From 8b2af8164aceac2f71bc02cf4b39c8d2f25eaca1 Mon Sep 17 00:00:00 2001
From: Bas van den Aakster <bvdaakster@gmail.com>
Date: Sat, 20 Sep 2025 20:24:34 +0200
Subject: [PATCH] Remove verbose debug logs from immediate processing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Reduced log noise while keeping essential error logging
- Only show job polling logs after 2 attempts (to catch real issues)
- Keep the main job scheduling confirmation log
- Immediate processing success is now at debug level

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 src/sendEmail.ts            | 11 ++++-------
 src/utils/emailProcessor.ts |  8 +-------
 src/utils/jobScheduler.ts   | 18 +++---------------
 3 files changed, 8 insertions(+), 29 deletions(-)

diff --git a/src/sendEmail.ts b/src/sendEmail.ts
index b5cfb4d..710b809 100644
--- a/src/sendEmail.ts
+++ b/src/sendEmail.ts
@@ -139,7 +139,6 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
   // If processImmediately is true, get the job from the relationship and process it now
   if (options.processImmediately) {
     const logger = createContextLogger(payload, 'IMMEDIATE')
-    logger.debug(`Starting immediate processing for email ${email.id}`)
 
     if (!payload.jobs) {
       throw new Error('PayloadCMS jobs not configured - cannot process email immediately')
@@ -153,7 +152,6 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
     const startTime = Date.now()
     let jobId: string | undefined
 
-    logger.debug(`Polling for job creation (max ${maxAttempts} attempts, ${maxTotalTime}ms timeout)`)
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       // Check total timeout before continuing
@@ -178,19 +176,19 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
         id: email.id,
       })
 
-      logger.debug(`Attempt ${attempt + 1}/${maxAttempts}: Found ${emailWithJobs.jobs?.length || 0} jobs for email ${email.id}`)
 
       if (emailWithJobs.jobs && emailWithJobs.jobs.length > 0) {
         // Job found! Get the first job ID (should only be one for a new email)
         const firstJob = Array.isArray(emailWithJobs.jobs) ? emailWithJobs.jobs[0] : emailWithJobs.jobs
         jobId = typeof firstJob === 'string' ? firstJob : String(firstJob.id || firstJob)
-        logger.info(`Found job ID: ${jobId}`)
         break
       }
 
       // Log on later attempts to help with debugging (reduced threshold)
       if (attempt >= 1) {
-        logger.debug(`Waiting for job creation for email ${email.id}, attempt ${attempt + 1}/${maxAttempts}`)
+        if (attempt >= 2) {
+          logger.debug(`Waiting for job creation for email ${email.id}, attempt ${attempt + 1}/${maxAttempts}`)
+        }
       }
     }
 
@@ -212,10 +210,9 @@ export const sendEmail = async <TEmail extends BaseEmailDocument = BaseEmailDocu
       )
     }
 
