bulltrackers-module 1.0.776 → 1.0.778

package/functions/computation-system-v2/handlers/scheduler.js

@@ -1,8 +1,9 @@
 /**
- * @fileoverview Scheduler V3.2: Smart Reconciliation & Tombstone Aware
+ * @fileoverview Scheduler V3.4: Enhanced Logging for Verification
  * * * 1. Reconcile: Checks ENTIRE graph for stale hashes, triggers ROOTS if needed.
  * * 2. Purge: Actively removes tasks that don't match the current deployment hash.
  * * 3. Watchdog: Recovers "Zombie" tasks (running but stuck).
+ * * 4. Logging: Detailed output for Tombstoned/Existing tasks to verify ETA logic.
  */
 
 const { CloudTasksClient } = require('@google-cloud/tasks');
@@ -17,8 +18,8 @@ const config = require('../config/bulltrackers.config');
 
 // Config
 const CLOUD_TASKS_CONCURRENCY = 20;
-const PLANNING_LOOKBACK_DAYS = 7;    // Look back to ensure recent history is correct
-const PLANNING_LOOKAHEAD_HOURS = 24; // Schedule future tasks
+const PLANNING_LOOKBACK_DAYS = 7;
+const PLANNING_LOOKAHEAD_HOURS = 24;
 const ZOMBIE_THRESHOLD_MINUTES = 15;
 
 // Cache singleton instances
