@peopl-health/nexus 2.4.6 → 2.4.8

package/lib/controllers/conversationController.js

@@ -5,12 +5,13 @@ const { Thread } = require('../models/threadModel');
 const llmConfig = require('../config/llmConfig');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 const { getRecordByFilter } = require('../services/airtableService');
+const { logger } = require('../utils/logger');
 
 const Message = mongoose.models.Message;
 
 const getConversationController = async (req, res) => {
   const startTime = Date.now();
-  console.log('Starting getConversationController at', new Date().toISOString());
+  logger.info('Starting getConversationController at', new Date().toISOString());
 
   try {
     // Parse pagination parameters
@@ -19,10 +20,10 @@ const getConversationController = async (req, res) => {
     const skip = (page - 1) * limit;
     const filter = req.query.filter || 'all';
 
-    console.log(`Pagination: page ${page}, limit ${limit}, skip ${skip}, filter: ${filter}`);
+    logger.info(`Pagination: page ${page}, limit ${limit}, skip ${skip}, filter: ${filter}`);
 
     if (!Message) {
-      console.log('Message model not found, returning empty conversations list');
+      logger.info('Message model not found, returning empty conversations list');
       return res.status(200).json({
         success: true,
         conversations: [],
@@ -31,10 +32,10 @@ const getConversationController = async (req, res) => {
     }
     
     const messageCount = await Message.countDocuments({});
-    console.log('Total message count:', messageCount);
+    logger.info('Total message count:', messageCount);
     
     if (messageCount === 0) {
-      console.log('No messages found in database, returning empty conversations list');
+      logger.info('No messages found in database, returning empty conversations list');
       return res.status(200).json({
         success: true,
         conversations: [],
@@ -46,7 +47,7 @@ const getConversationController = async (req, res) => {
     const { conversations, total, nameMap, unreadMap } = await fetchConversationData(filter, skip, limit);
 
     if (!conversations || conversations.length === 0) {
-      console.log('No conversations found, returning empty list');
+      logger.info('No conversations found, returning empty list');
       return res.status(200).json({
         success: true,
         conversations: [],
@@ -60,9 +61,9 @@ const getConversationController = async (req, res) => {
     const totalPages = Math.ceil(total / limit);
     const totalTime = Date.now() - startTime;
     
-    console.log('Number of conversations found:', conversations?.length || 0);
-    console.log(`Total controller execution time: ${totalTime}ms`);
-    console.log(`Filter: ${filter}, Pagination: ${conversations.length} of ${total} conversations (page ${page}/${totalPages})`);
+    logger.info('Number of conversations found:', conversations?.length || 0);
+    logger.info(`Total controller execution time: ${totalTime}ms`);
+    logger.info(`Filter: ${filter}, Pagination: ${conversations.length} of ${total} conversations (page ${page}/${totalPages})`);
 
     res.status(200).json({
       success: true,
@@ -77,11 +78,11 @@ const getConversationController = async (req, res) => {
         hasPrev: page > 1
       }
     });
-    console.log('Response sent successfully!');
+    logger.info('Response sent successfully!');
 
   } catch (error) {
-    console.error('Error fetching conversations:', error);
-    console.error('Error stack:', error.stack);
+    logger.error('Error fetching conversations:', error);
+    logger.error('Error stack:', error.stack);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversations'
@@ -90,10 +91,10 @@ const getConversationController = async (req, res) => {
 };
 
 const getConversationMessagesController = async (req, res) => {
-  console.log('Starting getConversationMessagesController at', new Date().toISOString());
+  logger.info('Starting getConversationMessagesController at', new Date().toISOString());
   try {
     const { phoneNumber } = req.params;
-    console.log('Requested conversation for phone number:', phoneNumber);
+    logger.info('Requested conversation for phone number:', phoneNumber);
     
     if (!phoneNumber) {
       return res.status(400).json({
@@ -110,20 +111,20 @@ const getConversationMessagesController = async (req, res) => {
       try {
         query.createdAt = { $lt: new Date(before) };
       } catch (parseError) {
-        console.warn('Invalid date format for before parameter:', before, parseError);
+        logger.warn('Invalid date format for before parameter:', before, parseError);
         query.createdAt = { $lt: before };
       }
     }
     
-    console.log('Fetching conversation messages with query:', JSON.stringify(query));
-    console.log('Using limit:', limit);
+    logger.info('Fetching conversation messages with query:', JSON.stringify(query));
+    logger.info('Using limit:', limit);
         
-    console.log('About to execute Message.find with query:', JSON.stringify(query));
+    logger.info('About to execute Message.find with query:', JSON.stringify(query));
     let messages = [];
     
     try {
       const countResult = await Message.countDocuments(query);
-      console.log(`Found ${countResult} messages matching query criteria`);
+      logger.info(`Found ${countResult} messages matching query criteria`);
       
       if (countResult > 0) {
         messages = await Message.find(query)
@@ -131,22 +132,22 @@ const getConversationMessagesController = async (req, res) => {
           .limit(limit)
           .lean();
           
-        console.log(`Retrieved ${messages.length} messages, inspecting for potential issues...`);
+        logger.info(`Retrieved ${messages.length} messages, inspecting for potential issues...`);
         
         const problematicMessages = messages.filter(msg => {
           if (!msg || !msg.numero || !msg.createdAt) {
-            console.warn('Found message missing required fields:', msg?._id || 'unknown');
+            logger.warn('Found message missing required fields:', msg?._id || 'unknown');
             return true;
           }
           
           if (msg.is_media === true) {
             if (!msg.media || typeof msg.media !== 'object') {
-              console.warn('Found media message with invalid media data:', msg._id);
+              logger.warn('Found media message with invalid media data:', msg._id);
               return true;
             }
             
             if (msg.media && (typeof msg.media.data === 'function' || msg.media.data instanceof Buffer)) {
-              console.warn('Found media message with Buffer data that might cause serialization issues:', msg._id);
+              logger.warn('Found media message with Buffer data that might cause serialization issues:', msg._id);
               return true;
             }
           }
@@ -155,25 +156,25 @@ const getConversationMessagesController = async (req, res) => {
         });
         
         if (problematicMessages.length > 0) {
-          console.warn(`Found ${problematicMessages.length} potentially problematic messages`);
-          console.log('First problematic message IDs:', problematicMessages.slice(0, 3).map(m => m?._id || 'unknown'));
+          logger.warn(`Found ${problematicMessages.length} potentially problematic messages`);
+          logger.info('First problematic message IDs:', problematicMessages.slice(0, 3).map(m => m?._id || 'unknown'));
         }
       } else {
-        console.log('No messages found for this query');
+        logger.info('No messages found for this query');
       }
     } catch (err) {
-      console.error('Database query error in message retrieval:', err);
+      logger.error('Database query error in message retrieval:', err);
       messages = [];
     }
     
-    console.log(`Retrieved a total of ${messages?.length || 0} messages for phone number: ${phoneNumber}`);
+    logger.info(`Retrieved a total of ${messages?.length || 0} messages for phone number: ${phoneNumber}`);
     
     const sanitizedMessages = (messages || []).map(msg => {
       try {
         JSON.stringify(msg);
         return msg;
       } catch (serializationError) {
-        console.error(`Found non-serializable message with ID ${msg._id}:`, serializationError);
+        logger.error(`Found non-serializable message with ID ${msg._id}:`, serializationError);
         return {
           _id: msg._id?.toString() || 'unknown',
           numero: msg.numero || phoneNumber,
@@ -187,16 +188,16 @@ const getConversationMessagesController = async (req, res) => {
     });
         
     const reversedMessages = sanitizedMessages.reverse();
-    console.log(`Sending ${reversedMessages.length} sanitized messages in response`);
+    logger.info(`Sending ${reversedMessages.length} sanitized messages in response`);
         
     res.status(200).json({
       success: true,
       phoneNumber,
       messages: reversedMessages
     });
-    console.log('Successfully sent conversation messages response');
+    logger.info('Successfully sent conversation messages response');
   } catch (error) {
-    console.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, error);
+    logger.error(`Error fetching conversation for ${req.params?.phoneNumber || 'unknown'}:`, error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversation'
@@ -205,10 +206,10 @@ const getConversationMessagesController = async (req, res) => {
 };
 
 const getConversationReplyController = async (req, res) => {
-  console.log('Starting getConversationReplyController at', new Date().toISOString());
+  logger.info('Starting getConversationReplyController at', new Date().toISOString());
   try {
     const { phoneNumber, message, mediaData, contentSid, variables } = req.body;
-    console.log('Reply request params:', { 
+    logger.info('Reply request params:', { 
       phoneNumber, 
       hasMessage: !!message, 
       hasMediaData: !!mediaData,
@@ -226,7 +227,7 @@ const getConversationReplyController = async (req, res) => {
     const formattedPhoneNumber = phoneNumber?.startsWith('whatsapp:') 
       ? phoneNumber 
       : `whatsapp:${phoneNumber}`;
-    console.log('Formatted phone number:', formattedPhoneNumber);
+    logger.info('Formatted phone number:', formattedPhoneNumber);
     
     const messageData = {
       code: formattedPhoneNumber,
@@ -235,11 +236,11 @@ const getConversationReplyController = async (req, res) => {
     
     // Handle template message (contentSid provided)
     if (contentSid) {
-      console.log('Processing template message with contentSid:', contentSid);
+      logger.info('Processing template message with contentSid:', contentSid);
       messageData.contentSid = contentSid;
       
       if (variables && Object.keys(variables).length > 0) {
-        console.log('Template variables:', JSON.stringify(variables));
+        logger.info('Template variables:', JSON.stringify(variables));
         messageData.variables = variables;
       }
       
@@ -255,7 +256,7 @@ const getConversationReplyController = async (req, res) => {
     }
     // Handle media message
     else if (mediaData && mediaData.fileUrl) {
-      console.log('Processing media data:', { fileType: mediaData.fileType, hasFileUrl: !!mediaData.fileUrl, fileName: mediaData.fileName });
+      logger.info('Processing media data:', { fileType: mediaData.fileType, hasFileUrl: !!mediaData.fileUrl, fileName: mediaData.fileName });
       messageData.fileUrl = mediaData.fileUrl;
       messageData.fileType = mediaData.fileType || 'image';
       
@@ -272,19 +273,19 @@ const getConversationReplyController = async (req, res) => {
       messageData.body = message;
     }
         
-    console.log('Sending message with data:', JSON.stringify(messageData));
+    logger.info('Sending message with data:', JSON.stringify(messageData));
     await sendMessage(messageData);
-    console.log('Message sent successfully');
+    logger.info('Message sent successfully');
         
     res.status(200).json({
       success: true,
       message: 'Reply sent successfully'
     });
   } catch (error) {
-    console.error('Error sending reply:', error);
-    console.log('Request body:', JSON.stringify(req.body || {}));
+    logger.error('Error sending reply:', error);
+    logger.info('Request body:', JSON.stringify(req.body || {}));
     const errorMsg = error.message || 'Failed to send reply';
-    console.error('Responding with error:', errorMsg);
+    logger.error('Responding with error:', errorMsg);
     res.status(500).json({
       success: false,
       error: errorMsg
@@ -306,7 +307,7 @@ const searchConversationsController = async (req, res) => {
     const maxLimit = 100;
     const parsedLimit = Math.min(parseInt(limit) || 50, maxLimit);
 
-    console.log(`Searching conversations for query: "${query}"`);
+    logger.info(`Searching conversations for query: "${query}"`);
     const searchStartTime = Date.now();
 
     const escapedQuery = query.replace(/\+/g, '\\+');
@@ -341,7 +342,7 @@ const searchConversationsController = async (req, res) => {
     ]);
 
     const searchTime = Date.now() - searchStartTime;
-    console.log(`Search completed in ${searchTime}ms, found ${conversations.length} conversations`);
+    logger.info(`Search completed in ${searchTime}ms, found ${conversations.length} conversations`);
 
     // Fetch names from Airtable and WhatsApp (same logic as fetchConversationData)
     const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
@@ -362,7 +363,7 @@ const searchConversationsController = async (req, res) => {
             batch.map(p => `{whatsapp_id} = "${p}"`).join(', ') +
             ')';
           return getRecordByFilter(Historial_Clinico_ID, 'estado_general', formula).catch(error => {
-            console.error('Error fetching Airtable batch for search:', error);
+            logger.error('Error fetching Airtable batch for search:', error);
             return [];
           });
         });
@@ -379,9 +380,9 @@ const searchConversationsController = async (req, res) => {
             }
           }
         });
-        console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable for search results (${batches.length} batches)`);
+        logger.info(`Found ${Object.keys(airtableNameMap).length} names in Airtable for search results (${batches.length} batches)`);
       } catch (error) {
-        console.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', error);
+        logger.error('Error fetching names from Airtable for search, falling back to nombre_whatsapp:', error);
       }
     }
 
@@ -446,7 +447,7 @@ const searchConversationsController = async (req, res) => {
     });
 
   } catch (error) {
-    console.error('Error searching conversations:', error);
+    logger.error('Error searching conversations:', error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to search conversations'
@@ -479,7 +480,7 @@ const getConversationsByNameController = async (req, res) => {
       }))
     });
   } catch (error) {
-    console.error('Error fetching conversations by name:', error);
+    logger.error('Error fetching conversations by name:', error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch conversations by name'
@@ -525,7 +526,7 @@ const getNewMessagesController = async (req, res) => {
       messages: messages
     });
   } catch (error) {
-    console.error(`Error fetching new messages for ${req.params.phoneNumber}:`, error);
+    logger.error(`Error fetching new messages for ${req.params.phoneNumber}:`, error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch new messages'
@@ -534,7 +535,7 @@ const getNewMessagesController = async (req, res) => {
 };
 
 const markMessagesAsReadController = async (req, res) => {
-  console.log('Starting markMessagesAsReadController at', new Date().toISOString());
+  logger.info('Starting markMessagesAsReadController at', new Date().toISOString());
   try {
     const { phoneNumber } = req.params;
         
@@ -545,7 +546,7 @@ const markMessagesAsReadController = async (req, res) => {
       });
     }
         
-    console.log('Marking messages as read for phone number:', phoneNumber);
+    logger.info('Marking messages as read for phone number:', phoneNumber);
     const result = await Message.updateMany(
       { 
         numero: phoneNumber, 
@@ -564,8 +565,8 @@ const markMessagesAsReadController = async (req, res) => {
       modifiedCount: result.nModified || result.modifiedCount
     });
   } catch (error) {
-    console.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, error);
-    console.error('Error stack:', error.stack);
+    logger.error(`Error marking messages as read for ${req.params?.phoneNumber || 'unknown'}:`, error);
+    logger.error('Error stack:', error.stack);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to mark messages as read'
@@ -574,7 +575,7 @@ const markMessagesAsReadController = async (req, res) => {
 };
 
 const sendTemplateToNewNumberController = async (req, res) => {
-  console.log('Starting sendTemplateToNewNumberController at', new Date().toISOString());
+  logger.info('Starting sendTemplateToNewNumberController at', new Date().toISOString());
   try {
     const { phoneNumber, templateId, variables } = req.body;
     
@@ -598,7 +599,7 @@ const sendTemplateToNewNumberController = async (req, res) => {
       : `whatsapp:${phoneNumber}`;
     
     // Log template details for debugging
-    console.log('Sending template to new number with details:', { 
+    logger.info('Sending template to new number with details:', { 
       phoneNumber: formattedPhoneNumber,
       templateId,
       hasVariables: variables && Object.keys(variables).length > 0,
@@ -612,7 +613,7 @@ const sendTemplateToNewNumberController = async (req, res) => {
     
     if (variables && Object.keys(variables).length > 0) {
       messageData.variables = variables;
-      console.log('Template variables:', JSON.stringify(variables));
+      logger.info('Template variables:', JSON.stringify(variables));
     }
     
     const message = await sendMessage(messageData);
@@ -623,7 +624,7 @@ const sendTemplateToNewNumberController = async (req, res) => {
       messageId: message.sid
     });
   } catch (error) {
-    console.error('Error sending template to new number:', error);
+    logger.error('Error sending template to new number:', error);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to send template to new number'
@@ -632,14 +633,14 @@ const sendTemplateToNewNumberController = async (req, res) => {
 };
 
 const getOpenAIThreadMessagesController = async (req, res) => {
-  console.log('Starting getOpenAIThreadMessagesController at', new Date().toISOString());
+  logger.info('Starting getOpenAIThreadMessagesController at', new Date().toISOString());
   try {
     const { phoneNumber } = req.params;
     const { limit = 50, order = 'desc', runId } = req.query;
     const variant = process.env.VARIANT || 'assistants';
     
-    console.log('Fetching OpenAI thread messages for:', phoneNumber);
-    console.log('Variant:', variant, 'Limit:', limit, 'Order:', order);
+    logger.info('Fetching OpenAI thread messages for:', phoneNumber);
+    logger.info('Variant:', variant, 'Limit:', limit, 'Order:', order);
     
     if (!phoneNumber) {
       return res.status(400).json({
@@ -654,22 +655,22 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     }).sort({ createdAt: -1 });
     
     if (!thread) {
-      console.log('No active OpenAI thread found for:', phoneNumber);
+      logger.info('No active OpenAI thread found for:', phoneNumber);
       return res.status(404).json({
         success: false,
         error: 'No active OpenAI thread found for this phone number'
       });
     }
     
-    const conversationId = thread.getConversationId();
-    console.log('Thread found - Conversation ID:', conversationId);
+    const conversationId = thread.conversation_id;
+    logger.info('Thread found - Conversation ID:', conversationId);
     
     const provider = llmConfig.getOpenAIProvider({ instantiate: true, variant });
     if (!provider) {
       throw new Error('OpenAI provider not initialized');
     }
     
-    console.log('Using provider variant:', provider.getVariant());
+    logger.info('Using provider variant:', provider.getVariant());
     
     const queryParams = { 
       threadId: conversationId, 
@@ -679,13 +680,13 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     
     if (variant === 'assistants' && runId) {
       queryParams.runId = runId;
-      console.log('Including runId:', runId);
+      logger.info('Including runId:', runId);
     }
     
-    console.log('Calling listMessages with params:', queryParams);
+    logger.info('Calling listMessages with params:', queryParams);
     const messages = await provider.listMessages(queryParams);
     
-    console.log(`Retrieved ${messages?.data?.length || 0} messages from OpenAI`);
+    logger.info(`Retrieved ${messages?.data?.length || 0} messages from OpenAI`);
     
     res.status(200).json({
       success: true,
@@ -702,8 +703,8 @@ const getOpenAIThreadMessagesController = async (req, res) => {
     });
     
   } catch (error) {
-    console.error('Error fetching OpenAI thread messages:', error);
-    console.error('Error stack:', error.stack);
+    logger.error('Error fetching OpenAI thread messages:', error);
+    logger.error('Error stack:', error.stack);
     res.status(500).json({
       success: false,
       error: error.message || 'Failed to fetch OpenAI thread messages'

package/lib/controllers/interactionController.js

@@ -3,6 +3,7 @@ const { Message } = require('../models/messageModel');
 const { INTERACTION_QUALITY_VALUES } = require('../config/interactionConfig');
 const { addRecord, getRecordByFilter } = require('../services/airtableService');
 const { Logging_ID } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 async function logInteractionToAirtable(messageIds, whatsapp_id, voter_username, description) {
   try {
@@ -21,7 +22,7 @@ async function logInteractionToAirtable(messageIds, whatsapp_id, voter_username,
         patientId = patientRecords[0].record_logging_id;
       }
     } catch (err) {
-      console.warn('Could not find patient in estado_general:', err.message);
+      logger.warn('Could not find patient in estado_general:', err.message);
     }
 
     const airtableData = {
@@ -32,9 +33,9 @@ async function logInteractionToAirtable(messageIds, whatsapp_id, voter_username,
     };
 
     await addRecord(Logging_ID, 'interactions', airtableData);
-    console.log('Interaction logged to Airtable successfully');
+    logger.info('Interaction logged to Airtable successfully');
   } catch (error) {
-    console.error('Error logging interaction to Airtable:', error);
+    logger.error('Error logging interaction to Airtable:', error);
   }
 }
 
@@ -52,12 +53,12 @@ const addInteractionController = async (req, res) => {
     const interaction = await Interaction.create({ messages, whatsapp_id, voter_username, quality, description });
     
     logInteractionToAirtable(messages, whatsapp_id, voter_username, description).catch(err => 
-      console.error('Background Airtable logging failed:', err)
+      logger.error('Background Airtable logging failed:', err)
     );
     
     res.status(201).json({ success: true, interaction });
   } catch (error) {
-    console.error('Error adding interaction:', error);
+    logger.error('Error adding interaction:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };
@@ -68,7 +69,7 @@ const getInteractionsByWhatsappIdController = async (req, res) => {
     const interactions = await Interaction.find({ whatsapp_id }).populate('messages').sort({ createdAt: -1 });
     res.status(200).json({ success: true, whatsappId: whatsapp_id, count: interactions.length, interactions });
   } catch (error) {
-    console.error('Error fetching interactions:', error);
+    logger.error('Error fetching interactions:', error);
     res.status(500).json({ success: false, error: error.message });
   }
 };

package/lib/controllers/mediaController.js

@@ -1,4 +1,6 @@
 const { s3, downloadFileFromS3 } = require('../config/awsConfig');
+const { logger } = require('../utils/logger');
+
 const bucketName = process.env.AWS_S3_BUCKET_NAME;
 
 
@@ -6,11 +8,11 @@ const getMediaController = async (req, res) => {
   try {
     const { key } = req.params;
         
-    console.log(`[MediaController] Received request for media file with key: ${key}`);
-    console.log(`[MediaController] Original URL path: ${req.originalUrl}`);
+    logger.info(`[MediaController] Received request for media file with key: ${key}`);
+    logger.info(`[MediaController] Original URL path: ${req.originalUrl}`);
         
     if (!key || key.trim() === '') {
-      console.error('[MediaController] Invalid key provided:', key);
+      logger.error('[MediaController] Invalid key provided:', key);
       return res.status(400).json({
         success: false,
         error: 'Invalid media key provided'
@@ -27,17 +29,17 @@ const getMediaController = async (req, res) => {
 
     let mediaKey = key;
         
-    console.log(`[MediaController] Final S3 key to fetch: ${mediaKey}`);
+    logger.info(`[MediaController] Final S3 key to fetch: ${mediaKey}`);
         
     const fileData = await downloadFileFromS3(bucketName, mediaKey);
         
     if (!fileData || !fileData.Body) {
-      console.error(`[MediaController] Media not found in S3: ${key}`);
+      logger.error(`[MediaController] Media not found in S3: ${key}`);
 
       if (s3) {
         try {
           const prefix = key.split('/') [0];
-          console.log(`[MediaController] Checking S3 for objects with prefix: ${prefix}/`);
+          logger.info(`[MediaController] Checking S3 for objects with prefix: ${prefix}/`);
           s3.listObjectsV2({
             Bucket: bucketName,
             Prefix: prefix + '/',
@@ -45,22 +47,22 @@ const getMediaController = async (req, res) => {
           }).promise()
             .then(listData => {
               if (listData.Contents && listData.Contents.length > 0) {
-                console.log(`[MediaController] Found ${listData.Contents.length} objects with similar prefix:`);
+                logger.info(`[MediaController] Found ${listData.Contents.length} objects with similar prefix:`);
                 listData.Contents.forEach(item => {
-                  console.log(`[MediaController] - ${item.Key} (${item.Size} bytes)`);
+                  logger.info(`[MediaController] - ${item.Key} (${item.Size} bytes)`);
                   if (item.Key.includes(key.split('/').pop().substring(0, 10))) {
-                    console.log(`[MediaController] !!! POTENTIAL MATCH: ${item.Key}`);
+                    logger.info(`[MediaController] !!! POTENTIAL MATCH: ${item.Key}`);
                   }
                 });
               } else {
-                console.log(`[MediaController] No objects found with prefix: ${prefix}/`);
+                logger.info(`[MediaController] No objects found with prefix: ${prefix}/`);
               }
             })
             .catch(listErr => {
-              console.error(`[MediaController] Error listing objects: ${listErr.message}`);
+              logger.error(`[MediaController] Error listing objects: ${listErr.message}`);
             });
         } catch (listErr) {
-          console.error(`[MediaController] Error setting up bucket listing: ${listErr.message}`);
+          logger.error(`[MediaController] Error setting up bucket listing: ${listErr.message}`);
         }
       }
 
@@ -94,7 +96,7 @@ const getMediaController = async (req, res) => {
         
     res.send(fileData.Body);
   } catch (error) {
-    console.error('Error serving media:', error);
+    logger.error('Error serving media:', error);
     res.status(500).json({
       success: false,
       error: 'Failed to retrieve media'

package/lib/controllers/messageController.js

@@ -6,6 +6,7 @@ const {
 } = require('../core/NexusMessaging');
 const { getRecordByFilter: defaultGetRecordByFilter } = require('../services/airtableService');
 const runtimeConfig = require('../config/runtimeConfig');
+const { logger } = require('../utils/logger');
 const moment = require('moment-timezone');
 
 const dependencies = {
@@ -131,7 +132,7 @@ const sendMessageController = async (req, res) => {
       messageId: pickMessageId(result, scheduledRecord)
     });
   } catch (err) {
-    console.error('Error scheduling individual message:', err);
+    logger.error('Error scheduling individual message:', err);
     res.status(500).json({ status: false, error: err.message });
   }
 };
@@ -196,7 +197,7 @@ const sendBulkMessageController = async (req, res) => {
       })
     );
 
-    console.log(`Send bulk of ${numSend} messages`);
+    logger.info(`Send bulk of ${numSend} messages`);
 
     const messageIds = sentMessages
       .map(({ result, scheduled }) => pickMessageId(result, scheduled))
@@ -208,7 +209,7 @@ const sendBulkMessageController = async (req, res) => {
       messageIds
     });
   } catch (err) {
-    console.error('Error sending bulk messages:', err);
+    logger.error('Error sending bulk messages:', err);
     res.status(500).send(err.message);
   }
 };
@@ -307,7 +308,7 @@ const sendBulkMessageAirtableController = async (req, res) => {
       .map(({ result, scheduled }) => pickMessageId(result, scheduled))
       .filter((id) => id !== null);
 
-    console.log(`Iterate over ${(rows || []).length} rows`);
+    logger.info(`Iterate over ${(rows || []).length} rows`);
 
     res.status(200).json({
       status: true,
@@ -315,7 +316,7 @@ const sendBulkMessageAirtableController = async (req, res) => {
       messageIds
     });
   } catch (err) {
-    console.error('Error sending Airtable bulk messages:', err);
+    logger.error('Error sending Airtable bulk messages:', err);
     res.status(500).send(err.message);
   }
 };
@@ -343,7 +344,7 @@ const getLastInteractionController = async (req, res) => {
 
     return res.status(200).send({ message: 'Last interaction retrieved successfully.', lastMessage, minutes });
   } catch (error) {
-    console.error(error);
+    logger.error(error);
     return res.status(500).send({ message: 'Failed to retrieve the last interaction.', error });
   }
 };