@peopl-health/nexus 2.4.7 → 2.4.9-fix-pdf-processing

package/lib/controllers/patientController.js

@@ -1,5 +1,6 @@
 const { getRecordByFilter } = require('../services/airtableService');
 const { Monitoreo_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 const getPatientInfoController = async (req, res) => {
   try {
@@ -15,7 +16,7 @@ const getPatientInfoController = async (req, res) => {
     const clinicalContext = records[0]['clinical-context-json'];
     res.status(200).json({ success: true, whatsappId: id, clinicalContext, patientInfo: records[0] });
   } catch (error) {
-    console.error('Error fetching patient info:', error);
+    logger.error('Error fetching patient info:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };

package/lib/controllers/qualityMessageController.js

@@ -1,5 +1,6 @@
 const { QualityMessage } = require('../models/qualityMessageModel');
 const { Message } = require('../models/messageModel');
+const { logger } = require('../utils/logger');
 
 const addQualityVoteController = async (req, res) => {
   try {
@@ -22,7 +23,7 @@ const addQualityVoteController = async (req, res) => {
 
     res.status(201).json({ success: true, qualityVote });
   } catch (error) {
-    console.error('Error adding quality vote:', error);
+    logger.error('Error adding quality vote:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };
@@ -41,7 +42,7 @@ const getQualityVotesByMessageController = async (req, res) => {
 
     res.status(200).json({ success: true, messageId: message_id, summary, votes });
   } catch (error) {
-    console.error('Error fetching quality votes:', error);
+    logger.error('Error fetching quality votes:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };
@@ -52,7 +53,7 @@ const getQualityVotesByVoterController = async (req, res) => {
     const votes = await QualityMessage.find({ voter_username }).populate('message_id').sort({ createdAt: -1 });
     res.status(200).json({ success: true, voterUsername: voter_username, count: votes.length, votes });
   } catch (error) {
-    console.error('Error fetching voter quality votes:', error);
+    logger.error('Error fetching voter quality votes:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };
@@ -68,7 +69,7 @@ const getQualityVoteByMessageAndVoterController = async (req, res) => {
     
     res.status(200).json({ success: true, vote });
   } catch (error) {
-    console.error('Error fetching quality vote:', error);
+    logger.error('Error fetching quality vote:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };

package/lib/controllers/templateController.js

@@ -1,3 +1,5 @@
+const { logger } = require('../utils/logger');
+
 // Check if provider supports templates
 const checkTemplateSupport = () => {
   if (!nexusProvider) {
@@ -29,7 +31,7 @@ const configureNexusProvider = (provider) => {
     try {
       configureTemplateProvider(provider);
     } catch (err) {
-      console.warn('[templateController] Failed to propagate provider to template structure:', err?.message || err);
+      logger.warn('[templateController] Failed to propagate provider to template structure:', err?.message || err);
     }
   }
 };
@@ -132,7 +134,7 @@ const createTemplate = async (req, res) => {
     
     // Make sure the dates are valid before saving
     if (isNaN(dateCreated.getTime())) {
-      console.log('Invalid dateCreated, using current date');
+      logger.info('Invalid dateCreated, using current date');
       dateCreated = currentDate;
     }
     
@@ -182,8 +184,8 @@ const listTemplates = async (req, res) => {
     const { status: queryStatus, type, limit = 50, showFlows: queryShowFlows } = req.query;
     const TemplateModel = getTemplateModel();
 
-    console.log('nexusProvider:', nexusProvider ? 'configured' : 'not configured');
-    console.log('nexusProvider methods:', nexusProvider ? Object.keys(nexusProvider) : 'none');
+    logger.info('nexusProvider:', nexusProvider ? 'configured' : 'not configured');
+    logger.info('nexusProvider methods:', nexusProvider ? Object.keys(nexusProvider) : 'none');
     
     checkTemplateSupport();
     const twilioRawTemplates = await nexusProvider.listTemplates({ limit: parseInt(limit, 10) });
@@ -224,7 +226,7 @@ const listTemplates = async (req, res) => {
           else if (reqData.status === 'PENDING') updateFields.status = 'PENDING';
         }
       } catch (err) {
-        console.warn(`Could not fetch approval status for template ${twilioTemplate.sid}:`, err.message);
+        logger.warn(`Could not fetch approval status for template ${twilioTemplate.sid}:`, err.message);
       }
 
       const onInsertFields = {
@@ -281,7 +283,7 @@ const listTemplates = async (req, res) => {
     });
 
   } catch (error) {
-    console.error('Error in listTemplates:', error);
+    logger.error('Error in listTemplates:', error);
     return handleApiError(res, error, 'Failed to list templates');
   }
 };
@@ -557,7 +559,7 @@ const getPredefinedTemplates = (req, res) => {
     });
         
   } catch (error) {
-    console.error('Error getting predefined templates:', error);
+    logger.error('Error getting predefined templates:', error);
     res.status(500).json({
       success: false,
       error: 'Failed to retrieve predefined templates',
@@ -584,7 +586,7 @@ const getCompleteTemplate = async (req, res) => {
       try {
         checkTemplateSupport();
         const twilioTemplate = await nexusProvider.getTemplate(sid);
-        console.log('Fetched template from Twilio:', twilioTemplate);
+        logger.info('Fetched template from Twilio:', twilioTemplate);
         
         let body = '';
         let footer = '';
@@ -659,7 +661,7 @@ const getCompleteTemplate = async (req, res) => {
           template.type = type;
         }
       } catch (twilioError) {
-        console.error('Error fetching complete template from Twilio:', twilioError);
+        logger.error('Error fetching complete template from Twilio:', twilioError);
       }
     }
     

package/lib/controllers/uploadController.js

@@ -1,6 +1,8 @@
 const multer = require('multer');
 const { v4: uuidv4 } = require('uuid');
 const { generatePresignedUrl, uploadBufferToS3 } = require('../config/awsConfig');
+const { logger } = require('../utils/logger');
+
 const bucketName = process.env.AWS_S3_BUCKET_NAME;
 
 const storage = multer.memoryStorage();
@@ -66,7 +68,7 @@ const handleFileUpload = async (req, res) => {
       contentType: file.mimetype
     });
   } catch (error) {
-    console.error('Error uploading file:', error);
+    logger.error('Error uploading file:', error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to upload file'

package/lib/core/NexusMessaging.js

@@ -3,6 +3,7 @@ const { addMsgAssistant, replyAssistant } = require('../services/assistantServic
 const { createProvider } = require('../adapters/registry');
 const runtimeConfig = require('../config/runtimeConfig');
 const { hasPreprocessingHandler, invokePreprocessingHandler } = require('../services/preprocessingHooks');
+const { logger } = require('../utils/logger');
 
 const mongoose = require('mongoose');
 const OpenAI = require('openai');
@@ -58,9 +59,9 @@ class NexusMessaging {
     try {
       await mongoose.connect(mongoUri);
       this.mongodb = mongoose.connection;
-      console.log('MongoDB connected successfully');
+      logger.info('MongoDB connected successfully');
     } catch (error) {
-      console.error('MongoDB connection failed:', error);
+      logger.error('MongoDB connection failed', { error: error.message });
       throw error;
     }
   }
@@ -359,7 +360,7 @@ class NexusMessaging {
       return await this.handleFlow(messageData);
     } else {
       // For regular messages and media, use batching if enabled
-      console.log('Batching config:', this.batchingConfig);
+      logger.info('Batching config:', this.batchingConfig);
       if (this.batchingConfig.enabled && chatId) {
         return await this._handleWithBatching(messageData, chatId);
       } else {
@@ -437,7 +438,7 @@ class NexusMessaging {
       }
 
       if (!from || !body) {
-        console.warn('Unable to resolve assistant inputs from message, skipping automatic reply.');
+        logger.warn('Unable to resolve assistant inputs from message, skipping automatic reply.');
         return;
       }
 
@@ -452,7 +453,7 @@ class NexusMessaging {
         });
       }
     } catch (error) {
-      console.error('Error in handleMessageWithAssistant:', error);
+      logger.error('Error in handleMessageWithAssistant:', error);
     }
   }
 
@@ -488,7 +489,7 @@ class NexusMessaging {
       const { from, body } = this._extractAssistantInputs(messageData);
 
       if (!from) {
-        console.warn('Unable to resolve sender for media message, skipping automatic reply.');
+        logger.warn('Unable to resolve sender for media message, skipping automatic reply.');
         return;
       }
 
@@ -516,7 +517,7 @@ class NexusMessaging {
         });
       }
     } catch (error) {
-      console.error('Error in handleMediaWithAssistant:', error);
+      logger.error('Error in handleMediaWithAssistant:', error);
     }
   }
 
@@ -530,16 +531,15 @@ class NexusMessaging {
 
       const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME') || process.env.AWS_S3_BUCKET_NAME;
       if (!bucketName) {
-        console.warn('[NexusMessaging] AWS_S3_BUCKET_NAME not configured. Skipping media persistence.');
+        logger.warn('[NexusMessaging] AWS_S3_BUCKET_NAME not configured. Skipping media persistence.');
         return;
       }
 
       const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor');
-      const { logger } = require('../utils/logger');
-      const mediaItems = await processTwilioMediaMessage(raw, logger, bucketName);
+      const mediaItems = await processTwilioMediaMessage(raw, bucketName);
 
       if (!mediaItems || mediaItems.length === 0) {
-        console.warn('[NexusMessaging] Media processing returned no items for incoming message.');
+        logger.warn('[NexusMessaging] Media processing returned no items for incoming message.');
         return;
       }
 
@@ -573,13 +573,13 @@ class NexusMessaging {
         values.media = mediaPayload;
 
         await insertMessage(values);
-        console.log('[NexusMessaging] Media message stored via legacy inserter', {
+        logger.info('[NexusMessaging] Media message stored via legacy inserter', {
           messageId: values.message_id,
           numero: values.numero
         });
       }
     } catch (error) {
-      console.error('[NexusMessaging] Failed to ensure media persistence:', error);
+      logger.error('[NexusMessaging] Failed to ensure media persistence:', error);
     }
   }
 
@@ -618,7 +618,7 @@ class NexusMessaging {
     // Clear existing timeout if there is one
     if (this.pendingResponses.has(chatId)) {
       clearTimeout(this.pendingResponses.get(chatId));
-      console.log(`Received additional message from ${chatId}, resetting wait timer`);
+      logger.info(`Received additional message from ${chatId}, resetting wait timer`);
     }
     
     // Calculate wait time with random variation
@@ -631,12 +631,12 @@ class NexusMessaging {
         this.pendingResponses.delete(chatId);
         await this._handleBatchedMessages(chatId);
       } catch (error) {
-        console.error(`Error handling batched messages for ${chatId}:`, error);
+        logger.error(`Error handling batched messages for ${chatId}:`, error);
       }
     }, waitTime);
     
     this.pendingResponses.set(chatId, timeoutId);
-    console.log(`Waiting ${Math.round(waitTime/1000)} seconds for more messages from ${chatId}`);
+    logger.info(`Waiting ${Math.round(waitTime/1000)} seconds for more messages from ${chatId}`);
   }
 
   /**
@@ -644,7 +644,7 @@ class NexusMessaging {
    */
   async _handleBatchedMessages(chatId) {
     try {
-      console.log(`Processing batched messages from ${chatId} (including media if any)`);
+      logger.info(`Processing batched messages from ${chatId} (including media if any)`);
       
       // Get assistant response
       const botResponse = await replyAssistant(chatId);
@@ -661,7 +661,7 @@ class NexusMessaging {
       this.events.emit('messages:batched', { chatId, response: botResponse });
       
     } catch (error) {
-      console.error('Error in batched message handling:', error);
+      logger.error('Error in batched message handling:', error);
     }
   }
 

package/lib/helpers/assistantHelper.js

@@ -5,7 +5,7 @@ const { createProvider } = require('../providers/createProvider.js');
 const { withTracing } = require('../utils/tracingDecorator');
 
 const { getRecordByFilter } = require('../services/airtableService.js');
-const { logger } = require('../middleware/requestId');
+const { logger } = require('../utils/logger');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
@@ -28,7 +28,7 @@ async function checkIfFinished(text) {
     
     return completion.choices[0].message.content;
   } catch (error) {
-    console.error('[checkIfFinished] Error checking run status:', error);
+    logger.error('[checkIfFinished] Error checking run status:', error);
   }
 }
 
@@ -78,7 +78,7 @@ const runAssistantAndWait = async ({
   let completed = false;
 
   try {
-    logger.log('[runAssistantAndWait] RUN ID', run.id, 'THREAD ID', thread.getConversationId(), 'ASSISTANT ID', thread.getAssistantId());
+    logger.info('[runAssistantAndWait] Run started', { runId: run.id, threadId: thread.getConversationId(), assistantId: thread.getAssistantId() });
     ({run, completed} = await provider.checkRunStatus(assistant, thread.getConversationId(), run.id, 0, maxRetries));
   } finally {
     if (filter) {
@@ -102,7 +102,7 @@ const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumb
     runConfig
   });
   
-  logger.log(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
+  logger.info(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
   
   return result;
 };
@@ -135,17 +135,16 @@ const runAssistantWithRetries = async (thread, assistant, runConfig, patientRepl
       const delay = retries === 1 
         ? 500
         : Math.min(1000 * Math.pow(1.5, retries - 1), 5000);
-      logger.log(`[runAssistantWithRetries] Retry ${retries}, waiting ${delay}ms`);
+      logger.info(`[runAssistantWithRetries] Retry ${retries}, waiting ${delay}ms`);
       await new Promise(resolve => setTimeout(resolve, delay));
     }
   } while (retries < maxRetries && (!completed || !output));
 
   const predictionTimeMs = Date.now() - startTime;
 
-  if (run?.last_error) logger.log('[runAssistantWithRetries] RUN LAST ERROR:', run.last_error);
-  logger.log('[runAssistantWithRetries] RUN STATUS', completed);
-  logger.log('[runAssistantWithRetries] OUTPUT', output);
-  logger.log('[runAssistantWithRetries] TIMING', { predictionTimeMs, retries });
+  if (run?.last_error) logger.warn('[runAssistantWithRetries] Run error', { error: run.last_error });
+  logger.info('[runAssistantWithRetries] Run completed', { completed, outputLength: output?.length || 0 });
+  logger.info('[runAssistantWithRetries] TIMING', { predictionTimeMs, retries });
   
   return { run, output, completed, retries, predictionTimeMs };
 };

package/lib/helpers/baileysHelper.js

@@ -2,6 +2,7 @@ const { Message, insertMessage, getMessageValues } = require('../models/messageM
 const { uploadMediaToS3 } = require('./mediaHelper.js');
 const { isRecentMessage } = require('./messageHelper.js');
 const { downloadMediaMessage } = require('baileys');
+const { logger } = require('../utils/logger');
 
 
 async function processMessage(message, messageType) {
@@ -19,7 +20,7 @@ async function processMessage(message, messageType) {
 
     return values;
   } catch (error) {
-    console.log('Failed to process message: %s', error.stack);
+    logger.error('Failed to process message', { error: error.message, stack: error.stack });
     throw error;
   }
 }
@@ -44,7 +45,7 @@ async function processMediaMessage(message, logger, messageType, bucketName, soc
 
     return values;
   } catch (error) {
-    console.log('Failed to process message: %s', error.stack);
+    logger.error('Failed to process message', { error: error.message, stack: error.stack });
     throw error;
   }
 }
@@ -128,7 +129,7 @@ async function downloadMedia(message, logger, sock) {
     );
     return buffer;
   } catch (error) {
-    console.log('Failed to download media:', error.stack);
+    logger.error('Failed to download media', { error: error.message, stack: error.stack });
     throw error;
   }
 }

package/lib/helpers/filesHelper.js

@@ -7,22 +7,29 @@ const sharp = require('sharp');
 const { downloadFileFromS3 } = require('../config/awsConfig.js');
 const { Message } = require('../models/messageModel.js');
 const { sanitizeFilename } = require('../utils/sanitizer.js');
+const { logger } = require('../utils/logger');
 
-async function convertPdfToImages(pdfName) {
+async function convertPdfToImages(pdfName, existingPdfPath = null) {
   const outputDir = path.join(__dirname, 'assets', 'tmp');
   
   const sanitizedName = sanitizeFilename(pdfName);
-  const pdfPath = path.join(outputDir, `${sanitizedName}.pdf`);
+  const pdfPath = existingPdfPath || path.join(outputDir, `${sanitizedName}.pdf`);
   const outputPattern = path.join(outputDir, sanitizedName);
 
   await fs.mkdir(outputDir, { recursive: true });
 
   return new Promise((resolve, reject) => {
     const args = ['-jpeg', pdfPath, outputPattern];
-    console.log('[convertPdfToImages] Running: pdftoppm', args.join(' '));
+    logger.info('[convertPdfToImages] Running: pdftoppm', args.join(' '));
     
     execFile('pdftoppm', args, (error, stdout, stderr) => {
       if (error) {
+        logger.error('[convertPdfToImages] Error details:', { 
+          error: error.message, 
+          stderr, 
+          pdfPath,
+          pdfExists: require('fs').existsSync(pdfPath)
+        });
         return reject(new Error(`Error splitting PDF: ${stderr || error.message}`));
       }
 
@@ -71,7 +78,7 @@ async function combineImagesToPDF(config) {
     imageFiles.sort();
   }
   
-  console.log(`Found ${imageFiles.length} image files to combine`);
+  logger.info(`Found ${imageFiles.length} image files to combine`);
     
   const pdfDoc = await PDFDocument.create();
   const processedFiles = [];
@@ -79,7 +86,7 @@ async function combineImagesToPDF(config) {
   for (const [index, file] of imageFiles.entries()) {
     try {
       const filePath = path.join(inputDir, file);
-      console.log(`Processing file ${index + 1}/${imageFiles.length}: ${file}`);
+      logger.info(`Processing file ${index + 1}/${imageFiles.length}: ${file}`);
             
       const imageBuffer = await fs.readFile(filePath);
       const pngBuffer = await sharp(imageBuffer)
@@ -99,11 +106,11 @@ async function combineImagesToPDF(config) {
 
       processedFiles.push(filePath);
     } catch (error) {
-      console.error(`Error processing file ${file}:`, error);
+      logger.error(`Error processing file ${file}:`, error);
     }
   }
     
-  console.log('Combined PDF created successfully');
+  logger.info('Combined PDF created successfully');
     
   return {
     pdfBuffer: await pdfDoc.save(),
@@ -120,12 +127,12 @@ const cleanupFiles = async (files) => {
     } catch (error) {
       if (error?.code !== 'ENOENT') {
         const safeFileName = filePath ? filePath.split('/').pop().replace(/^[^-]+-[^-]+-/, 'xxx-xxx-') : 'unknown';
-        console.warn(`[cleanupFiles] Error deleting ${safeFileName}:`, error?.message || String(error));
+        logger.warn(`[cleanupFiles] Error deleting ${safeFileName}:`, error?.message || String(error));
       }
     }
   }));
   
-  console.log(`[cleanupFiles] Cleaned up ${files.length} files`);
+  logger.info(`[cleanupFiles] Cleaned up ${files.length} files`);
 };
 
 async function downloadMediaAndCreateFile(code, reply) {
@@ -138,7 +145,7 @@ async function downloadMediaAndCreateFile(code, reply) {
   if (!resultMedia) return [];
 
   if (!resultMedia.media || !resultMedia.media.key) {
-    console.log('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
+    logger.info('[downloadMediaAndCreateFile] No valid media found for message:', reply.message_id);
     return [];
   }
 
@@ -147,19 +154,21 @@ async function downloadMediaAndCreateFile(code, reply) {
   
   const [subType, fileName] = key.split('/');
   
-  const sanitizedCode = sanitizeFilename(code);
-  const sanitizedSubType = sanitizeFilename(subType);
-  const sanitizedFileName = sanitizeFilename(fileName);
+  const sanitizedCode = sanitizeFilename(code, 20);
+  const sanitizedSubType = sanitizeFilename(subType, 10);
+  const sanitizedFileName = sanitizeFilename(fileName, 50);
   
   const sourceFile = `${sanitizedCode}-${sanitizedSubType}-${sanitizedFileName}`;
   const downloadPath = path.join(__dirname, 'assets', 'tmp', sourceFile);
   
+  logger.info('[downloadMediaAndCreateFile] Downloading file', { sourceFile, downloadPath, bucketName, key });
+  
   await fs.mkdir(path.dirname(downloadPath), { recursive: true });
   await downloadFileFromS3(bucketName, key, downloadPath);
 
   const { name: baseName } = path.parse(sourceFile);
   const fileNames = (subType === 'document' ||  subType === 'application')
-    ? await convertPdfToImages(baseName)
+    ? await convertPdfToImages(baseName, downloadPath)
     : [downloadPath];
 
   if (subType === 'document' ||  subType === 'application') {

package/lib/helpers/llmsHelper.js

@@ -1,13 +1,14 @@
 const llmConfig = require('../config/llmConfig.js');
+const { logger } = require('../utils/logger');
 const fs = require('fs');
 const mime = require('mime-types');
 
 
-async function analyzeImage(imagePath, isSticker = false) {
+async function analyzeImage(imagePath, isSticker = false, contentType = null) {
   try {
     const anthropicClient = llmConfig.anthropicClient;
     if (!anthropicClient || !anthropicClient.messages) {
-      console.warn('[llmsHelper] Anthropics client not configured; skipping image analysis');
+      logger.warn('[llmsHelper] Anthropics client not configured; skipping image analysis');
       return {
         description: 'Image could not be analyzed - Anthropic client not configured',
         medical_analysis: 'QUALITY_INSUFFICIENT',
@@ -19,7 +20,7 @@ async function analyzeImage(imagePath, isSticker = false) {
 
     // Skip only WBMP images (unsupported format)
     if (imagePath.toLowerCase().includes('.wbmp')) {
-      console.log('Skipping WBMP image analysis:', imagePath);
+      logger.info('Skipping WBMP image or sticker analysis:', imagePath);
       return {
         description: 'Unsupported image format',
         medical_analysis: 'NOT_MEDICAL',
@@ -29,10 +30,16 @@ async function analyzeImage(imagePath, isSticker = false) {
       };
     }
     
-    // Check MIME type
-    const mimeType = mime.lookup(imagePath) || 'image/jpeg';
+    let mimeType = contentType;
+    if (!mimeType) {
+      if (imagePath.toLowerCase().endsWith('.webp')) {
+        mimeType = 'image/webp';
+      } else {
+        mimeType = mime.lookup(imagePath) || 'image/jpeg';
+      }
+    }
     if (mimeType === 'image/vnd.wap.wbmp') {
-      console.log('Skipping image with MIME type:', mimeType);
+      logger.info('Skipping image with MIME type:', mimeType);
       return {
         description: 'Unsupported image format',
         medical_analysis: 'NOT_MEDICAL',
@@ -113,7 +120,7 @@ Only extract tables - ignore any other content in the image.`;
               type: 'image',
               source: {
                 type: 'base64',
-                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                media_type: mimeType,
                 data: base64Image,
               },
             },
@@ -180,7 +187,7 @@ Ejemplo 1:
               type: 'image',
               source: {
                 type: 'base64',
-                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                media_type: mimeType,
                 data: base64Image,
               },
             },
@@ -208,7 +215,7 @@ Ejemplo 1:
               type: 'image',
               source: {
                 type: 'base64',
-                media_type: mime.lookup(imagePath) || 'image/jpeg',
+                media_type: mimeType,
                 data: base64Image,
               },
             },
@@ -231,7 +238,7 @@ Ejemplo 1:
     return {description: description, medical_analysis: messageAnalysisStr, 
       medical_relevance: isRelevant, has_table: isTable, table_data: table};
   } catch (error) {
-    console.error('Error analyzing image:', error);
+    logger.error('Error analyzing image:', error);
     throw error;
   }
 }

package/lib/helpers/mediaHelper.js

@@ -2,6 +2,7 @@ const path = require('path');
 const fs = require('fs');
 const AWS = require('../config/awsConfig.js');
 const { sanitizeMediaFilename } = require('../utils/sanitizer.js');
+const { logger } = require('../utils/logger');
 
 async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, contentType, messageType) {
   const extension = getFileExtension(contentType);
@@ -9,13 +10,13 @@ async function uploadMediaToS3(buffer, messageID, titleFile, bucketName, content
   const fileName = sanitizedTitle 
     ? `${messageType}/${messageID}_${sanitizedTitle}.${extension}`
     : `${messageType}/${messageID}.${extension}`;
-  console.log(titleFile, messageType);
+  logger.info(titleFile, messageType);
     
   try {
     await AWS.uploadBufferToS3(buffer, bucketName, fileName, contentType);
     return fileName;
   } catch (error) {
-    console.error('Failed to upload media to S3:', error.stack);
+    logger.error('Failed to upload media to S3:', error.stack);
     throw error;
   }
 }