@peopl-health/nexus 2.4.3 → 2.4.5

package/lib/helpers/assistantHelper.js

@@ -5,6 +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 DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
@@ -77,7 +78,7 @@ const runAssistantAndWait = async ({
   let completed = false;
 
   try {
-    console.log('[runAssistantAndWait] RUN ID', run.id, 'THREAD ID', thread.getConversationId(), 'ASSISTANT ID', thread.getAssistantId());
+    logger.log('[runAssistantAndWait] RUN ID', run.id, 'THREAD ID', thread.getConversationId(), 'ASSISTANT ID', thread.getAssistantId());
     ({run, completed} = await provider.checkRunStatus(assistant, thread.getConversationId(), run.id, 0, maxRetries));
   } finally {
     if (filter) {
@@ -101,7 +102,7 @@ const executeAssistantAttempt = async (thread, assistant, runConfig, attemptNumb
     runConfig
   });
   
-  console.log(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
+  logger.log(`[executeAssistantAttempt] Attempt ${attemptNumber}: completed=${result.completed}, output=${result.output || '(empty)'}`);
   
   return result;
 };
@@ -111,6 +112,7 @@ const runAssistantWithRetries = async (thread, assistant, runConfig, patientRepl
     assistant.setReplies(patientReply);
   }
 
+  const startTime = Date.now();
   let run, output, completed;
   let retries = 0;
   const maxRetries = DEFAULT_MAX_RETRIES;
@@ -128,14 +130,24 @@ const runAssistantWithRetries = async (thread, assistant, runConfig, patientRepl
     )(thread, assistant, runConfig, retries));
     
     if (completed && output) break;
-    if (retries < maxRetries) await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    if (retries < maxRetries) {
+      const delay = retries === 1 
+        ? 500
+        : Math.min(1000 * Math.pow(1.5, retries - 1), 5000);
+      logger.log(`[runAssistantWithRetries] Retry ${retries}, waiting ${delay}ms`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
   } while (retries < maxRetries && (!completed || !output));
 
-  if (run?.last_error) console.log('[runAssistantWithRetries] RUN LAST ERROR:', run.last_error);
-  console.log('[runAssistantWithRetries] RUN STATUS', completed);
-  console.log('[runAssistantWithRetries] OUTPUT', 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 });
   
-  return { run, output, completed, retries };
+  return { run, output, completed, retries, predictionTimeMs };
 };
 
 module.exports = {

package/lib/index.js

@@ -23,6 +23,11 @@ const {
   hasPreprocessingHandler,
   invokePreprocessingHandler
 } = require('./services/preprocessingHooks');
+const { 
+  requestIdMiddleware, 
+  getRequestId, 
+  logger 
+} = require('./middleware/requestId');
 
 /**
  * Main Nexus class that orchestrates all components
@@ -341,5 +346,9 @@ module.exports = {
   listFlows: interactive.listFlows,
   sendInteractive: interactive.sendInteractive,
   registerInteractiveHandler: interactive.registerInteractiveHandler,
-  attachInteractiveRouter: interactive.attachInteractiveRouter
+  attachInteractiveRouter: interactive.attachInteractiveRouter,
+  // Request tracing
+  requestIdMiddleware,
+  getRequestId,
+  logger
 };

package/lib/middleware/requestId.js

@@ -0,0 +1,41 @@
+const { AsyncLocalStorage } = require('async_hooks');
+const { v4: uuidv4 } = require('uuid');
+
+const requestContext = new AsyncLocalStorage();
+
+function getRequestId() {
+  const store = requestContext.getStore();
+  return store?.requestId || 'no-context';
+}
+
+function requestIdMiddleware(req, res, next) {
+  const requestId = uuidv4().substring(0, 8);
+  req.requestId = requestId;
+  res.setHeader('X-Request-Id', requestId);
+  
+  requestContext.run({ requestId }, () => {
+    console.log(`[${requestId}] → ${req.method} ${req.path}`);
+    
+    const startTime = Date.now();
+    res.on('finish', () => {
+      const duration = Date.now() - startTime;
+      console.log(`[${requestId}] ← ${res.statusCode} ${req.method} ${req.path} (${duration}ms)`);
+    });
+    
+    next();
+  });
+}
+
+const logger = {
+  log: (...args) => console.log(`[${getRequestId()}]`, ...args),
+  error: (...args) => console.error(`[${getRequestId()}]`, ...args),
+  warn: (...args) => console.warn(`[${getRequestId()}]`, ...args),
+  info: (...args) => console.info(`[${getRequestId()}]`, ...args),
+  debug: (...args) => console.debug(`[${getRequestId()}]`, ...args)
+};
+
+module.exports = { 
+  requestIdMiddleware, 
+  getRequestId,
+  logger 
+};

package/lib/models/messageModel.js

@@ -59,6 +59,9 @@ const messageSchema = new mongoose.Schema({
 messageSchema.index({ message_id: 1, timestamp: 1 }, { unique: true });
 messageSchema.index({ numero: 1, createdAt: -1 });
 
+messageSchema.index({ numero: 1, processed: 1, origin: 1 }, { name: 'numero_processed_origin_idx' });
+messageSchema.index({ numero: 1, createdAt: -1, processed: 1 }, { name: 'numero_created_processed_idx' });
+
 messageSchema.pre('save', function (next) {
   if (this.timestamp) {
     this.timestamp = moment.tz(this.timestamp, 'America/Mexico_City').toDate();

package/lib/models/predictionMetricsModel.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+
+const predictionMetricsSchema = new mongoose.Schema({
+  message_id: { type: String, required: true, index: true },
+  numero: { type: String, required: true, index: true },
+  assistant_id: { type: String, required: true, index: true },
+  thread_id: { type: String, required: true },
+  prediction_time_ms: { type: Number, required: true },
+  retry_count: { type: Number, required: true, default: 1 },
+  completed: { type: Boolean, default: true },
+  error: { type: String, default: null },
+  timing_breakdown: { type: Object, default: {} }
+}, { timestamps: true });
+
+predictionMetricsSchema.index({ createdAt: -1 });
+predictionMetricsSchema.index({ assistant_id: 1, createdAt: -1 });
+predictionMetricsSchema.index({ numero: 1, createdAt: -1 });
+
+const PredictionMetrics = mongoose.model('PredictionMetrics', predictionMetricsSchema);
+
+module.exports = { PredictionMetrics, predictionMetricsSchema };

package/lib/services/assistantService.js

@@ -6,6 +6,7 @@ const { BaseAssistant } = require('../assistants/BaseAssistant');
 const { createProvider } = require('../providers/createProvider');
 
 const { Thread } = require('../models/threadModel.js');
+const { PredictionMetrics } = require('../models/predictionMetricsModel');
 
 const { getCurRow } = require('../helpers/assistantHelper.js');
 const { runAssistantAndWait, runAssistantWithRetries } = require('../helpers/assistantHelper.js');
@@ -14,6 +15,7 @@ const { withTracing } = require('../utils/tracingDecorator.js');
 const { processIndividualMessage } = require('../helpers/processHelper.js');
 const { getLastMessages } = require('../helpers/messageHelper.js');
 const { combineImagesToPDF, cleanupFiles } = require('../helpers/filesHelper.js');
+const { logger } = require('../middleware/requestId');
 
 const DEFAULT_MAX_RETRIES = parseInt(process.env.MAX_RETRIES || '30', 10);
 
@@ -268,6 +270,10 @@ const addInsAssistant = withTracing(
 );
 
 const replyAssistantCore = async (code, message_ = null, thread_ = null, runOptions = {}) => {
+  const timings = {};
+  const startTotal = Date.now();
+  
+  timings.getThread = Date.now();
   const thread = thread_ || await withTracing(getThread, 'get_thread_operation', 
     (threadCode) => ({ 
       'thread.code': threadCode,
@@ -275,30 +281,43 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
       'thread.provided': !!thread_
     })
   )(code);
+  timings.getThread = Date.now() - timings.getThread;
+  
   if (!thread) return null;
 
+  timings.getMessages = Date.now();
   const patientReply = await getLastMessages(code);
+  timings.getMessages = Date.now() - timings.getMessages;
+  
   if (!patientReply) {
-    console.log('[replyAssistantCore] No relevant data found for this assistant.');
+    logger.log('[replyAssistantCore] No relevant data found for this assistant.');
     return null;
   }
 
   const provider = createProvider({ variant: process.env.VARIANT || 'assistants' });
   
-  let patientMsg = false;
-  let urls = [];
-  for (let i = 0; i < patientReply.length; i++) {
-    const reply = patientReply[i];
-    const { isPatient, url } = await processIndividualMessage(code, reply, provider, thread);
-    console.log(`[replyAssistantCore] Processing message ${i + 1}/${patientReply.length}: isPatient=${isPatient}, hasUrl=${!!url}`);
-    patientMsg = patientMsg || isPatient;
-    if (url) urls.push({ 'url': url });
-  }
+  timings.processMessages = Date.now();
+  logger.log(`[replyAssistantCore] Processing ${patientReply.length} messages in parallel`);
+  const results = await Promise.all(
+    patientReply.map((reply, i) => 
+      processIndividualMessage(code, reply, provider, thread)
+        .then(result => {
+          logger.log(`[replyAssistantCore] Message ${i + 1}/${patientReply.length}: isPatient=${result.isPatient}, hasUrl=${!!result.url}`);
+          return result;
+        })
+    )
+  );
+  timings.processMessages = Date.now() - timings.processMessages;
+  
+  const patientMsg = results.some(r => r.isPatient);
+  const urls = results.filter(r => r.url).map(r => ({ url: r.url }));
   
   if (urls.length > 0) {
-    console.log(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
+    timings.pdfCombination = Date.now();
+    logger.log(`[replyAssistantCore] Processing ${urls.length} URLs for PDF combination`);
     const { pdfBuffer, processedFiles } = await combineImagesToPDF({ code });
-    console.log(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
+    timings.pdfCombination = Date.now() - timings.pdfCombination;
+    logger.log(`[replyAssistantCore] PDF combination complete: ${processedFiles?.length || 0} files processed`);
     
     if (pdfBuffer) {
       const key = `${code}-${Date.now()}-combined.pdf`;
@@ -315,8 +334,9 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
 
   if (!patientMsg || thread.stopped) return null;
 
+  timings.runAssistant = Date.now();
   const assistant = getAssistantById(thread.getAssistantId(), thread);
-  const { run, output, completed, retries } = await withTracing(
+  const { run, output, completed, retries, predictionTimeMs } = await withTracing(
     runAssistantWithRetries,
     'run_assistant_with_retries',
     (thread, assistant, runConfig, patientReply) => ({
@@ -325,6 +345,36 @@ const replyAssistantCore = async (code, message_ = null, thread_ = null, runOpti
       'assistant.has_patient_reply': !!patientReply
     })
   )(thread, assistant, runOptions, patientReply);
+  timings.runAssistant = Date.now() - timings.runAssistant;
+  timings.total = Date.now() - startTotal;
+
+  logger.log('[Performance Breakdown]', {
+    code: code ? `${code.substring(0, 3)}***${code.slice(-4)}` : 'unknown',
+    messageCount: patientReply.length,
+    hasMedia: urls.length > 0,
+    retries,
+    time: `${timings.total}ms`
+  });
+
+  if (output && predictionTimeMs) {
+    await PredictionMetrics.create({
+      message_id: `${code}-${Date.now()}`,
+      numero: code,
+      assistant_id: thread.getAssistantId(),
+      thread_id: thread.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));
+  }
 
   return output;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peopl-health/nexus",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "Core messaging and assistant library for WhatsApp communication platforms",
   "keywords": [
     "whatsapp",