@@ -44,7 +45,6 @@ async function initialize() {
 
 /**
  * ENTRY POINT 1: The Planner
- * Trigger: Cloud Scheduler -> "0 * * * *" (Hourly)
  */
 async function planComputations(req, res) {
     try {
@@ -61,8 +61,6 @@ async function planComputations(req, res) {
 
         console.log(`[Planner] Reconciling window: ${windowStart.toISOString()} to ${windowEnd.toISOString()}`);
 
-        // Helper to find Roots for any given computation (Pass 1..N)
-        // If a deep node (Pass 3) is stale, we must run its Pass 1 ancestor to regenerate the data.
         const manifestMap = new Map(manifest.map(m => [m.name, m]));
         const getRoots = (entry, visited = new Set()) => {
             if (visited.has(entry.name)) return [];
@@ -74,7 +72,7 @@ async function planComputations(req, res) {
                 .flatMap(p => getRoots(p, visited));
         };
 
-        const tasksToSchedule = new Map(); // Use Map to deduplicate by Task Name
+        const tasksToSchedule = new Map();
         const stats = { checked: 0, scheduled: 0, mismatched: 0, missing: 0 };
 
         const targetDates = [];
@@ -89,9 +87,7 @@ async function planComputations(req, res) {
             const dateStr = dateObj.toISOString().split('T')[0];
             const dailyStatus = await stateRepository.getDailyStatus(dateStr);
 
-            // Iterate ALL computations (not just Pass 1) to find stale nodes
             for (const entry of manifest) {
-                // If this specific entry is not scheduled for today, skip it
                 if (!shouldRunOnDate(entry.schedule, dateObj)) continue;
 
                 stats.checked++;
@@ -107,22 +103,22 @@ async function planComputations(req, res) {
                 }
 
                 if (reason) {
-                    // If entry is stale, we must schedule its ROOT(s) to trigger the chain
                     const roots = getRoots(entry);
                     
                     roots.forEach(root => {
-                        // Unique Task Key: RootName + Date + Hash
-                        // Including Hash in key ensures we don't dedupe against a DIFFERENT version
                         const taskKey = `root-${toKebab(root.originalName)}-${dateStr}-${root.hash}`;
                         
                         if (!tasksToSchedule.has(taskKey)) {
+                            // Calculate proper ETA (Next valid window)
+                            const runAt = getNextRunWindow(root.schedule, dateObj);
+
                             tasksToSchedule.set(taskKey, {
                                 computation: root.originalName,
                                 targetDate: dateStr,
-                                runAtSeconds: getRunTimeSeconds(root.schedule, dateObj),
+                                runAtSeconds: runAt,
                                 configHash: root.hash,
                                 queuePath: getQueuePath(),
-                                reason: `TRIGGERED_BY_${entry.name}_${reason}` // Track what triggered this root
+                                reason: `TRIGGERED_BY_${entry.name}_${reason}`
                             });
                         }
                     });
@@ -164,7 +160,6 @@ async function planComputations(req, res) {
 
 /**
  * ENTRY POINT 2: The Watchdog
- * Trigger: Cloud Scheduler -> "*\/15 * * * *" (Every 15 mins)
  */
 async function runWatchdog(req, res) {
     try {
@@ -204,75 +199,48 @@ async function runWatchdog(req, res) {
 
 async function cleanupOrphanedTasks() {
     const parent = getQueuePath();
-    
-    // Create a map of { kebabName: activeHash } for O(1) lookups
-    const activeComputations = new Map(
-        manifest.map(m => [toKebab(m.originalName), m.hash])
-    );
-
+    const activeComputations = new Map(manifest.map(m => [toKebab(m.originalName), m.hash]));
     const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
     let deletedCount = 0;
 
     try {
         const tasksToDelete = [];
-
-        // Increase pageSize to 1000 to minimize pagination calls/warnings
-        for await (const task of tasksClient.listTasksAsync({ 
-            parent, 
-            responseView: 'BASIC',
-            pageSize: 1000 
-        })) {
+        for await (const task of tasksClient.listTasksAsync({ parent, responseView: 'BASIC', pageSize: 1000 })) {
             const taskNameFull = task.name;
             const taskNameShort = taskNameFull.split('/').pop(); 
 
-            // 1. Handle ROOT Tasks: root-{kebabName}-{date}-{hash}
+            // 1. Root Tasks
             const rootMatch = taskNameShort.match(/^root-(.+)-\d{4}-\d{2}-\d{2}-(.+)$/);
-
             if (rootMatch) {
                 const [_, kebabName, taskHash] = rootMatch;
                 const activeHash = activeComputations.get(kebabName);
-
-                // DELETE IF:
-                // A) Computation removed from manifest (!activeHash)
-                // B) Hash mismatch (Old deployment/Stale) (activeHash !== taskHash)
-                if (!activeHash || activeHash !== taskHash) {
-                    tasksToDelete.push(taskNameFull);
-                }
+                if (!activeHash || activeHash !== taskHash) tasksToDelete.push(taskNameFull);
                 continue;
             }
 
-            // 2. Handle RECOVERY Tasks: recovery-{kebabName}-{date}-{timestamp}
+            // 2. Recovery Tasks
             const recoveryMatch = taskNameShort.match(/^recovery-(.+)-\d{4}-\d{2}-\d{2}-/);
-            
             if (recoveryMatch) {
                 const [_, kebabName] = recoveryMatch;
-                if (!activeComputations.has(kebabName)) {
-                    tasksToDelete.push(taskNameFull);
-                }
+                if (!activeComputations.has(kebabName)) tasksToDelete.push(taskNameFull);
             }
         }
 
         if (tasksToDelete.length === 0) return 0;
-
         console.log(`[Planner] 🗑️ Found ${tasksToDelete.length} stale/orphaned tasks. Deleting...`);
 
-        // 3. Delete in parallel
         await Promise.all(tasksToDelete.map(name => limit(async () => {
             try {
                 await tasksClient.deleteTask({ name });
                 deletedCount++;
             } catch (e) {
-                // Ignore "NOT_FOUND" errors in case of race conditions
-                if (e.code !== 5) { 
-                    console.warn(`[Planner] Failed to delete ${name}: ${e.message}`);
-                }
+                if (e.code !== 5) console.warn(`[Planner] Failed to delete ${name}: ${e.message}`);
             }
         })));
 
     } catch (e) {
         console.error(`[Planner] GC Error: ${e.message}`);
     }
-
     return deletedCount;
 }
 
@@ -286,10 +254,21 @@ function shouldRunOnDate(schedule, dateObj) {
     return true;
 }
 
-function getRunTimeSeconds(schedule, dateObj) {
+function getNextRunWindow(schedule, targetDateObj) {
     const [h, m] = (schedule.time || '02:00').split(':').map(Number);
-    const runTime = new Date(dateObj);
+    let runTime = new Date(targetDateObj);
     runTime.setUTCHours(h, m, 0, 0);
+
+    const now = Date.now();
+    // If idealized time is in the past, shift to NEXT available window relative to NOW
+    if (runTime.getTime() < now) {
+        const nextWindow = new Date();
+        nextWindow.setUTCHours(h, m, 0, 0);
+        if (nextWindow.getTime() <= now) {
+            nextWindow.setUTCDate(nextWindow.getUTCDate() + 1);
+        }
+        return nextWindow.getTime() / 1000;
+    }
     return runTime.getTime() / 1000;
 }
 
@@ -340,10 +319,13 @@ async function dispatchTasks(tasks) {
             
         } catch (e) {
             // ALREADY_EXISTS (6) or CONFLICT (409)
-            // This happens if we try to recreate a task that was recently deleted (Tombstone)
-            // or if it genuinely already exists.
             if (e.code === 6 || e.code === 409) {
-                console.warn(`[Planner] Task skipped (Already Exists/Tombstone): ${t.computation} @ ${t.targetDate}`);
+                // ENHANCED LOGGING:
+                const eta = t.runAtSeconds 
+                    ? new Date(t.runAtSeconds * 1000).toISOString() 
+                    : 'Immediate';
+                
+                console.warn(`[Planner] ⚠️ Task collision (Tombstone/Exists): ${t.computation} | Target: ${t.targetDate} | Planned ETA: ${eta} | Hash: ${t.configHash}`);
                 return { status: 'exists' };
             }
             

package/package.json

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