@peopl-health/nexus 2.4.7 → 2.4.9

package/lib/providers/createProvider.js

@@ -1,5 +1,6 @@
 const { OpenAIAssistantsProvider } = require('./OpenAIAssistantsProvider');
 const { OpenAIResponsesProvider } = require('./OpenAIResponsesProvider');
+const { logger } = require('../utils/logger');
 
 const PROVIDER_VARIANTS = {
   assistants: OpenAIAssistantsProvider,
@@ -10,7 +11,7 @@ const PROVIDER_VARIANTS = {
  * Returns the appropriate OpenAI provider implementation for the requested variant.
  */
 function createProvider(config = {}) {
-  console.log('Creating OpenAI provider with config:', config);
+  logger.debug('Creating OpenAI provider', { variant: config.variant || 'assistants' });
   const variant = (config.variant || config.providerVariant || config.llmVariant || 'assistants')
     .toString()
     .toLowerCase();

package/lib/services/airtableService.js

@@ -1,4 +1,5 @@
 const { airtable } = require('../config/airtableConfig');
+const { logger } = require('../utils/logger');
 
 
 async function addRecord(baseID, tableName, fields) {
@@ -6,10 +7,10 @@ async function addRecord(baseID, tableName, fields) {
     if (!airtable) throw new Error('Airtable not configured. Set AIRTABLE_API_KEY');
     const base = airtable.base(baseID);
     const record = await base(tableName).create(fields);
-    console.log('Record added at', tableName);
+    logger.info('Record added at', tableName);
     return record;
   } catch (error) {
-    console.error('Error adding record:', error);
+    logger.error('Error adding record:', error);
     throw error; 
   }
 }
@@ -30,7 +31,7 @@ async function getRecords(baseID, tableName) {
     });
     return records;
   } catch (error) {
-    console.error('Error fetching records:', error);
+    logger.error('Error fetching records:', error);
   }
 }
 
@@ -51,7 +52,7 @@ async function getRecordByFilter(baseID, tableName, filter, view = 'Grid view')
     });
     return records;
   } catch (error) {
-    console.error(`Error fetching records by ${filter}:`, error);
+    logger.error(`Error fetching records by ${filter}:`, error);
   }
 }
 
@@ -74,7 +75,7 @@ async function updateRecordByFilter(baseID, tableName, filter, updateFields) {
         
     return updatedRecords;
   } catch (error) {
-    console.error(`Error updating records by ${filter}:`, error);
+    logger.error(`Error updating records by ${filter}:`, error);
   }
 }
 

package/lib/services/assistantService.js