-    logger.info(`Starting job execution for job ${jobId}`)
     try {
       await processJobById(payload, jobId)
-      logger.info(`Successfully processed email ${email.id} immediately`)
+      logger.debug(`Successfully processed email ${email.id} immediately`)
     } catch (error) {
       logger.error(`Failed to process email ${email.id} immediately:`, error)
       throw new Error(`Failed to process email ${email.id} immediately: ${String(error)}`)
diff --git a/src/utils/emailProcessor.ts b/src/utils/emailProcessor.ts
index 1977670..2820fd0 100644
--- a/src/utils/emailProcessor.ts
+++ b/src/utils/emailProcessor.ts
@@ -37,16 +37,11 @@ export async function processEmailById(payload: Payload, emailId: string): Promi
  * @returns Promise that resolves when job is processed
  */
 export async function processJobById(payload: Payload, jobId: string): Promise<void> {
-  const logger = createContextLogger(payload, 'PROCESSOR')
-  logger.debug(`Starting processJobById for job ${jobId}`)
-
   if (!payload.jobs) {
     throw new Error('PayloadCMS jobs not configured - cannot process job immediately')
   }
 
   try {
-    logger.debug(`Running job ${jobId} with payload.jobs.run()`)
-
     // Run a specific job by its ID (using where clause to find the job)
     const result = await payload.jobs.run({
       where: {
@@ -55,9 +50,8 @@ export async function processJobById(payload: Payload, jobId: string): Promise<v
         }
       }
     })
-
-    logger.info(`Job ${jobId} execution completed`, { result })
   } catch (error) {
+    const logger = createContextLogger(payload, 'PROCESSOR')
     logger.error(`Job ${jobId} execution failed:`, error)
     throw new Error(`Failed to process job ${jobId}: ${String(error)}`)
   }
diff --git a/src/utils/jobScheduler.ts b/src/utils/jobScheduler.ts
index ff7fc5b..6d09751 100644
--- a/src/utils/jobScheduler.ts
+++ b/src/utils/jobScheduler.ts
@@ -49,15 +49,12 @@ export async function ensureEmailJob(
   const queueName = options?.queueName || mailingContext?.config?.queue || 'default'
 
   const logger = createContextLogger(payload, 'JOB_SCHEDULER')
-  logger.debug(`Ensuring job for email ${normalizedEmailId}`)
-  logger.debug(`Queue: ${queueName}, scheduledAt: ${options?.scheduledAt || 'immediate'}`)
 
   // First, optimistically try to create the job
   // If it fails due to uniqueness constraint, then check for existing jobs
   // This approach minimizes the race condition window
 
   try {
-    logger.debug(`Attempting to create new job for email ${normalizedEmailId}`)
     // Attempt to create job - rely on database constraints for duplicate prevention
     const job = await payload.jobs.queue({
       queue: queueName,
@@ -69,31 +66,22 @@ export async function ensureEmailJob(
     })
 
     logger.info(`Auto-scheduled processing job ${job.id} for email ${normalizedEmailId}`)
-    logger.debug(`Job details`, {
-      jobId: job.id,
-      emailId: normalizedEmailId,
-      scheduledAt: options?.scheduledAt || 'immediate',
-      task: 'process-email',
-      queue: queueName
-    })
 
     return {
       jobIds: [job.id],
       created: true
     }
   } catch (createError) {
-    logger.warn(`Job creation failed for email ${normalizedEmailId}: ${String(createError)}`)
 
     // Job creation failed - likely due to duplicate constraint or system issue
 
     // Check if duplicate jobs exist (handles race condition where another process created job)
     const existingJobs = await findExistingJobs(payload, normalizedEmailId)
 
-    logger.debug(`Found ${existingJobs.totalDocs} existing jobs after creation failure`)
 
     if (existingJobs.totalDocs > 0) {
       // Found existing jobs - return them (race condition handled successfully)
-      logger.info(`Using existing jobs for email ${normalizedEmailId}: ${existingJobs.docs.map(j => j.id).join(', ')}`)
+      logger.debug(`Using existing jobs for email ${normalizedEmailId}: ${existingJobs.docs.map(j => j.id).join(', ')}`)
       return {
         jobIds: existingJobs.docs.map(job => job.id),
         created: false
@@ -109,7 +97,7 @@ export async function ensureEmailJob(
 
     if (isLikelyUniqueConstraint) {
       // This should not happen if our check above worked, but provide a clear error
-      logger.error(`Unique constraint violation but no existing jobs found for email ${normalizedEmailId}`)
+      logger.warn(`Unique constraint violation but no existing jobs found for email ${normalizedEmailId}`)
       throw new Error(
         `Database uniqueness constraint violation for email ${normalizedEmailId}, but no existing jobs found. ` +
         `This indicates a potential data consistency issue. Original error: ${errorMessage}`
@@ -117,7 +105,7 @@ export async function ensureEmailJob(
     }
 
     // Non-constraint related error
-    logger.error(`Non-constraint job creation error for email ${normalizedEmailId}: ${errorMessage}`)
+    logger.error(`Job creation error for email ${normalizedEmailId}: ${errorMessage}`)
     throw new Error(`Failed to create job for email ${normalizedEmailId}: ${errorMessage}`)
   }
 }