fix(logs): log the webhook poll id and emitted event id under their own names

Webhook polls and Sim events logged their own generated ids as requestId, which the poll route's request context overwrites, so the ids never reached a log line. The orchestrator now binds each poll's id on the handler logger as pollId, handlers drop their per-line requestId fields, and the event emitter logs its per-event id as dispatchId. The ids passed downstream as each execution's request id are unchanged.

Author: waleedlatif1

.agents/skills/add-trigger/SKILL.md

@@ -423,6 +423,7 @@ export const {service}PollingHandler: PollingProviderHandler = {
 - First poll seeds state and emits nothing (avoids flooding with existing data)
 - Use `pollingIdempotency.executeWithIdempotency(provider, key, callback)` for dedup
 - Use `processPolledWebhookEvent(webhookData, workflowData, payload, requestId)` to fire the workflow
+- Log through `ctx.logger` (already bound with `webhookId` and `pollId`, which equals `ctx.requestId`). Never add `{ requestId }` to a log line; the poll route's request context owns that field and overwrites it
 - Use `updateWebhookProviderConfig(webhookId, partialConfig, logger)` for read-merge-write on state
 - Use the latest server-side timestamp from API responses (not wall clock) to avoid clock skew
 

apps/sim/lib/webhooks/polling/gmail.ts

@@ -77,12 +77,7 @@ export const gmailPollingHandler: PollingProviderHandler = {
       const config = getProviderConfig<GmailWebhookConfig>(webhookData.providerConfig)
       const now = new Date()
 
-      const { emails, latestHistoryId } = await fetchNewEmails(
-        accessToken,
-        config,
-        requestId,
-        logger
-      )
+      const { emails, latestHistoryId } = await fetchNewEmails(accessToken, config, logger)
       const pollState = {
         lastCheckedTimestamp: now.toISOString(),
         // Omit unless this poll held a cursor, so it can't clear one an overlapping poll stored.
@@ -92,11 +87,11 @@ export const gmailPollingHandler: PollingProviderHandler = {
       if (!emails || !emails.length) {
         await updateWebhookProviderConfig(webhookId, pollState, logger)
         await markWebhookSuccess(webhookId, logger)
-        logger.info(`No new emails found for webhook ${webhookId}`, { requestId })
+        logger.info(`No new emails found for webhook ${webhookId}`)
         return 'success'
       }
 
-      logger.info(`Found ${emails.length} new emails for webhook ${webhookId}`, { requestId })
+      logger.info(`Found ${emails.length} new emails for webhook ${webhookId}`)
 
       const { processedCount, failedCount } = await processEmails(
         emails,
@@ -112,35 +107,27 @@ export const gmailPollingHandler: PollingProviderHandler = {
 
       if (failedCount > 0 && processedCount === 0) {
         await markWebhookFailed(webhookId, logger)
-        logger.warn(`All ${failedCount} emails failed to process for webhook ${webhookId}`, {
-          requestId,
-        })
+        logger.warn(`All ${failedCount} emails failed to process for webhook ${webhookId}`)
         return 'failure'
       }
 
       await markWebhookSuccess(webhookId, logger)
       logger.info(
-        `Successfully processed ${processedCount} emails for webhook ${webhookId}${failedCount > 0 ? ` (${failedCount} failed)` : ''}`,
-        { requestId }
+        `Successfully processed ${processedCount} emails for webhook ${webhookId}${failedCount > 0 ? ` (${failedCount} failed)` : ''}`
       )
       return 'success'
     } catch (error) {
       if (error instanceof PollAdmissionRefusedError) {
-        return skipAdmissionRefusedPoll(logger, requestId, webhookId)
+        return skipAdmissionRefusedPoll(logger, webhookId)
       }
-      logger.error(`Error processing Gmail webhook ${webhookId}:`, error, { requestId })
+      logger.error(`Error processing Gmail webhook ${webhookId}:`, error)
       await markWebhookFailed(webhookId, logger)
       return 'failure'
     }
   },
 }
 
-async function fetchNewEmails(
-  accessToken: string,
-  config: GmailWebhookConfig,
-  requestId: string,
-  logger: Logger
-) {
+async function fetchNewEmails(accessToken: string, config: GmailWebhookConfig, logger: Logger) {
   try {
     const useHistoryApi = !!config.historyId
     let emails: GmailEmail[] = []
@@ -166,15 +153,13 @@ async function fetchNewEmails(
           if (status === 404 || status === 400) {
             await historyResponse.body?.cancel().catch(() => {})
             logger.info(
-              `Gmail rejected history cursor ${config.historyId} (${status}); resyncing through search`,
-              { requestId }
+              `Gmail rejected history cursor ${config.historyId} (${status}); resyncing through search`
             )
-            return resyncAfterExpiredHistory(accessToken, config, requestId, logger)
+            return resyncAfterExpiredHistory(accessToken, config, logger)
           }
 
           const errorData = await historyResponse.json().catch(() => ({}))
           logger.warn('Gmail history API error:', {
-            requestId,
             status,
             statusText: historyResponse.statusText,
             error: errorData,
@@ -186,8 +171,8 @@ async function fetchNewEmails(
             )
           }
 
-          logger.info(`Falling back to search API after history API error ${status}`, { requestId })
-          return searchEmails(accessToken, config, requestId, logger)
+          logger.info(`Falling back to search API after history API error ${status}`)
+          return searchEmails(accessToken, config, logger)
         }
 
         const historyData = await historyResponse.json()
@@ -215,14 +200,14 @@ async function fetchNewEmails(
 
       const sortedIds = [...messageIds].sort().reverse()
       const idsToFetch = sortedIds.slice(0, config.maxEmailsPerPoll || 25)
-      logger.info(`Processing ${idsToFetch.length} emails from history API`, { requestId })
+      logger.info(`Processing ${idsToFetch.length} emails from history API`)
 
       const emailResults = await Promise.allSettled(
         idsToFetch.map((messageId) => getEmailDetails(accessToken, messageId))
       )
       const rejected = emailResults.filter((r) => r.status === 'rejected')
       if (rejected.length > 0) {
-        logger.warn(`Failed to fetch ${rejected.length} email details`, { requestId })
+        logger.warn(`Failed to fetch ${rejected.length} email details`)
       }
       emails = emailResults
         .filter(
@@ -232,13 +217,13 @@ async function fetchNewEmails(
 
       emails = filterEmailsByLabels(emails, config)
     } else {
-      return searchEmails(accessToken, config, requestId, logger)
+      return searchEmails(accessToken, config, logger)
     }
 
     return { emails, latestHistoryId }
   } catch (error) {
     const errorMessage = getErrorMessage(error, 'Unknown error')
-    logger.error('Error fetching new emails:', errorMessage, { requestId })
+    logger.error('Error fetching new emails:', errorMessage)
     throw error
   }
 }
@@ -283,12 +268,7 @@ function buildGmailSearchQuery(config: {
   return baseQuery
 }
 
-async function searchEmails(
-  accessToken: string,
-  config: GmailWebhookConfig,
-  requestId: string,
-  logger: Logger
-) {
+async function searchEmails(accessToken: string, config: GmailWebhookConfig, logger: Logger) {
   try {
     const baseQuery = buildGmailSearchQuery(config)
     let timeConstraint = ''
@@ -324,7 +304,6 @@ async function searchEmails(
     if (!searchResponse.ok) {
       const errorData = await searchResponse.json()
       logger.error('Gmail search API error:', {
-        requestId,
         status: searchResponse.status,
         statusText: searchResponse.statusText,
         query,
@@ -338,24 +317,23 @@ async function searchEmails(
     const searchData = await searchResponse.json()
 
     if (!searchData.messages || !searchData.messages.length) {
-      logger.info(`No emails found matching query: ${query}`, { requestId })
+      logger.info(`No emails found matching query: ${query}`)
       return { emails: [], latestHistoryId: config.historyId }
     }
 
     const idsToFetch = searchData.messages.slice(0, config.maxEmailsPerPoll || 25)
     let latestHistoryId = config.historyId
 
     logger.info(
-      `Processing ${idsToFetch.length} emails from search API (total matches: ${searchData.messages.length})`,
-      { requestId }
+      `Processing ${idsToFetch.length} emails from search API (total matches: ${searchData.messages.length})`
     )
 
     const emailResults = await Promise.allSettled(
       idsToFetch.map((message: { id: string }) => getEmailDetails(accessToken, message.id))
     )
     const rejected = emailResults.filter((r) => r.status === 'rejected')
     if (rejected.length > 0) {
-      logger.warn(`Failed to fetch ${rejected.length} email details`, { requestId })
+      logger.warn(`Failed to fetch ${rejected.length} email details`)
     }
     const emails = emailResults
       .filter(
@@ -370,7 +348,7 @@ async function searchEmails(
     return { emails, latestHistoryId }
   } catch (error) {
     const errorMessage = getErrorMessage(error, 'Unknown error')
-    logger.error('Error searching emails:', errorMessage, { requestId })
+    logger.error('Error searching emails:', errorMessage)
     throw error
   }
 }
@@ -383,40 +361,36 @@ async function searchEmails(
 async function resyncAfterExpiredHistory(
   accessToken: string,
   config: GmailWebhookConfig,
-  requestId: string,
   logger: Logger
 ) {
-  const searchResult = await searchEmails(accessToken, config, requestId, logger)
+  const searchResult = await searchEmails(accessToken, config, logger)
   const candidate =
     searchResult.latestHistoryId !== config.historyId
       ? searchResult.latestHistoryId
-      : await getGmailProfileHistoryId(accessToken, requestId, logger)
+      : await getGmailProfileHistoryId(accessToken, logger)
   const latestHistoryId = candidate && candidate !== config.historyId ? candidate : undefined
   if (!latestHistoryId) {
-    logger.info('No replacement Gmail history cursor yet; polling through search', { requestId })
+    logger.info('No replacement Gmail history cursor yet; polling through search')
   }
   return { emails: searchResult.emails, latestHistoryId }
 }
 
 async function getGmailProfileHistoryId(
   accessToken: string,
-  requestId: string,
   logger: Logger
 ): Promise<string | null> {
   try {
     const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/profile', {
       headers: { Authorization: `Bearer ${accessToken}` },
     })
     if (!response.ok) {
-      logger.warn(`Failed to fetch Gmail profile for fresh historyId: ${response.status}`, {
-        requestId,
-      })
+      logger.warn(`Failed to fetch Gmail profile for fresh historyId: ${response.status}`)
       return null
     }
     const profile = await response.json()
     return (profile.historyId as string | undefined) ?? null
   } catch (error) {
-    logger.warn('Error fetching Gmail profile:', error, { requestId })
+    logger.warn('Error fetching Gmail profile:', error)
     return null
   }
 }
@@ -524,9 +498,7 @@ async function processEmails(
               const attachmentInfo = extractAttachmentInfo(payload)
               attachments = await downloadAttachments(email.id, attachmentInfo, accessToken)
             } catch (error) {
-              logger.error(`Error downloading attachments for email ${email.id}:`, error, {
-                requestId,
-              })
+              logger.error(`Error downloading attachments for email ${email.id}:`, error)
             }
           }
 
@@ -563,8 +535,7 @@ async function processEmails(
             logger.error(
               `Failed to process webhook for email ${email.id}:`,
               result.statusCode,
-              result.error,
-              { requestId }
+              result.error
             )
             throw new Error(`Webhook processing failed (${result.statusCode}): ${result.error}`)
           }
@@ -577,14 +548,12 @@ async function processEmails(
         }
       )
 
-      logger.info(`Successfully processed email ${email.id} for webhook ${webhookData.id}`, {
-        requestId,
-      })
+      logger.info(`Successfully processed email ${email.id} for webhook ${webhookData.id}`)
       processedCount++
     } catch (error) {
       if (error instanceof PollAdmissionRefusedError && processedCount === 0) throw error
       const errorMessage = getErrorMessage(error, 'Unknown error')
-      logger.error(`Error processing email ${email.id}:`, errorMessage, { requestId })
+      logger.error(`Error processing email ${email.id}:`, errorMessage)
       failedCount++
     }
   }

apps/sim/lib/webhooks/polling/google-calendar.ts

@@ -119,7 +119,7 @@ export const googleCalendarPollingHandler: PollingProviderHandler = {
           logger
         )
         await markWebhookSuccess(webhookId, logger)
-        logger.info(`First poll for webhook ${webhookId}, seeded timestamp`, { requestId })
+        logger.info(`First poll for webhook ${webhookId}, seeded timestamp`)
         return 'success'
       }
 
@@ -128,11 +128,11 @@ export const googleCalendarPollingHandler: PollingProviderHandler = {
 
       if (!events.length) {
         await markWebhookSuccess(webhookId, logger)
-        logger.info(`No changed events for webhook ${webhookId}`, { requestId })
+        logger.info(`No changed events for webhook ${webhookId}`)
         return 'success'
       }
 
-      logger.info(`Found ${events.length} changed events for webhook ${webhookId}`, { requestId })
+      logger.info(`Found ${events.length} changed events for webhook ${webhookId}`)
 
       const { processedCount, failedCount, latestUpdated } = await processEvents(
         events,
@@ -162,23 +162,20 @@ export const googleCalendarPollingHandler: PollingProviderHandler = {
 
       if (failedCount > 0 && processedCount === 0) {
         await markWebhookFailed(webhookId, logger)
-        logger.warn(`All ${failedCount} events failed to process for webhook ${webhookId}`, {
-          requestId,
-        })
+        logger.warn(`All ${failedCount} events failed to process for webhook ${webhookId}`)
         return 'failure'
       }
 
       await markWebhookSuccess(webhookId, logger)
       logger.info(
-        `Successfully processed ${processedCount} events for webhook ${webhookId}${failedCount > 0 ? ` (${failedCount} failed)` : ''}`,
-        { requestId }
+        `Successfully processed ${processedCount} events for webhook ${webhookId}${failedCount > 0 ? ` (${failedCount} failed)` : ''}`
       )
       return 'success'
     } catch (error) {
       if (error instanceof PollAdmissionRefusedError) {
-        return skipAdmissionRefusedPoll(logger, requestId, webhookId)
+        return skipAdmissionRefusedPoll(logger, webhookId)
       }
-      logger.error(`Error processing Google Calendar webhook ${webhookId}:`, error, { requestId })
+      logger.error(`Error processing Google Calendar webhook ${webhookId}:`, error)
       await markWebhookFailed(webhookId, logger)
       return 'failure'
     }
@@ -341,8 +338,7 @@ async function processEvents(
             logger.error(
               `Failed to process webhook for event ${event.id}:`,
               result.statusCode,
-              result.error,
-              { requestId }
+              result.error
             )
             throw new Error(`Webhook processing failed (${result.statusCode}): ${result.error}`)
           }
@@ -351,14 +347,12 @@ async function processEvents(
         }
       )
 
-      logger.info(`Successfully processed event ${event.id} for webhook ${webhookData.id}`, {
-        requestId,
-      })
+      logger.info(`Successfully processed event ${event.id} for webhook ${webhookData.id}`)
       processedCount++
     } catch (error) {
       if (error instanceof PollAdmissionRefusedError && processedCount === 0) throw error
       const errorMessage = getErrorMessage(error, 'Unknown error')
-      logger.error(`Error processing event ${event.id}:`, errorMessage, { requestId })
+      logger.error(`Error processing event ${event.id}:`, errorMessage)
       failedCount++
     }
   }