bulltrackers-module 1.0.201 → 1.0.203

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -1,10 +1,13 @@
 /**
  * FILENAME: bulltrackers-module/functions/computation-system/helpers/computation_dispatcher.js
  * PURPOSE: Dispatches computation tasks to Pub/Sub for scalable execution.
+ * FIXED: Instantiates PubSubUtils locally to ensure valid logger/dependencies are used.
+ * IMPROVED: Logging now explicitly lists the calculations being scheduled.
  */
 
 const { getExpectedDateStrings } = require('../utils/utils.js');
 const { groupByPass } = require('./orchestration_helpers.js');
+const { PubSubUtils } = require('../../core/utils/pubsub_utils');
 
 const TOPIC_NAME = 'computation-tasks';
 
@@ -13,16 +16,30 @@ const TOPIC_NAME = 'computation-tasks';
  * Instead of running them, it queues them in Pub/Sub.
  */
 async function dispatchComputationPass(config, dependencies, computationManifest) {
-    const { logger, pubsubUtils } = dependencies;
+    const { logger } = dependencies;
+
+    // Create fresh PubSubUtils instance
+    const pubsubUtils = new PubSubUtils(dependencies);
+
     const passToRun = String(config.COMPUTATION_PASS_TO_RUN);
 
     if (!passToRun) {
         return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.');
     }
 
-    logger.log('INFO', `🚀 [Dispatcher] Preparing to dispatch PASS ${passToRun}...`);
+    // 1. Validate Pass Existence
+    const passes = groupByPass(computationManifest);
+    const calcsInThisPass = passes[passToRun] || [];
+
+    if (!calcsInThisPass.length) {
+        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
+    }
+
+    const calcNames = calcsInThisPass.map(c => c.name).join(', ');
+    logger.log('INFO', `🚀 [Dispatcher] Preparing PASS ${passToRun}.`);
+    logger.log('INFO', `[Dispatcher] Included Calculations: [${calcNames}]`);
 
-    // 1. Determine Date Range (Same logic as PassRunner)
+    // 2. Determine Date Range
     // Hardcoded earliest dates - keep synced with PassRunner for now
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
@@ -36,19 +53,11 @@ async function dispatchComputationPass(config, dependencies, computationManifest
 
     const allExpectedDates = getExpectedDateStrings(passEarliestDate, endDateUTC);
 
-    // 2. Validate Pass Existence
-    const passes = groupByPass(computationManifest);
-    const calcsInThisPass = passes[passToRun] || [];
-
-    if (!calcsInThisPass.length) {
-        return logger.log('WARN', `[Dispatcher] No calcs for Pass ${passToRun}. Exiting.`);
-    }
-
-    logger.log('INFO', `[Dispatcher] Found ${calcsInThisPass.length} calcs for Pass ${passToRun}. Target dates: ${allExpectedDates.length}`);
+    logger.log('INFO', `[Dispatcher] Dispatches checks for ${allExpectedDates.length} dates (${allExpectedDates[0]} to ${allExpectedDates[allExpectedDates.length - 1]}). Workers will validate dependencies.`);
 
     // 3. Dispatch Messages
     let dispatchedCount = 0;
-    const BATCH_SIZE = 50; // Pub/Sub batch publishing size
+    const BATCH_SIZE = 50;
 
     // We can publish in parallel batches
     const chunks = [];
@@ -75,8 +84,8 @@ async function dispatchComputationPass(config, dependencies, computationManifest
         }
     }
 
-    logger.log('INFO', `[Dispatcher] Finished dispatching. Total tasks: ${dispatchedCount}`);
+    logger.log('INFO', `[Dispatcher] Finished. Dispatched ${dispatchedCount} checks for Pass ${passToRun}.`);
     return { dispatched: dispatchedCount };
 }
 
-module.exports = { dispatchComputationPass };
+module.exports = { dispatchComputationPass };

package/functions/computation-system/helpers/computation_worker.js

@@ -1,6 +1,7 @@
 /**
  * FILENAME: bulltrackers-module/functions/computation-system/helpers/computation_worker.js
  * PURPOSE: Consumes computation tasks from Pub/Sub and executes them.
+ * FIXED: Added robust payload parsing to handle Cloud Functions Gen 2 (CloudEvents).
  */
 
 const { runDateComputation } = require('./computation_pass_runner.js');
@@ -8,15 +9,43 @@ const { groupByPass } = require('./orchestration_helpers.js');
 
 /**
  * Handles a single Pub/Sub message for a computation task.
+ * Supports both Gen 1 (Message) and Gen 2 (CloudEvent) formats.
  */
 async function handleComputationTask(message, config, dependencies, computationManifest) {
     const { logger } = dependencies;
 
+    let data;
     try {
-        const data = message.json || message; // Handle both raw payload and parsed JSON
+        // 1. Handle Cloud Functions Gen 2 (CloudEvent)
+        // Structure: event.data.message.data (base64)
+        if (message.data && message.data.message && message.data.message.data) {
+            const buffer = Buffer.from(message.data.message.data, 'base64');
+            data = JSON.parse(buffer.toString());
+        }
+        // 2. Handle Cloud Functions Gen 1 / Legacy PubSub
+        // Structure: message.data (base64) or message.json
+        else if (message.data && typeof message.data === 'string') {
+            const buffer = Buffer.from(message.data, 'base64');
+            data = JSON.parse(buffer.toString());
+        }
+        // 3. Handle Direct JSON (Test harness or simulator)
+        else if (message.json) {
+            data = message.json;
+        }
+        // 4. Fallback: Assume message is the payload
+        else {
+            data = message;
+        }
+    } catch (parseError) {
+        logger.log('ERROR', `[Worker] Failed to parse Pub/Sub payload.`, { error: parseError.message });
+        return;
+    }
 
-        if (data.action !== 'RUN_COMPUTATION_DATE') {
-            logger.log('WARN', `[Worker] Unknown action: ${data.action}. Ignoring.`);
+    try {
+        // Validate Action
+        if (!data || data.action !== 'RUN_COMPUTATION_DATE') {
+            // Only log if data exists but action is wrong, prevents log spam on empty messages
+            if (data) logger.log('WARN', `[Worker] Unknown or missing action: ${data?.action}. Ignoring.`);
             return;
         }
 
@@ -39,12 +68,13 @@ async function handleComputationTask(message, config, dependencies, computationM
         }
 
         // Execute the computation for this specific date
+        // The runner internally checks dependencies (Pass 1, 2, 3 status) and skips if not ready.
         const result = await runDateComputation(date, pass, calcsInThisPass, config, dependencies, computationManifest);
 
         if (result) {
             logger.log('INFO', `[Worker] Successfully processed ${date} (Pass ${pass}). Updates: ${Object.keys(result.updates || {}).length}`);
         } else {
-            logger.log('INFO', `[Worker] Processed ${date} (Pass ${pass}) - No action needed or data missing.`);
+            logger.log('INFO', `[Worker] Processed ${date} (Pass ${pass}) - Skipped (Dependencies missing or already done).`);
         }
 
     } catch (err) {
@@ -53,4 +83,4 @@ async function handleComputationTask(message, config, dependencies, computationM
     }
 }
 
-module.exports = { handleComputationTask };
+module.exports = { handleComputationTask };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.201",
+  "version": "1.0.203",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [