bulltrackers-module 1.0.226 → 1.0.228

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Strict Dependency & Hash Cascade Logic with Explicit Failure Marking.
+ * UPDATED: Includes defensive checks for Logger compatibility.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -31,26 +31,17 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         runnable: [],
         blocked: [],          // Missing Root Data
         failedDependency: [], // Missing Dependency OR Stale Dependency
-        reRuns: [],           // Hash Mismatch (Triggered by self code change OR upstream cascade)
+        reRuns: [],           // Hash Mismatch
         skipped: []           // Already done & valid
     };
 
-    // Helper: Is a dependency satisfied AND valid (matching hash)?
     const isDepSatisfied = (depName, dailyStatus, manifestMap) => {
         const norm = normalizeName(depName);
         const storedDepHash = dailyStatus[norm];
         const depManifest = manifestMap.get(norm);
 
-        // 1. Must exist in DB. If missing, we cannot run.
         if (!storedDepHash) return false; 
-        
-        // 2. Must exist in Manifest (Sanity check)
         if (!depManifest) return false;
-
-        // 3. STRICT: The dependency's stored hash must match its current manifest hash.
-        // If 'A' changed code, 'A' has a new hash. If we are running 'B' (Pass 2),
-        // we expect 'A' (Pass 1) to have already run and updated the DB with the NEW hash.
-        // If DB still has OLD hash, 'A' failed or didn't run. 'B' is unsafe to run.
         if (storedDepHash !== depManifest.hash) return false;
 
         return true;
@@ -61,7 +52,7 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const storedHash = dailyStatus[cName];
         const currentHash = calc.hash;
 
-        // 1. Root Data Check (FATAL)
+        // 1. Root Data Check
         const missingRoots = [];
         if (calc.rootDataDependencies) {
             for (const dep of calc.rootDataDependencies) {
@@ -75,12 +66,10 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         if (missingRoots.length > 0) {
             report.blocked.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')}` });
-            continue; // Cannot proceed
+            continue;
         }
 
-        // 2. Dependency Check (FATAL)
-        // Since we are in a topological pass system, all dependencies SHOULD be satisfied 
-        // by previous passes. If not, it is a fatal error for this calculation.
+        // 2. Dependency Check
         const missingDeps = [];
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
@@ -92,23 +81,17 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 
         if (missingDeps.length > 0) {
             report.failedDependency.push({ name: cName, missing: missingDeps });
-            continue; // Cannot proceed
+            continue;
         }
 
         // 3. Hash / State Check
         if (!storedHash) {
-            // Case A: No result exists (or status is 'false' from previous failure) -> RUN
-            // Note: If storedHash is boolean false, !storedHash is true, so we retry.
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
-            // Case B: Result exists, but hash mismatch -> RE-RUN
-            // This covers code changes in THIS calc, AND cascading changes from dependencies
             report.reRuns.push({ name: cName, oldHash: storedHash, newHash: currentHash });
         } else if (storedHash === true) {
-            // Case C: Legacy boolean status -> RE-RUN (Upgrade to hash)
             report.reRuns.push({ name: cName, reason: 'Legacy Upgrade' });
         } else {
-            // Case D: Result exists, Hash Matches -> SKIP
             report.skipped.push({ name: cName });
         }
     }
@@ -119,13 +102,12 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
 async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, dependencies, computationManifest) {
     const { logger } = dependencies;
     const orchestratorPid = generateProcessId(PROCESS_TYPES.ORCHESTRATOR, passToRun, dateStr);
-
     const dateToProcess = new Date(dateStr + 'T00:00:00Z');
     
     // 1. Fetch State
     const dailyStatus = await fetchComputationStatus(dateStr, config, dependencies);
     
-    // 2. Check Data Availability (One shot)
+    // 2. Check Data Availability
     const earliestDates = {
         portfolio: new Date('2025-09-25T00:00:00Z'),
         history:   new Date('2025-11-05T00:00:00Z'), 
@@ -141,11 +123,17 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const manifestMap = new Map(computationManifest.map(c => [normalizeName(c.name), c]));
     const analysisReport = analyzeDateExecution(dateStr, calcsInThisPass, rootStatus, dailyStatus, manifestMap);
     
-    // 4. LOG ANALYSIS
-    logger.logDateAnalysis(dateStr, analysisReport);
+    // 4. LOG ANALYSIS (SAFEGUARDED)
+    if (logger && typeof logger.logDateAnalysis === 'function') {
+        logger.logDateAnalysis(dateStr, analysisReport);
+    } else {
+        // Fallback if injected logger is outdated
+        const logMsg = `[Analysis] Date: ${dateStr} | Runnable: ${analysisReport.runnable.length} | Blocked: ${analysisReport.blocked.length} | ReRuns: ${analysisReport.reRuns.length}`;
+        if (logger && logger.info) logger.info(logMsg);
+        else console.log(logMsg);
+    }
 
-    // 5. MARK FAILURES (Explicitly write 'false' to DB for blocked items)
-    // This prevents UI/downstream consumers from waiting indefinitely.
+    // 5. MARK FAILURES (Write 'false' to DB for blocked items)
     const failureUpdates = {};
     analysisReport.blocked.forEach(item => failureUpdates[item.name] = false);
     analysisReport.failedDependency.forEach(item => failureUpdates[item.name] = false);
@@ -163,11 +151,12 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const finalRunList = calcsInThisPass.filter(c => calcsToRunNames.has(normalizeName(c.name)));
 
     if (!finalRunList.length) {
-        // Nothing to run (everything either skipped, blocked, or failed)
         return { date: dateStr, updates: {}, skipped: analysisReport.skipped.length };
     }
 
-    logger.log('INFO', `[Orchestrator] Executing ${finalRunList.length} calculations for ${dateStr}`, { processId: orchestratorPid });
+    if (logger && logger.log) {
+        logger.log('INFO', `[Orchestrator] Executing ${finalRunList.length} calculations for ${dateStr}`, { processId: orchestratorPid });
+    }
 
     const standardToRun = finalRunList.filter(c => c.type === 'standard');
     const metaToRun     = finalRunList.filter(c => c.type === 'meta');
@@ -177,11 +166,8 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     try {
         const calcsRunning = [...standardToRun, ...metaToRun];
         
-        // Fetch dependencies (Previous pass results)
-        // includeSelf=false: We are re-running, so we ignore our own old results.
+        // Fetch dependencies
         const existingResults = await fetchExistingResults(dateStr, calcsRunning, computationManifest, config, dependencies, false);
-        
-        // Fetch Yesterday's results (if Historical)
         const prevDate        = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
         const prevDateStr     = prevDate.toISOString().slice(0, 10);
         const previousResults = await fetchExistingResults(prevDateStr, calcsRunning, computationManifest, config, dependencies, true);
@@ -196,9 +182,11 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
         }
 
     } catch (err) {
-        // If execution CRASHES (code bug, timeout), we log and throw.
-        // Pub/Sub will retry this message. This is correct for transient errors.
-        logger.log('ERROR', `[Orchestrator] Failed execution for ${dateStr}`, { processId: orchestratorPid, error: err.message });
+        if (logger && logger.log) {
+            logger.log('ERROR', `[Orchestrator] Failed execution for ${dateStr}`, { processId: orchestratorPid, error: err.message });
+        } else {
+            console.error(`[Orchestrator] Failed execution for ${dateStr}: ${err.message}`);
+        }
         throw err; 
     }
 

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

@@ -1,15 +1,15 @@
 /**
  * FILENAME: computation-system/helpers/computation_worker.js
  * PURPOSE: Consumes computation tasks from Pub/Sub and executes them.
- * UPDATED: Fixed import source. Points to actual Calculations package, not layers.
+ * UPDATED: Instantiates the internal StructuredLogger to replace the generic injected logger.
  */
 
 const { runDateComputation, groupByPass } = require('../WorkflowOrchestrator.js');
 const { getManifest }                     = require('../topology/ManifestLoader');
+const { StructuredLogger }                = require('../logger/logger'); // <--- CRITICAL IMPORT
 
-// 1. IMPORT CALCULATIONS (CORRECTED)
+// 1. IMPORT CALCULATIONS
 // We import the specific package containing your strategies (gem, pyro, core, etc.)
-// Adjust the require path if you are using a local relative path instead of node_modules.
 let calculationPackage;
 try {
     // Primary: Try to load from the installed npm package
@@ -21,34 +21,50 @@ try {
 
 
 // The package exports { calculations: { ... }, utils: { ... } }
-// We only need the 'calculations' object (which contains the folder-grouped classes)
 const calculations = calculationPackage.calculations;
 
 /**
  * Handles a single Pub/Sub message for a computation task.
  * Supports both Gen 1 (Message) and Gen 2 (CloudEvent) formats.
  * @param {object} message - The Pub/Sub message payload.
- * @param {object} config - System configuration (must include activeProductLines).
- * @param {object} dependencies - System dependencies (logger, db, etc.).
+ * @param {object} config - System configuration.
+ * @param {object} dependencies - Injected dependencies (db, generic logger, etc.).
  */
 async function handleComputationTask(message, config, dependencies) {
-    const { logger } = dependencies;
+    
+    // 2. INITIALIZE SYSTEM LOGGER
+    // We ignore the generic 'dependencies.logger' and instantiate our specialized one.
+    // This ensures methods like 'logDateAnalysis' and 'logStorage' exist.
+    const systemLogger = new StructuredLogger({
+        minLevel: config.minLevel || 'INFO',
+        enableStructured: true,
+        ...config // Apply any other relevant config overrides
+    });
 
-    // 2. LAZY LOAD MANIFEST
-    // We pass the CORRECT 'calculations' object here (e.g. { core: {...}, pyro: {...} })
+    // 3. OVERRIDE DEPENDENCIES
+    // We create a new dependencies object to pass downstream.
+    // This fixes the "logger.logStorage is not a function" error in ResultCommitter.js
+    const runDependencies = {
+        ...dependencies,
+        logger: systemLogger
+    };
+
+    const { logger } = runDependencies; // Use this for local logging
+
+    // 4. LAZY LOAD MANIFEST
     let computationManifest;
     try {
         computationManifest = getManifest(
             config.activeProductLines || [], 
             calculations, 
-            dependencies
+            runDependencies // Pass the updated dependencies
         );
     } catch (manifestError) {
         logger.log('FATAL', `[Worker] Failed to load Manifest: ${manifestError.message}`);
         return; 
     }
 
-    // 3. PARSE PUB/SUB MESSAGE
+    // 5. PARSE PUB/SUB MESSAGE
     let data;
     try {
         if (message.data && message.data.message && message.data.message.data) { 
@@ -67,7 +83,7 @@ async function handleComputationTask(message, config, dependencies) {
         return; 
     }
 
-    // 4. EXECUTE TASK
+    // 6. EXECUTE TASK
     try {
         if (!data || data.action !== 'RUN_COMPUTATION_DATE') { 
             if (data) logger.log('WARN', `[Worker] Unknown or missing action: ${data?.action}. Ignoring.`); 
@@ -95,7 +111,7 @@ async function handleComputationTask(message, config, dependencies) {
             pass, 
             calcsInThisPass, 
             config, 
-            dependencies, 
+            runDependencies, // <--- IMPORTANT: Pass the dependencies with the System Logger
             computationManifest
         );
         

package/package.json

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