@@ -15,7 +15,7 @@ const { withTracing } = require('../utils/tracingDecorator.js');
 const { processThreadMessage } = require('../helpers/processHelper.js');
 const { getLastMessages, updateMessageRecord } = require('../helpers/messageHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
-const { logger } = require('../middleware/requestId');
+const { logger } = require('../utils/logger');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
@@ -136,9 +136,9 @@ const getAssistantById = (assistant_id, thread) => {
 
 const createAssistant = async (code, assistant_id, messages=[], force=false) => {
   const findThread = await Thread.findOne({ code: code });
-  console.log('[createAssistant] findThread', findThread);
+  logger.info('[createAssistant] findThread', findThread);
   if (findThread && findThread.getConversationId()) {
-    console.log('[createAssistant] Thread already exists');
+    logger.info('[createAssistant] Thread already exists');
     const updateFields = { active: true, stopped: false };
     Thread.setAssistantId(updateFields, assistant_id);    
     await Thread.updateOne({ code: code }, { $set: updateFields });
@@ -146,7 +146,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   }
   
   const curRow = await getCurRow(Historial_Clinico_ID, code);
-  console.log('[createAssistant] curRow', curRow[0]);
+  logger.info('[createAssistant] curRow', curRow[0]);
   const nombre = curRow?.[0]?.['name'] || null;
   const patientId = curRow?.[0]?.['record_id'] || null;
 
@@ -175,7 +175,7 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
   const condition = { $or: [{ code: code }] };
   const options = { new: true, upsert: true };
   const updatedThread = await Thread.findOneAndUpdate(condition, {run_id: null, ...thread}, options);
-  console.log('[createAssistant] Updated thread:', updatedThread);
+  logger.info('[createAssistant] Updated thread:', updatedThread);
 
   // Delete previous thread
   if (force) {
@@ -188,12 +188,12 @@ const createAssistant = async (code, assistant_id, messages=[], force=false) =>
 const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) => {
   try {
     const thread = await Thread.findOne({ code: code });
-    console.log(thread);
+    logger.info(thread);
     if (thread === null) return null;
 
     const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
     for (const message of inMessages) {
-      console.log(message);
+      logger.info(message);
       await provider.addMessage({
         threadId: thread.getConversationId(),
         role: role,
@@ -209,17 +209,17 @@ const addMsgAssistant = async (code, inMessages, role = 'user', reply = false) =
     const assistant = getAssistantById(thread.getAssistantId(), thread);
     do {
       ({ output, completed } = await runAssistantAndWait({ thread, assistant }));
-      console.log(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
+      logger.info(`Attempt ${retries + 1}: completed=${completed}, output=${output || '(empty)'}`);
       
       if (completed && output) break;
       if (retries < maxRetries) await new Promise(resolve => setTimeout(resolve, 2000));
       retries++;
     } while (retries <= maxRetries && (!completed || !output));
 
-    console.log('THE ANS IS', output);
+    logger.info('THE ANS IS', output);
     return output;
   } catch (error) {
-    console.log(error);
+    logger.info(error);
     return null;
   }
 };
@@ -254,7 +254,7 @@ const addInstructionCore = async (code, instruction, role = 'user') => {
     null // no patientReply for instructions
   );
 
-  console.log('RUN RESPONSE', output);
+  logger.info('RUN RESPONSE', output);
   return output;
 };
 
@@ -273,33 +273,48 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const timings = {};
   const startTotal = Date.now();
   
-  timings.getThread = Date.now();
-  const thread = thread_ || await withTracing(getThread, 'get_thread_operation', 
+  const { result: thread, duration: getThreadMs } = await withTracing(
+    getThread, 
+    'get_thread_operation', 
     (threadCode) => ({ 
       'thread.code': threadCode,
       'operation.type': 'thread_retrieval',
       'thread.provided': !!thread_
-    })
+    }),
+    { returnTiming: true }
   )(code);
-  timings.getThread = Date.now() - timings.getThread;
+  timings.get_thread_ms = getThreadMs;
   
-  if (!thread) return null;
-
-  timings.getMessages = Date.now();
-  const patientReply = await getLastMessages(code);
-  timings.getMessages = Date.now() - timings.getMessages;
+  if (!thread_ && !thread) return null;
+  const finalThread = thread_ || thread;
+
+  const { result: patientReply, duration: getMessagesMs } = await withTracing(
+    getLastMessages,
+    'get_last_messages',
+    (code) => ({ 'thread.code': code }),
+    { returnTiming: true }
+  )(code);
+  timings.get_messages_ms = getMessagesMs;
   
   if (!patientReply) {
-    logger.log('[replyAssistantCore] No relevant data found for this assistant.');
+    logger.info('[replyAssistantCore] No relevant data found for this assistant.');
     return null;
   }
 
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   
-  timings.processMessages = Date.now();
-  logger.log(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+  logger.info(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
   
-  const processResults = await processThreadMessage(code, patientReply, provider);
+  const { result: processResults, duration: processMessagesMs } = await withTracing(
+    processThreadMessage,
+    'process_thread_messages',
+    (code, patientReply, provider) => ({
+      'messages.count': patientReply.length,
+      'thread.code': code
+    }),
+    { returnTiming: true }
+  )(code, patientReply, provider);
+  timings.process_messages_ms = processMessagesMs;
   
   const patientMsg = processResults.some(r => r.isPatient);
   const urls = processResults.filter(r => r.url).map(r => ({ url: r.url }));
@@ -307,22 +322,28 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
   const allTempFiles = processResults.flatMap(r => r.tempFiles || []);
   
   if (allMessagesToAdd.length > 0) {
-    const threadId = thread.getConversationId();
-    logger.log(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
+    const threadId = finalThread.getConversationId();
+    logger.info(`[replyAssistantCore] Adding ${allMessagesToAdd.length} messages to thread in batch`);
     await provider.addMessage({ threadId, messages: allMessagesToAdd });
   }
   
-  await Promise.all(processResults.map(r => updateMessageRecord(r.reply, thread)));
+  await Promise.all(processResults.map(r => updateMessageRecord(r.reply, finalThread)));
   await cleanupFiles(allTempFiles);
   
-  timings.processMessages = Date.now() - timings.processMessages;
-  
   if (urls.length > 0) {
-    timings.pdfCombination = Date.now();
-    logger.log(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
-    const { pdfBuffer, processedFiles } = await combineImagesToPDF({ code });
-    timings.pdfCombination = Date.now() - timings.pdfCombination;
-    logger.log(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+    logger.info(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+    const { result: pdfResult, duration: pdfCombinationMs } = await withTracing(
+      combineImagesToPDF,
+      'combine_images_to_pdf',
+      ({ code }) => ({
+        'pdf.thread_code': code,
+        'pdf.url_count': urls.length
+      }),
+      { returnTiming: true }
+    )({ code });
+    timings.pdf_combination_ms = pdfCombinationMs;
+    const { pdfBuffer, processedFiles } = pdfResult;
+    logger.info(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
     
     if (pdfBuffer) {
       const key = `${code}-${Date.now()}-combined.pdf`;
@@ -337,48 +358,43 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
     }
   }
 
-  if (!patientMsg || thread.stopped) return null;
+  if (!patientMsg || finalThread.stopped) return null;
 
-  timings.runAssistant = Date.now();
-  const assistant = getAssistantById(thread.getAssistantId(), thread);
-  const { run, output, completed, retries, predictionTimeMs } = await withTracing(
+  const assistant = getAssistantById(finalThread.getAssistantId(), finalThread);
+  const { result: runResult, duration: runAssistantMs } = await withTracing(
     runAssistantWithRetries,
     'run_assistant_with_retries',
     (thread, assistant, runConfig, patientReply) => ({
       'assistant.id': thread.getAssistantId(),
       'assistant.max_retries': DEFAULT_MAX_RETRIES,
       'assistant.has_patient_reply': !!patientReply
-    })
-  )(thread, assistant, runOptions, patientReply);
-  timings.runAssistant = Date.now() - timings.runAssistant;
-  timings.total = Date.now() - startTotal;
+    }),
+    { returnTiming: true }
+  )(finalThread, assistant, runOptions, patientReply);
+  timings.run_assistant_ms = runAssistantMs;
+  timings.total_ms = Date.now() - startTotal;
+  
+  const { run, output, completed, retries, predictionTimeMs } = runResult;
 
-  logger.log('[Performance Breakdown]', {
+  logger.info('[Assistant Reply Complete]', {
     code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
     messageCount: patientReply.length,
     hasMedia: urls.length > 0,
     retries,
-    time: `${timings.total}ms`
+    totalMs: timings.total_ms
   });
 
   if (output && predictionTimeMs) {
     await PredictionMetrics.create({
       message_id: `${code}-${Date.now()}`,
       numero: code,
-      assistant_id: thread.getAssistantId(),
-      thread_id: thread.getConversationId(),
+      assistant_id: finalThread.getAssistantId(),
+      thread_id: finalThread.getConversationId(),
       prediction_time_ms: predictionTimeMs,
       retry_count: retries,
       completed: completed,
-      timing_breakdown: {
-        get_thread_ms: timings.getThread,
-        get_messages_ms: timings.getMessages,
-        process_messages_ms: timings.processMessages,
-        pdf_combination_ms: timings.pdfCombination || 0,
-        run_assistant_ms: timings.runAssistant,
-        total_ms: timings.total
-      }
-    }).catch(err => console.error('[replyAssistantCore] Failed to store metrics:', err));
+      timing_breakdown: timings
+    }).catch(err => logger.error('[replyAssistantCore] Failed to store metrics:', err));
   }
 
   return output;
@@ -398,7 +414,7 @@ const replyAssistant = withTracing(
 const switchAssistant = async (code, assistant_id) => {
   try {
     const thread = await Thread.findOne({ code: code });
-    console.log('Inside thread', thread);
+    logger.info('Inside thread', thread);
     if (thread === null) return;
 
     const variant = process.env.VARIANT || 'assistants';
@@ -412,7 +428,7 @@ const switchAssistant = async (code, assistant_id) => {
 
     await Thread.updateOne({ code }, { $set: updateFields });  
   } catch (error) {
-    console.log(error);
+    logger.info(error);
     return null;
   }
 };

package/lib/services/conversationService.js

@@ -1,6 +1,7 @@
 const { Message } = require('../models/messageModel');
 const { Historial_Clinico_ID } = require('../config/airtableConfig');
 const { getRecordByFilter } = require('./airtableService');
+const { logger } = require('../utils/logger');
 
 
 const fetchConversationData = async (filter, skip, limit) => {
@@ -16,11 +17,11 @@ const fetchConversationData = async (filter, skip, limit) => {
         { read: { $exists: false } }
       ]
     };
-    console.log('Applying unread filter');
+    logger.info('Applying unread filter');
     break;
 
   case 'no-response':
-    console.log('Applying no-response filter');
+    logger.info('Applying no-response filter');
     break;
 
   case 'recent': {
@@ -30,18 +31,18 @@ const fetchConversationData = async (filter, skip, limit) => {
       is_group: false,
       createdAt: { $gt: yesterday }
     };
-    console.log('Applying recent filter (last 24 hours)');
+    logger.info('Applying recent filter (last 24 hours)');
     break;
   }
 
   case 'all':
   default:
     filterConditions = { is_group: false };
-    console.log('Applying all conversations filter');
+    logger.info('Applying all conversations filter');
     break;
   }
 
-  console.log('Executing aggregation pipeline...');
+  logger.info('Executing aggregation pipeline...');
   const aggregationStartTime = Date.now();
   
   let aggregationPipeline = [
@@ -77,7 +78,7 @@ const fetchConversationData = async (filter, skip, limit) => {
   const conversations = await Message.aggregate(aggregationPipeline);
 
   const aggregationTime = Date.now() - aggregationStartTime;
-  console.log(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
+  logger.info(`Aggregation completed in ${aggregationTime}ms, found ${conversations.length} conversations`);
 
   // Fetch names from Airtable and WhatsApp
   const phoneNumbers = conversations.map(conv => conv._id).filter(Boolean);
@@ -89,7 +90,7 @@ const fetchConversationData = async (filter, skip, limit) => {
     map[patient.whatsapp_id] = patient.name;
     return map;
   }, {});
-  console.log(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
+  logger.info(`Found ${Object.keys(airtableNameMap).length} names in Airtable`);
 
   const contactNames = await Message.aggregate([
     { $match: { is_group: false, from_me: false } },
@@ -110,7 +111,7 @@ const fetchConversationData = async (filter, skip, limit) => {
   }, {...airtableNameMap}) || airtableNameMap || {};
       
   // Fetch unread counts
-  console.log('Fetching unread counts using Message.aggregate');
+  logger.info('Fetching unread counts using Message.aggregate');
   const unreadCounts = await Message.aggregate([
     { 
       $match: { 
@@ -134,8 +135,8 @@ const fetchConversationData = async (filter, skip, limit) => {
     }
     return map;
   }, {}) || {};
-  console.log('unreadMap', JSON.stringify(unreadMap));
-  console.log('Number of conversations found:', conversations?.length || 0);
+  logger.info('unreadMap', JSON.stringify(unreadMap));
+  logger.info('Number of conversations found:', conversations?.length || 0);
       
   // Calculate total count for pagination
   let totalFilterConditions = { is_group: false };
@@ -193,14 +194,14 @@ const fetchConversationData = async (filter, skip, limit) => {
  * Processes conversations to prepare them for the response
  */
 const processConversations = async (conversations, nameMap, unreadMap) => {
-  console.log('Processing conversations for response...');
+  logger.info('Processing conversations for response...');
 
   let processedConversations = [];
   try {
     processedConversations = (conversations || []).map((conv, index) => {
       try {
         if (!conv || !conv.latestMessage) {
-          console.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
+          logger.warn(`Conversation ${index} missing latestMessage:`, conv?._id || 'unknown');
           return {
             phoneNumber: conv?._id || 'unknown',
             name: 'Unknown',
@@ -245,7 +246,7 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
           lastMessageFromMe: conv?.latestMessage?.from_me || false
         };
       } catch (convError) {
-        console.error(`Error processing conversation ${index}:`, convError);
+        logger.error(`Error processing conversation ${index}:`, convError);
         return {
           phoneNumber: conv?._id || `error_${index}`,
           name: 'Error Processing',
@@ -260,11 +261,10 @@ const processConversations = async (conversations, nameMap, unreadMap) => {
       }
     });
 
-    console.log(`Successfully processed ${processedConversations.length} conversations`);
+    logger.info(`Successfully processed ${processedConversations.length} conversations`);
   
   } catch (mappingError) {
-    console.error('Error in conversation mapping:', mappingError);
-    // Return empty conversations if mapping fails
+    logger.error('Error in conversation mapping:', mappingError);
     processedConversations = [];
   }
 

package/lib/services/preprocessingHooks.js

@@ -1,3 +1,5 @@
+const { logger } = require('../utils/logger');
+
 let preprocessingHandler = null;
 
 const setPreprocessingHandler = (handler) => {
@@ -16,7 +18,7 @@ const invokePreprocessingHandler = async (payload) => {
     const result = await preprocessingHandler(payload);
     return Boolean(result);
   } catch (error) {
-    console.warn('[PreprocessingHooks] Handler threw an error:', error?.message || error);
+    logger.warn('[PreprocessingHooks] Handler threw an error:', error?.message || error);
     return false;
   }
 };

package/lib/storage/MongoStorage.js

@@ -1,5 +1,6 @@
 const mongoose = require('mongoose');
 const runtimeConfig = require('../config/runtimeConfig');
+const { logger } = require('../utils/logger');
 
 /**
  * MongoDB storage interface for messages and interactions
@@ -34,7 +35,7 @@ class MongoStorage {
         useNewUrlParser: true,
         useUnifiedTopology: true
       });
-      console.log('MongoDB connected successfully');
+      logger.info('MongoDB connected successfully');
     } catch (error) {
       throw new Error(`MongoDB connection failed: ${error.message}`);
     }
@@ -46,10 +47,10 @@ class MongoStorage {
       const values = this.buildMessageValues(enrichedMessage);
       const { insertMessage } = require('../models/messageModel');
       await insertMessage(values);
-      console.log('[MongoStorage] Message stored');
+      logger.info('[MongoStorage] Message stored');
       return values;
     } catch (error) {
-      console.error('Error saving message:', error);
+      logger.error('Error saving message:', error);
       throw error;
     }
   }
@@ -64,23 +65,22 @@ class MongoStorage {
         return messageData;
       }
 
-      console.log('[MongoStorage] Detected Twilio media message', {
+      logger.info('[MongoStorage] Detected Twilio media message', {
         from: rawMessage.From,
         numMedia
       });
 
       const bucketName = runtimeConfig.get('AWS_S3_BUCKET_NAME') || process.env.AWS_S3_BUCKET_NAME;
       if (!bucketName) {
-        console.warn('[MongoStorage] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
+        logger.warn('[MongoStorage] AWS_S3_BUCKET_NAME not configured. Skipping media upload.');
         return messageData;
       }
 
       const { processTwilioMediaMessage } = require('../helpers/twilioMediaProcessor');
-      const { logger } = require('../utils/logger');
 
-      const mediaItems = await processTwilioMediaMessage(rawMessage, logger, bucketName);
+      const mediaItems = await processTwilioMediaMessage(rawMessage, bucketName);
       if (!mediaItems || mediaItems.length === 0) {
-        console.warn('[MongoStorage] Media processing returned no items');
+        logger.warn('[MongoStorage] Media processing returned no items');
         return messageData;
       }
 
@@ -91,7 +91,7 @@ class MongoStorage {
 
       rawMessage.__nexusMediaProcessed = true;
 
-      console.log('[MongoStorage] Media processed successfully', {
+      logger.info('[MongoStorage] Media processed successfully', {
         primaryType: mediaPayload.mediaType,
         mediaCount: mediaItems.length,
         s3Key: mediaPayload.key
@@ -107,7 +107,7 @@ class MongoStorage {
         caption: primary.caption || messageData.caption
       };
     } catch (error) {
-      console.error('[MongoStorage] Failed to enrich Twilio media message:', error);
+      logger.error('[MongoStorage] Failed to enrich Twilio media message:', error);
       return messageData;
     }
   }
@@ -197,7 +197,7 @@ class MongoStorage {
         .sort({ createdAt: -1 })
         .limit(limit);
     } catch (error) {
-      console.error('Error getting messages:', error);
+      logger.error('Error getting messages:', error);
       throw error;
     }
   }
@@ -206,7 +206,7 @@ class MongoStorage {
     try {
       return await this.schemas.Thread.findOne({ code, active: true });
     } catch (error) {
-      console.error('Error getting thread:', error);
+      logger.error('Error getting thread:', error);
       throw error;
     }
   }
@@ -217,7 +217,7 @@ class MongoStorage {
       await thread.save();
       return thread;
     } catch (error) {
-      console.error('Error creating thread:', error);
+      logger.error('Error creating thread:', error);
       throw error;
     }
   }
@@ -230,7 +230,7 @@ class MongoStorage {
         { new: true }
       );
     } catch (error) {
-      console.error('Error updating thread:', error);
+      logger.error('Error updating thread:', error);
       throw error;
     }
   }

package/lib/utils/errorHandler.js

@@ -1,5 +1,7 @@
+const { logger } = require('../utils/logger');
+
 const handleApiError = (res, error, message) => {
-  console.error(message, error);
+  logger.error(message, error);
   return res.status(500).json({ success: false, error: message });
 };
 

package/lib/utils/logger.js

@@ -1,5 +1,5 @@
 const pino = require('pino');
-const { trace, context } = require('@opentelemetry/api');
+const { trace } = require('@opentelemetry/api');
 
 const createLogger = (config = {}) => {
   const {
@@ -98,12 +98,44 @@ const createObservabilityLogger = (serviceName = 'nexus-assistant', config = {})
 };
 
 // Default logger instances
-const logger = createLogger();
+const baseLogger = createLogger();
 const observabilityLogger = createObservabilityLogger();
 
+let getRequestId = () => null;
+
+function setRequestIdGetter(getter) {
+  getRequestId = getter;
+}
+
+const logger = {
+  info: (message, meta = {}) => {
+    const requestId = getRequestId();
+    baseLogger.info(requestId ? { requestId, ...meta } : meta, message);
+  },
+  
+  error: (message, meta = {}) => {
+    const requestId = getRequestId();
+    baseLogger.error(requestId ? { requestId, ...meta } : meta, message);
+  },
+  
+  warn: (message, meta = {}) => {
+    const requestId = getRequestId();
+    baseLogger.warn(requestId ? { requestId, ...meta } : meta, message);
+  },
+  
+  debug: (message, meta = {}) => {
+    const requestId = getRequestId();
+    baseLogger.debug(requestId ? { requestId, ...meta } : meta, message);
+  },
+  
+  child: (bindings) => baseLogger.child(bindings),
+  level: baseLogger.level
+};
+
 module.exports = { 
   logger, 
   createLogger, 
   observabilityLogger, 
-  createObservabilityLogger 
+  createObservabilityLogger,
+  setRequestIdGetter
 };