bulltrackers-module 1.0.229 → 1.0.230

package/functions/computation-system/WorkflowOrchestrator.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Main Orchestrator. Coordinates the topological execution.
- * UPDATED: Includes defensive checks for Logger compatibility.
+ * UPDATED: Implements 'IMPOSSIBLE' state logic for missing root data on historical dates.
  */
 const { normalizeName }                                    = require('./utils/utils');
 const { checkRootDataAvailability }                        = require('./data/AvailabilityChecker');
@@ -10,6 +10,9 @@ const { StandardExecutor }                                 = require('./executor
 const { MetaExecutor }                                     = require('./executors/MetaExecutor');
 const { generateProcessId, PROCESS_TYPES }                 = require('./logger/logger');
 
+// New Status Constant
+const STATUS_IMPOSSIBLE = 'IMPOSSIBLE';
+
 function groupByPass(manifest) { 
     return manifest.reduce((acc, calc) => { 
         (acc[calc.pass] = acc[calc.pass] || []).push(calc); 
@@ -18,28 +21,32 @@ function groupByPass(manifest) {
 }
 
 /**
- * Performs strict analysis of what can run based on availability and hash states.
- * AIRTIGHT LOGIC:
- * 1. Missing Root Data -> Blocked (Writes 'false' to DB)
- * 2. Missing/Stale Dependency -> FailedDependency (Writes 'false' to DB)
- * 3. Hash Mismatch -> ReRun (Cascade or Code Change)
- * 4. No Result -> Run
- * 5. Result Exists & Hash Match -> Skip
+ * Performs strict analysis of what can run.
+ * IMPOSSIBLE LOGIC:
+ * 1. If Root Data is missing AND Date != Today -> IMPOSSIBLE.
+ * 2. If Dependency is IMPOSSIBLE -> IMPOSSIBLE.
+ * 3. IMPOSSIBLE items are written to DB to prevent future retries.
  */
 function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus, manifestMap) {
     const report = {
         runnable: [],
-        blocked: [],          // Missing Root Data
-        failedDependency: [], // Missing Dependency OR Stale Dependency
+        blocked: [],          // Missing Root Data (Today - Retriable)
+        impossible: [],       // Missing Root Data (Historical) or Dependency Impossible
+        failedDependency: [], // Missing/Stale Dependency (Transient)
         reRuns: [],           // Hash Mismatch
         skipped: []           // Already done & valid
     };
 
+    const isTargetToday = (dateStr === new Date().toISOString().slice(0, 10));
+
     const isDepSatisfied = (depName, dailyStatus, manifestMap) => {
         const norm = normalizeName(depName);
         const storedDepHash = dailyStatus[norm];
         const depManifest = manifestMap.get(norm);
 
+        // Check 1: Is dependency IMPOSSIBLE? (Logic handled in main loop, but safe to check here)
+        if (storedDepHash === STATUS_IMPOSSIBLE) return false; 
+
         if (!storedDepHash) return false; 
         if (!depManifest) return false;
         if (storedDepHash !== depManifest.hash) return false;
@@ -52,7 +59,13 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         const storedHash = dailyStatus[cName];
         const currentHash = calc.hash;
 
-        // 1. Root Data Check
+        // 1. Check if ALREADY marked IMPOSSIBLE
+        if (storedHash === STATUS_IMPOSSIBLE) {
+            report.skipped.push({ name: cName, reason: 'Permanently Impossible' });
+            continue;
+        }
+
+        // 2. Root Data Check
         const missingRoots = [];
         if (calc.rootDataDependencies) {
             for (const dep of calc.rootDataDependencies) {
@@ -65,27 +78,49 @@ function analyzeDateExecution(dateStr, calcsInPass, rootDataStatus, dailyStatus,
         }
 
         if (missingRoots.length > 0) {
-            report.blocked.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')}` });
+            // LOGIC: If date is NOT today, missing root data is fatal and permanent.
+            if (!isTargetToday) {
+                report.impossible.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')} (Historical)` });
+            } else {
+                report.blocked.push({ name: cName, reason: `Missing Root Data: ${missingRoots.join(', ')} (Waiting)` });
+            }
             continue;
         }
 
-        // 2. Dependency Check
+        // 3. Dependency Check
+        let dependencyIsImpossible = false;
         const missingDeps = [];
+        
         if (calc.dependencies) {
             for (const dep of calc.dependencies) {
+                const normDep = normalizeName(dep);
+                
+                // Check if the dependency is marked IMPOSSIBLE in the DB
+                if (dailyStatus[normDep] === STATUS_IMPOSSIBLE) {
+                    dependencyIsImpossible = true;
+                    // We can break early, if one input is impossible, the result is impossible.
+                    break; 
+                }
+
                 if (!isDepSatisfied(dep, dailyStatus, manifestMap)) {
                     missingDeps.push(dep);
                 }
             }
         }
 
+        if (dependencyIsImpossible) {
+            // Propagate the Impossible Status
+            report.impossible.push({ name: cName, reason: 'Dependency is Impossible' });
+            continue;
+        }
+
         if (missingDeps.length > 0) {
             report.failedDependency.push({ name: cName, missing: missingDeps });
             continue;
         }
 
-        // 3. Hash / State Check
-        if (!storedHash) {
+        // 4. Hash / State Check
+        if (!storedHash || storedHash === false) { // false indicates previous transient failure
             report.runnable.push(calc);
         } else if (storedHash !== currentHash) {
             report.reRuns.push({ name: cName, oldHash: storedHash, newHash: currentHash });
@@ -123,23 +158,28 @@ 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 (SAFEGUARDED)
+    // 4. LOG ANALYSIS
     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}`;
+        // Safe fallback
+        const logMsg = `[Analysis] Date: ${dateStr} | Runnable: ${analysisReport.runnable.length} | Blocked: ${analysisReport.blocked.length} | Impossible: ${analysisReport.impossible.length}`;
         if (logger && logger.info) logger.info(logMsg);
         else console.log(logMsg);
     }
 
-    // 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);
+    // 5. UPDATE STATUS FOR NON-RUNNABLE ITEMS
+    const statusUpdates = {};
+
+    // A. Mark BLOCKED as 'false' (Transient Failure)
+    analysisReport.blocked.forEach(item => statusUpdates[item.name] = false);
+    analysisReport.failedDependency.forEach(item => statusUpdates[item.name] = false);
+
+    // B. Mark IMPOSSIBLE as 'IMPOSSIBLE' (Permanent Failure - Overwrites existing status)
+    analysisReport.impossible.forEach(item => statusUpdates[item.name] = STATUS_IMPOSSIBLE);
     
-    if (Object.keys(failureUpdates).length > 0) {
-        await updateComputationStatus(dateStr, failureUpdates, config, dependencies);
+    if (Object.keys(statusUpdates).length > 0) {
+        await updateComputationStatus(dateStr, statusUpdates, config, dependencies);
     }
 
     // 6. EXECUTE RUNNABLES
@@ -151,7 +191,12 @@ async function runDateComputation(dateStr, passToRun, calcsInThisPass, config, d
     const finalRunList = calcsInThisPass.filter(c => calcsToRunNames.has(normalizeName(c.name)));
 
     if (!finalRunList.length) {
-        return { date: dateStr, updates: {}, skipped: analysisReport.skipped.length };
+        return { 
+            date: dateStr, 
+            updates: {}, 
+            skipped: analysisReport.skipped.length, 
+            impossible: analysisReport.impossible.length 
+        };
     }
 
     if (logger && logger.log) {

package/functions/computation-system/logger/logger.js

@@ -1,26 +1,14 @@
 /**
  * @fileoverview Structured Logging System for Computation Engine
- * Provides comprehensive tracking with process IDs, context, and filtering capabilities.
- * UPDATED: Fixed Date Analysis keys to match WorkflowOrchestrator (failedDependency vs resolving).
+ * UPDATED: Added 'impossible' category handling to Date Analysis.
  */
 
 const crypto = require('crypto');
 
-/**
- * Log Levels (Ordered by Severity)
- */
 const LOG_LEVELS = {
-    TRACE: 0,
-    DEBUG: 1,
-    INFO: 2,
-    WARN: 3,
-    ERROR: 4,
-    FATAL: 5
+    TRACE: 0, DEBUG: 1, INFO: 2, WARN: 3, ERROR: 4, FATAL: 5
 };
 
-/**
- * Process Types for Tracking
- */
 const PROCESS_TYPES = {
     MANIFEST: 'manifest',
     ORCHESTRATOR: 'orchestrator',
@@ -31,17 +19,11 @@ const PROCESS_TYPES = {
     DISPATCH: 'dispatch'
 };
 
-/**
- * Generates a deterministic process ID.
- */
 function generateProcessId(type, identifier, date = '') {
     const input = `${type}|${identifier}|${date}`;
     return crypto.createHash('sha256').update(input).digest('hex').substring(0, 16);
 }
 
-/**
- * Formats a log entry into structured JSON
- */
 function formatLogEntry(entry) {
     return JSON.stringify({
         timestamp: entry.timestamp,
@@ -68,7 +50,6 @@ class StructuredLogger {
             includeStackTrace: config.includeStackTrace !== false,
             ...config
         };
-        
         this.activeProcesses = new Map();
     }
 
@@ -78,7 +59,6 @@ class StructuredLogger {
             : crypto.randomBytes(8).toString('hex');
 
         const processLogger = new ProcessLogger(this, processType, processId, computationName, date);
-        
         this.activeProcesses.set(processId, {
             type: processType,
             computationName,
@@ -86,7 +66,6 @@ class StructuredLogger {
             startTime: Date.now(),
             logger: processLogger
         });
-        
         return processLogger;
     }
 
@@ -101,17 +80,17 @@ class StructuredLogger {
     }
 
     /**
-     * The Main Date Analysis Logger (FIXED)
-     * Handles 'failedDependency', 'skipped', and 'blocked' correctly.
+     * The Main Date Analysis Logger (UPDATED)
+     * Handles 'impossible' category for permanent failures.
      */
     logDateAnalysis(dateStr, analysisReport) {
-        // Destructure with SAFETY DEFAULTS to prevent crashes
         const { 
             runnable = [], 
             blocked = [], 
+            impossible = [], // New Category
             reRuns = [], 
-            failedDependency = [], // Matches WorkflowOrchestrator
-            skipped = []           // Matches WorkflowOrchestrator
+            failedDependency = [], 
+            skipped = []           
         } = analysisReport;
         
         // 1. Structured Output
@@ -125,6 +104,7 @@ class StructuredLogger {
                 stats: {
                     runnable: runnable.length,
                     blocked: blocked.length,
+                    impossible: impossible.length,
                     reRuns: reRuns.length,
                     failedDependency: failedDependency.length,
                     skipped: skipped.length
@@ -135,7 +115,10 @@ class StructuredLogger {
 
         // 2. Human Readable Output
         if (this.config.enableConsole) {
-            const symbols = { info: 'ℹ️', warn: '⚠️', check: '✅', block: '⛔', link: '🔗', cycle: '🔄', skip: '⏭️' };
+            const symbols = { 
+                info: 'ℹ️', warn: '⚠️', check: '✅', block: '⛔', 
+                cycle: '🔄', skip: '⏭️', dead: '💀' 
+            };
             
             console.log(`\n🔍 === DATE ANALYSIS REPORT: ${dateStr} ===`);
             
@@ -146,29 +129,34 @@ class StructuredLogger {
                 });
             }
 
-            // Updated to handle failedDependency instead of resolving
             if (failedDependency.length) {
-                console.log(`\n${symbols.block} [FAILED DEPENDENCIES] (Missing upstream data)`);
+                console.log(`\n${symbols.block} [FAILED DEPENDENCIES] (Upstream failure)`);
                 failedDependency.forEach(item => {
-                    // item.missing comes from Orchestrator (not item.missingDeps)
                     console.log(`   • ${item.name}: Missing ${item.missing ? item.missing.join(', ') : 'dependencies'}`);
                 });
             }
 
+            // NEW: Impossible items
+            if (impossible.length) {
+                console.log(`\n${symbols.dead} [IMPOSSIBLE] (Permanent Failure - Will not retry)`);
+                impossible.forEach(item => {
+                    console.log(`   • ${item.name}: ${item.reason}`);
+                });
+            }
+
             if (runnable.length) {
                 console.log(`\n${symbols.check} [READY TO RUN]`);
                 runnable.forEach(item => console.log(`   • ${item.name}`));
             }
 
             if (blocked.length) {
-                console.log(`\n${symbols.warn} [BLOCKED] (Missing Root Data)`);
+                console.log(`\n${symbols.warn} [BLOCKED] (Waiting for data - Retriable)`);
                 blocked.forEach(item => {
                     console.log(`   • ${item.name}: ${item.reason}`);
                 });
             }
 
             if (skipped.length) {
-                 // Optional: Only show count if list is huge
                 if (skipped.length > 10) {
                      console.log(`\n${symbols.skip} [SKIPPED] (${skipped.length} calculations up-to-date)`);
                 } else {
@@ -264,7 +252,6 @@ class StructuredLogger {
     }
 }
 
-// ... ProcessLogger and Templates (unchanged) ...
 class ProcessLogger {
     constructor(parent, processType, processId, computationName, date) {
         this.parent = parent;

package/package.json

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