bulltrackers-module 1.0.228 → 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: Includes Pre-flight Date Analysis and Storage Observability.
+ * 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',
@@ -28,30 +16,14 @@ const PROCESS_TYPES = {
     STORAGE: 'storage',
     WORKER: 'worker',
     ANALYSIS: 'analysis',
-    // Legacy / Specific aliases
-    SCHEMA_GENERATION: 'schema_generation',
-    COMPUTATION_EXECUTION: 'computation_execution',
-    DEPENDENCY_FETCH: 'dependency_fetch',
-    DATA_AVAILABILITY: 'data_availability',
     DISPATCH: 'dispatch'
 };
 
-/**
- * Generates a deterministic process ID from inputs.
- * Ensures that logs for the same computation/date always have the same Trace ID.
- * @param {string} type - Process type (e.g., 'orchestrator')
- * @param {string} identifier - Unique key (e.g., pass name, calculation name)
- * @param {string} date - Date string YYYY-MM-DD (optional)
- * @returns {string} 16-character hexadecimal 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,
@@ -63,16 +35,12 @@ function formatLogEntry(entry) {
         message: entry.message,
         context: entry.context,
         metadata: entry.metadata,
-        // Specific fields for specialized logs
         stats: entry.stats,
         storage: entry.storage,
         details: entry.details
     });
 }
 
-/**
- * Main Structured Logger Class
- */
 class StructuredLogger {
     constructor(config = {}) {
         this.config = {
@@ -82,25 +50,15 @@ class StructuredLogger {
             includeStackTrace: config.includeStackTrace !== false,
             ...config
         };
-        
         this.activeProcesses = new Map();
     }
 
-    /**
-     * Starts a tracked process and returns a ProcessLogger
-     * @param {string} processType - Type from PROCESS_TYPES
-     * @param {string} computationName - Optional computation name
-     * @param {string} date - Optional date string
-     * @returns {ProcessLogger}
-     */
     startProcess(processType, computationName = null, date = null) {
-        // Use deterministic ID if components are present, else random/time-based fallback
         const processId = (computationName || date) 
             ? generateProcessId(processType, computationName || 'general', date)
             : crypto.randomBytes(8).toString('hex');
 
         const processLogger = new ProcessLogger(this, processType, processId, computationName, date);
-        
         this.activeProcesses.set(processId, {
             type: processType,
             computationName,
@@ -108,13 +66,9 @@ class StructuredLogger {
             startTime: Date.now(),
             logger: processLogger
         });
-        
         return processLogger;
     }
 
-    /**
-     * Ends a tracked process
-     */
     endProcess(processId) {
         const process = this.activeProcesses.get(processId);
         if (process) {
@@ -126,13 +80,20 @@ class StructuredLogger {
     }
 
     /**
-     * The Main Date Analysis Logger (NEW)
-     * Aggregates the status of all calculations for a specific date into one readable report.
+     * The Main Date Analysis Logger (UPDATED)
+     * Handles 'impossible' category for permanent failures.
      */
     logDateAnalysis(dateStr, analysisReport) {
-        const { runnable, blocked, reRuns, resolving } = analysisReport;
+        const { 
+            runnable = [], 
+            blocked = [], 
+            impossible = [], // New Category
+            reRuns = [], 
+            failedDependency = [], 
+            skipped = []           
+        } = analysisReport;
         
-        // 1. Structured Output (Machine Readable)
+        // 1. Structured Output
         if (this.config.enableStructured) {
             console.log(JSON.stringify({
                 timestamp: new Date().toISOString(),
@@ -143,30 +104,43 @@ class StructuredLogger {
                 stats: {
                     runnable: runnable.length,
                     blocked: blocked.length,
+                    impossible: impossible.length,
                     reRuns: reRuns.length,
-                    resolving: resolving.length
+                    failedDependency: failedDependency.length,
+                    skipped: skipped.length
                 },
                 details: analysisReport
             }));
         }
 
-        // 2. Human Readable Output (Console)
+        // 2. Human Readable Output
         if (this.config.enableConsole) {
-            const symbols = { info: 'ℹ️', warn: '⚠️', check: '✅', block: '⛔', link: '🔗', cycle: '🔄' };
+            const symbols = { 
+                info: 'ℹ️', warn: '⚠️', check: '✅', block: '⛔', 
+                cycle: '🔄', skip: '⏭️', dead: '💀' 
+            };
             
             console.log(`\n🔍 === DATE ANALYSIS REPORT: ${dateStr} ===`);
             
             if (reRuns.length) {
                 console.log(`\n${symbols.cycle} [HASH MISMATCH / RE-RUNS]`);
                 reRuns.forEach(item => {
-                    console.log(`   • ${item.name}: Hash changed (Old: ${item.oldHash?.substring(0,6)}... New: ${item.newHash?.substring(0,6)}...). Cascade: ${item.cascade?.length || 0} dependents.`);
+                    console.log(`   • ${item.name}: Hash changed. (Old: ${item.oldHash?.substring(0,6)}... New: ${item.newHash?.substring(0,6)}...)`);
                 });
             }
 
-            if (resolving.length) {
-                console.log(`\n${symbols.link} [DEPENDENCY RESOLUTION] (Will run after deps)`);
-                resolving.forEach(item => {
-                    console.log(`   • ${item.name}: Waiting for [${item.missingDeps.join(', ')}]`);
+            if (failedDependency.length) {
+                console.log(`\n${symbols.block} [FAILED DEPENDENCIES] (Upstream failure)`);
+                failedDependency.forEach(item => {
+                    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}`);
                 });
             }
 
@@ -176,20 +150,26 @@ class StructuredLogger {
             }
 
             if (blocked.length) {
-                console.log(`\n${symbols.block} [BLOCKED / SKIPPED]`);
+                console.log(`\n${symbols.warn} [BLOCKED] (Waiting for data - Retriable)`);
                 blocked.forEach(item => {
                     console.log(`   • ${item.name}: ${item.reason}`);
                 });
             }
+
+            if (skipped.length) {
+                if (skipped.length > 10) {
+                     console.log(`\n${symbols.skip} [SKIPPED] (${skipped.length} calculations up-to-date)`);
+                } else {
+                    console.log(`\n${symbols.skip} [SKIPPED]`);
+                    skipped.forEach(item => console.log(`   • ${item.name}`));
+                }
+            }
+
             console.log(`\n=============================================\n`);
         }
     }
 
-    /**
-     * Storage Observability Logger (NEW)
-     */
     logStorage(processId, calcName, date, path, sizeBytes, isSharded) {
-        // Standard Log Call with extended metadata
         this.log(LOG_LEVELS.INFO, `Results stored for ${calcName}`, {
             storage: { 
                 path, 
@@ -200,16 +180,10 @@ class StructuredLogger {
         }, PROCESS_TYPES.STORAGE, processId, calcName, date);
     }
 
-    /**
-     * Core logging method
-     */
     log(level, message, context = {}, processType = null, processId = null, computationName = null, date = null) {
         const numericLevel = typeof level === 'string' ? LOG_LEVELS[level] : level;
-        
         if (numericLevel < this.config.minLevel) return;
 
-        // Support passing "meta" object in place of context for newer calls
-        // Logic: If context contains 'processId' or 'storage', it's likely a meta object
         let finalContext = context;
         let finalMetadata = {};
         let finalStats = undefined;
@@ -222,7 +196,6 @@ class StructuredLogger {
             if (context.date) date = context.date;
             if (context.stats) finalStats = context.stats;
             if (context.storage) finalStorage = context.storage;
-            // Clean up context to be just the data remaining
             finalContext = { ...context };
             delete finalContext.processId; delete finalContext.processType;
             delete finalContext.computationName; delete finalContext.date;
@@ -243,25 +216,19 @@ class StructuredLogger {
             storage: finalStorage
         };
 
-        // Add stack trace for errors
         if (numericLevel >= LOG_LEVELS.ERROR && this.config.includeStackTrace && finalContext.stack) {
             entry.metadata.stackTrace = finalContext.stack;
         }
 
-        // Console output (pretty-printed for development)
         if (this.config.enableConsole) {
             this._consoleLog(entry);
         }
 
-        // Structured output (for log aggregation systems)
         if (this.config.enableStructured) {
             console.log(formatLogEntry(entry));
         }
     }
 
-    /**
-     * Pretty console output for development
-     */
     _consoleLog(entry) {
         const symbols = { TRACE: '🔍', DEBUG: '🐛', INFO: 'ℹ️', WARN: '⚠️', ERROR: '❌', FATAL: '💀' };
         const colors = {
@@ -273,38 +240,18 @@ class StructuredLogger {
         const symbol = symbols[entry.level] || 'ℹ️';
 
         let output = `${color}${symbol} [${entry.level}]${reset}`;
-        
         if (entry.processType) output += ` [${entry.processType}]`;
-        if (entry.processId) output += ` [${entry.processId.substring(0, 8)}]`;
         if (entry.computationName) output += ` [${entry.computationName}]`;
-        if (entry.date) output += ` [${entry.date}]`;
         
         output += ` ${entry.message}`;
 
         console.log(output);
-
-        // Print context if present and not empty
         if (entry.context && Object.keys(entry.context).length > 0) {
-            console.log(`  ${color}Context:${reset}`, entry.context);
-        }
-        if (entry.storage) {
-             console.log(`  ${color}Storage:${reset}`, entry.storage);
+            console.log(`  Context:`, entry.context);
         }
     }
-
-    // Convenience methods
-    trace(message, context = {}) { this.log(LOG_LEVELS.TRACE, message, context); }
-    debug(message, context = {}) { this.log(LOG_LEVELS.DEBUG, message, context); }
-    info(message, context = {}) { this.log(LOG_LEVELS.INFO, message, context); }
-    warn(message, context = {}) { this.log(LOG_LEVELS.WARN, message, context); }
-    error(message, context = {}) { this.log(LOG_LEVELS.ERROR, message, context); }
-    fatal(message, context = {}) { this.log(LOG_LEVELS.FATAL, message, context); }
 }
 
-/**
- * Process-scoped Logger
- * Automatically includes process context in all log calls
- */
 class ProcessLogger {
     constructor(parent, processType, processId, computationName, date) {
         this.parent = parent;
@@ -313,142 +260,20 @@ class ProcessLogger {
         this.computationName = computationName;
         this.date = date;
         this.startTime = Date.now();
-        this.metrics = {
-            operations: 0,
-            errors: 0,
-            warnings: 0
-        };
+        this.metrics = { operations: 0, errors: 0, warnings: 0 };
     }
-
     log(level, message, context = {}) {
-        const numericLevel = typeof level === 'string' ? LOG_LEVELS[level] : level;
-        
         this.metrics.operations++;
-        if (numericLevel === LOG_LEVELS.ERROR || numericLevel === LOG_LEVELS.FATAL) {
-            this.metrics.errors++;
-        }
-        if (numericLevel === LOG_LEVELS.WARN) {
-            this.metrics.warnings++;
-        }
-
-        this.parent.log(
-            level,
-            message,
-            context,
-            this.processType,
-            this.processId,
-            this.computationName,
-            this.date
-        );
+        this.parent.log(level, message, context, this.processType, this.processId, this.computationName, this.date);
     }
-
-    /**
-     * Complete the process and log summary
-     */
     complete(success = true, finalMessage = null) {
         const duration = Date.now() - this.startTime;
-        const level = success ? LOG_LEVELS.INFO : LOG_LEVELS.ERROR;
-        
-        const summaryMessage = finalMessage || (success 
-            ? `Process completed successfully`
-            : `Process completed with errors`);
-
-        this.log(level, summaryMessage, {
-            stats: {
-                duration: `${duration}ms`,
-                durationMs: duration,
-                operations: this.metrics.operations,
-                errors: this.metrics.errors,
-                warnings: this.metrics.warnings,
-                success
-            }
-        });
-
+        this.log(success ? LOG_LEVELS.INFO : LOG_LEVELS.ERROR, 
+            finalMessage || (success ? 'Process completed' : 'Process failed'), 
+            { stats: { durationMs: duration, ...this.metrics, success } });
         this.parent.endProcess(this.processId);
         return duration;
     }
-
-    // Convenience methods
-    trace(message, context = {}) { this.log(LOG_LEVELS.TRACE, message, context); }
-    debug(message, context = {}) { this.log(LOG_LEVELS.DEBUG, message, context); }
-    info(message, context = {}) { this.log(LOG_LEVELS.INFO, message, context); }
-    warn(message, context = {}) { this.log(LOG_LEVELS.WARN, message, context); }
-    error(message, context = {}) { this.log(LOG_LEVELS.ERROR, message, context); }
-    fatal(message, context = {}) { this.log(LOG_LEVELS.FATAL, message, context); }
 }
 
-/**
- * Log Message Templates
- */
-const LOG_TEMPLATES = {
-    // Schema Generation
-    SCHEMA_SUCCESS: (computationName) => 
-        `Schema generation successful for ${computationName}`,
-    SCHEMA_FAILURE: (computationName, reason) => 
-        `Schema generation failed for ${computationName}: ${reason}`,
-
-    // Computation Execution
-    COMPUTATION_START: (computationName, date) => 
-        `Starting computation ${computationName} for ${date}`,
-    COMPUTATION_SUCCESS: (computationName, date) => 
-        `Computation successful for ${computationName} on ${date}`,
-    COMPUTATION_FAILURE: (computationName, date, reason) => 
-        `Computation failed for ${computationName} on ${date}: ${reason}`,
-
-    // Storage
-    STORAGE_SUCCESS: (computationName, date, path, size) => 
-        `Results stored for ${computationName} on ${date} at ${path} (${size} bytes)`,
-    STORAGE_FAILURE: (computationName, date, path, reason) => 
-        `Failed to store results for ${computationName} on ${date} at ${path}: ${reason}`,
-
-    // Hash Validation
-    HASH_MISMATCH: (computationName, storedHash, currentHash) => 
-        `Hash mismatch for ${computationName}: stored=${storedHash}, current=${currentHash}`,
-    HASH_MATCH: (computationName) => 
-        `Hash match for ${computationName}, no code changes detected`,
-    HASH_CASCADE: (computationName, affectedComputations) => 
-        `Code change in ${computationName} will cascade to: ${affectedComputations.join(', ')}`,
-
-    // Manifest
-    MANIFEST_SUCCESS: (computationCount) => 
-        `Manifest built successfully with ${computationCount} computations`,
-    MANIFEST_TREE: (tree) => 
-        `Dependency tree:\n${tree}`,
-
-    // Date Analysis
-    DATE_ANALYSIS: (date, runnable, notRunnable) => 
-        `Date ${date}: ${runnable.length} runnable, ${notRunnable.length} blocked`,
-    DATE_MISSING_ROOTDATA: (date, computationName, missingData) => 
-        `${computationName} on ${date}: Cannot run due to missing root data: ${missingData.join(', ')}`,
-    DATE_MISSING_DEPENDENCY: (date, computationName, missingDep) => 
-        `${computationName} on ${date}: Will resolve after ${missingDep} completes`,
-    DATE_HASH_RERUN: (date, computationName, affectedDeps) => 
-        `${computationName} on ${date}: Hash mismatch, re-running (affects: ${affectedDeps.join(', ')})`,
-
-    // Availability
-    DATA_AVAILABLE: (date, types) => 
-        `Data available for ${date}: ${types.join(', ')}`,
-    DATA_MISSING: (date, types) => 
-        `Data missing for ${date}: ${types.join(', ')}`,
-
-    // Dispatch/Worker
-    DISPATCH_START: (pass, dateCount) => 
-        `Dispatching Pass ${pass} for ${dateCount} dates`,
-    DISPATCH_COMPLETE: (pass, dispatched) => 
-        `Dispatch complete: ${dispatched} tasks for Pass ${pass}`,
-    WORKER_TASK_START: (date, pass) => 
-        `Worker starting task: Date=${date}, Pass=${pass}`,
-    WORKER_TASK_COMPLETE: (date, pass, updateCount) => 
-        `Worker completed task: Date=${date}, Pass=${pass}, Updates=${updateCount}`,
-    WORKER_TASK_SKIP: (date, pass, reason) => 
-        `Worker skipped task: Date=${date}, Pass=${pass}, Reason=${reason}`
-};
-
-module.exports = {
-    StructuredLogger,
-    ProcessLogger,
-    LOG_LEVELS,
-    PROCESS_TYPES,
-    LOG_TEMPLATES,
-    generateProcessId
-};
+module.exports = { StructuredLogger, ProcessLogger, LOG_LEVELS, PROCESS_TYPES, generateProcessId };

package/package.json

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