bulltrackers-module 1.0.339 → 1.0.341

package/functions/computation-system/config/monitoring_config.js

@@ -0,0 +1,31 @@
+/**
+ * computation-system/config/monitoring_config.js
+ * Configuration for Google Cloud Monitoring, Logging, and Tracing.
+ */
+
+module.exports = {
+    // Toggle to easily disable all GCP telemetry without changing code
+    enabled: true,
+    
+    // Your Google Cloud Project ID
+    project: process.env.GOOGLE_CLOUD_PROJECT_ID || process.env.GCP_PROJECT || 'your-project-id',
+    
+    // Configuration for the "Eyeball" (Trace)
+    trace: {
+        enabled: true,
+        // Force sampling for these computations (can use '*' for all)
+        sampledTasks: ['*'] 
+    },
+
+    // Definitions for Custom Metrics
+    metrics: {
+        // The heartbeat metric replaces the Firestore 'active' check over time
+        heartbeat: 'custom.googleapis.com/computation/worker_heartbeat',
+        
+        // Tracks memory usage per worker/task
+        memory: 'custom.googleapis.com/computation/memory_usage',
+        
+        // Tracks duration of specific processing stages
+        duration: 'custom.googleapis.com/computation/stage_duration'
+    }
+};

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

@@ -3,6 +3,7 @@
  * PURPOSE: Sequential Cursor-Based Dispatcher.
  * UPDATED: Enforces Strict One-Shot Policy (Standard -> HighMem -> Dead Letter).
  * UPDATED: Prevents infinite loops by permanently ignoring deterministic failures.
+ * UPDATED: Generates Google Cloud Trace Context (traceId/spanId) for end-to-end monitoring.
  */
 
 const { getExpectedDateStrings, getEarliestDataDates, normalizeName, DEFINITIVE_EARLIEST_DATES } = require('../utils/utils.js');
@@ -11,6 +12,7 @@ const { PubSubUtils } = require('../../core/utils/pubsub_utils');
 const { fetchComputationStatus } = require('../persistence/StatusRepository');
 const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
 const crypto = require('crypto');
+const monConfig = require('../config/monitoring_config'); // [NEW]
 
 const OOM_THRESHOLD_MB = 1500;
 const BASE_SECONDS_PER_WEIGHT_UNIT = 3;
@@ -246,7 +248,6 @@ async function handleSweepDispatch(config, dependencies, computationManifest, re
     }
 
     // [CRITICAL] FILTER FOR SWEEP:
-    // Only dispatch if it hasn't failed High-Mem or Quality checks.
     const validTasks = [];
     for (const task of pending) {
         const name = normalizeName(task.name);
@@ -256,13 +257,13 @@ async function handleSweepDispatch(config, dependencies, computationManifest, re
             const data = doc.data();
             const stage = data.error?.stage;
             
-            // A. QUALITY CHECK: If it failed logic, DO NOT RETRY.
+            // A. QUALITY CHECK
             if (['QUALITY_CIRCUIT_BREAKER', 'SEMANTIC_GATE', 'SHARDING_LIMIT_EXCEEDED'].includes(stage)) {
                  logger.log('WARN', `[Sweep] 🛑 Skipping deterministic failure for ${name} (${stage}).`);
                  continue;
              }
              
-             // B. DEAD END CHECK: If it failed High-Mem already, DO NOT RETRY.
+             // B. DEAD END CHECK
              if (data.resourceTier === 'high-mem' && data.status === 'FAILED') {
                  logger.log('WARN', `[Sweep] 🛑 Skipping ${name} - Already failed on High-Mem.`);
                  continue;
@@ -276,19 +277,31 @@ async function handleSweepDispatch(config, dependencies, computationManifest, re
         return { dispatched: 0 };
     }
 
-    // 2. FORCE High Mem for remaining valid tasks
+    // 2. FORCE High Mem & INJECT TRACE
     const currentDispatchId = crypto.randomUUID();
     
-    const tasksPayload = validTasks.map(t => ({
-        ...t,
-        action: 'RUN_COMPUTATION_DATE',
-        computation: t.name,
-        date: date,
-        pass: passToRun,
-        dispatchId: currentDispatchId,
-        triggerReason: 'SWEEP_RECOVERY',
-        resources: 'high-mem' // FORCE
-    }));
+    const tasksPayload = validTasks.map(t => {
+        // [NEW] Generate Eyeball Trace
+        const traceId = crypto.randomBytes(16).toString('hex');
+        const spanId = crypto.randomBytes(8).toString('hex');
+
+        return {
+            ...t,
+            action: 'RUN_COMPUTATION_DATE',
+            computation: t.name,
+            date: date,
+            pass: passToRun,
+            dispatchId: currentDispatchId,
+            triggerReason: 'SWEEP_RECOVERY',
+            resources: 'high-mem', // FORCE
+            // [NEW] Attach the eyeball
+            traceContext: {
+                traceId: traceId,
+                spanId: spanId,
+                sampled: true
+            }
+        };
+    });
 
     logger.log('WARN', `[Sweep] 🧹 Forcing ${tasksPayload.length} tasks to HIGH-MEM for ${date}.`);
 
@@ -349,7 +362,7 @@ async function handleStandardDispatch(config, dependencies, computationManifest,
             checkRootDataAvailability(selectedDate, config, dependencies, DEFINITIVE_EARLIEST_DATES)
         ]);
 
-        if (availability && availability.status.hasPrices) {
+        if (availability && availability.status) { // Just check availability exists
             const report = analyzeDateExecution(selectedDate, calcsInThisPass, availability.status, dailyStatus, manifestMap, prevDailyStatus);
             let rawTasks = [...report.runnable, ...report.reRuns];
 
@@ -386,10 +399,28 @@ async function handleStandardDispatch(config, dependencies, computationManifest,
         date: selectedDate, pass: passToRun, dispatchedCount: selectedTasks.length, etaSeconds, dispatchId: currentDispatchId, details: taskDetails
     });
 
-    const mapToTaskPayload = (t) => ({
-        ...t, action: 'RUN_COMPUTATION_DATE', computation: t.name, date: selectedDate, pass: passToRun,
-        dispatchId: currentDispatchId, triggerReason: t.reason, resources: t.resources || 'standard'
-    });
+    const mapToTaskPayload = (t) => {
+        // [NEW] Generate Eyeball Trace
+        const traceId = crypto.randomBytes(16).toString('hex');
+        const spanId = crypto.randomBytes(8).toString('hex');
+
+        return {
+            ...t, 
+            action: 'RUN_COMPUTATION_DATE', 
+            computation: t.name, 
+            date: selectedDate, 
+            pass: passToRun,
+            dispatchId: currentDispatchId, 
+            triggerReason: t.reason, 
+            resources: t.resources || 'standard',
+            // [NEW] Attach the eyeball
+            traceContext: {
+                traceId: traceId,
+                spanId: spanId,
+                sampled: true
+            }
+        };
+    };
 
     const standardTasks = selectedTasks.filter(t => t.resources !== 'high-mem').map(mapToTaskPayload);
     const highMemTasks  = selectedTasks.filter(t => t.resources === 'high-mem').map(mapToTaskPayload);

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

@@ -1,10 +1,7 @@
 /**
  * FILENAME: computation-system/helpers/computation_worker.js
- * UPDATED: Implemented Strict Idempotency Gate (The "One-Shot" Policy).
- * BEHAVIOR: 
- * 1. Checks Ledger via Transaction before execution.
- * 2. If Status is COMPLETED or FAILED, immediately ACKs (returns) to stop Pub/Sub loops.
- * 3. Preserves Error 'stage' to ensure logic errors are not retried.
+ * UPDATED: Implements Google Cloud Monitoring Heartbeats.
+ * UPDATED: Implements Structured Logging with Trace Context.
  */
 
 const { executeDispatchTask } = require('../WorkflowOrchestrator.js');
@@ -13,6 +10,11 @@ const { StructuredLogger }    = require('../logger/logger');
 const { recordRunAttempt }    = require('../persistence/RunRecorder'); 
 const { normalizeName }       = require('../utils/utils');
 const os                      = require('os');
+const monitoring              = require('@google-cloud/monitoring'); // [NEW]
+const monConfig               = require('../config/monitoring_config'); // [NEW]
+
+// Initialize the Google Monitoring Client once
+const metricClient = new monitoring.MetricServiceClient();
 
 let calculationPackage;
 try { calculationPackage = require('aiden-shared-calculations-unified'); } catch (e) { throw e; }
@@ -20,21 +22,75 @@ const calculations = calculationPackage.calculations;
 
 const MAX_RETRIES = 3;
 
-function startMemoryHeartbeat(db, ledgerPath, intervalMs = 2000) {
+// [NEW] Helper to push metric to Google Cloud
+async function pushMetric(type, value, labels) {
+    if (!monConfig.enabled) return;
+    try {
+        const dataPoint = {
+            interval: { endTime: { seconds: Date.now() / 1000 } },
+            value: { int64Value: value }, // Assumes memory in MB
+        };
+
+        const timeSeriesData = {
+            name: metricClient.projectPath(monConfig.project),
+            timeSeries: [{
+                metric: {
+                    type: type,
+                    labels: labels,
+                },
+                resource: {
+                    type: 'global',
+                    labels: { project_id: monConfig.project },
+                },
+                points: [dataPoint],
+            }],
+        };
+
+        // Fire and forget (don't await to avoid blocking compute)
+        metricClient.createTimeSeries(timeSeriesData).catch(err => console.error('[Monitoring] Push failed', err.message));
+    } catch (e) { /* Ignore setup errors */ }
+}
+
+function startMemoryHeartbeat(db, ledgerPath, workerId, computationName, traceId, intervalMs = 5000) {
     let peakRss = 0;
-    const timer = setInterval(async () => {
+    
+    // Firestore Heartbeat (Legacy/State)
+    const firestoreTimer = setInterval(async () => {
         const rssMB = Math.round(process.memoryUsage().rss / 1024 / 1024);
         if (rssMB > peakRss) peakRss = rssMB;
-        await db.doc(ledgerPath).update({ 'telemetry.lastMemoryMB': rssMB, 'telemetry.lastHeartbeat': new Date() }).catch(() => {});
-    }, intervalMs);
-    timer.unref();
-    return { timer, getPeak: () => peakRss };
+        await db.doc(ledgerPath).update({ 
+            'telemetry.lastMemoryMB': rssMB, 
+            'telemetry.lastHeartbeat': new Date() 
+        }).catch(() => {});
+    }, 2000); // 2s for DB
+
+    // Google Monitoring Heartbeat (New/Out-of-Band)
+    const monitoringTimer = setInterval(async () => {
+        const rssMB = Math.round(process.memoryUsage().rss / 1024 / 1024);
+        
+        // Push Memory Metric
+        pushMetric(monConfig.metrics.memory, rssMB, {
+            worker_id: workerId,
+            computation: computationName,
+            // Including trace_id in metric labels allows strict correlation 
+            // BUT can cause high cardinality. Use with caution or only for debugging.
+            // Per user request, we include it to "attach eyeball".
+            trace_id: traceId || 'unknown' 
+        });
+
+    }, intervalMs); // 5s for API
+
+    firestoreTimer.unref();
+    monitoringTimer.unref();
+
+    return { 
+        stop: () => { clearInterval(firestoreTimer); clearInterval(monitoringTimer); },
+        getPeak: () => peakRss 
+    };
 }
 
 /**
  * STRICT IDEMPOTENCY GATE
- * Uses a transaction to verify this task hasn't already been processed.
- * Returns { shouldRun: boolean, leaseData: object }
  */
 async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId) {
     const docRef = db.doc(ledgerPath);
@@ -45,31 +101,17 @@ async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerI
             
             if (doc.exists) {
                 const data = doc.data();
-
-                // 1. TERMINAL STATE CHECK
-                // If the task is already finalized, we MUST NOT run it again.
-                // This stops the infinite loop if Pub/Sub redelivers a FAILED task.
                 if (['COMPLETED', 'FAILED', 'CRASH'].includes(data.status)) {
                     return { shouldRun: false, reason: `Task already in terminal state: ${data.status}` };
                 }
-
-                // 2. DUPLICATE DELIVERY CHECK
-                // If it's IN_PROGRESS with the SAME dispatchId, we are likely seeing a Pub/Sub redelivery 
-                // while the code is actually running. Ignore it.
                 if (data.status === 'IN_PROGRESS' && data.dispatchId === dispatchId) {
                     return { shouldRun: false, reason: 'Duplicate delivery: Task already IN_PROGRESS with same ID.' };
                 }
-
-                // 3. ZOMBIE CHECK (Optional safety, usually handled by Dispatcher)
-                // If it's IN_PROGRESS but clearly stale (older than 15 mins), we might steal it, 
-                // but generally we let the Dispatcher handle zombies. For now, we block collision.
                 if (data.status === 'IN_PROGRESS') {
                     return { shouldRun: false, reason: 'Collision: Task currently IN_PROGRESS by another worker.' };
                 }
             }
 
-            // 4. CLAIM LEASE
-            // If we get here, the task is either new (doesn't exist) or PENDING.
             const lease = {
                 status: 'IN_PROGRESS',
                 workerId: workerId,
@@ -81,18 +123,13 @@ async function checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerI
             return { shouldRun: true, leaseData: lease };
         });
     } catch (e) {
-        console.error(`[Idempotency] Transaction failed: ${e.message}`);
-        // If transaction fails (contention), assume we shouldn't run
         return { shouldRun: false, reason: `Transaction Error: ${e.message}` };
     }
 }
 
 async function handleComputationTask(message, config, dependencies) {
-    const logger = new StructuredLogger({ minLevel: config.minLevel || 'INFO', enableStructured: true, ...config });
-    const runDeps = { ...dependencies, logger };
-    const db = dependencies.db;
+    // 1. Parse Message
     let data;
-
     try {
         const raw = message.data?.message?.data || message.data || message.json;
         data = (typeof raw === 'string') ? JSON.parse(Buffer.from(raw, 'base64').toString()) : raw;
@@ -100,25 +137,43 @@ async function handleComputationTask(message, config, dependencies) {
 
     if (!data || data.action !== 'RUN_COMPUTATION_DATE') return;
     
-    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes, resources } = data;
+    const { date, pass, computation, previousCategory, triggerReason, dispatchId, dependencyResultHashes, resources, traceContext } = data;
     const resourceTier = resources || 'standard';
     const ledgerPath = `computation_audit_ledger/${date}/passes/${pass}/tasks/${computation}`;
-
     const workerId = process.env.K_REVISION || os.hostname();
 
+    // 2. Initialize Trace-Aware Logger (The "Eyeball")
+    // If traceContext is present (from dispatcher), we inject it into globalMetadata
+    // so ALL logs from this execution line up in Google Trace.
+    const globalMetadata = {};
+    if (traceContext && monConfig.enabled) {
+        globalMetadata['logging.googleapis.com/trace'] = `projects/${monConfig.project}/traces/${traceContext.traceId}`;
+        globalMetadata['logging.googleapis.com/spanId'] = traceContext.spanId;
+        globalMetadata['logging.googleapis.com/trace_sampled'] = traceContext.sampled;
+    }
+
+    const logger = new StructuredLogger({ 
+        minLevel: config.minLevel || 'INFO', 
+        enableStructured: true, 
+        globalMetadata, // [NEW] Inject Trace
+        ...config 
+    });
+    
+    const runDeps = { ...dependencies, logger };
+    const db = dependencies.db;
+
     // --- STEP 1: IDEMPOTENCY CHECK ---
     const gate = await checkIdempotencyAndClaimLease(db, ledgerPath, dispatchId, workerId);
-    
     if (!gate.shouldRun) {
-        // [CRITICAL] We return successfully (ACK) to remove the message from Pub/Sub.
-        // We do NOT throw an error, because that would cause a retry.
         logger.log('WARN', `[Worker] 🛑 Idempotency Gate: Skipping ${computation}. Reason: ${gate.reason}`);
         return; 
     }
 
     logger.log('INFO', `[Worker] 📥 Task: ${computation} (${date}) [Tier: ${resourceTier}] [ID: ${dispatchId}]`);
 
-    const heartbeat = startMemoryHeartbeat(db, ledgerPath);
+    // --- STEP 2: START DUAL HEARTBEATS ---
+    // Starts both Firestore writes (legacy) AND Google Metrics (new)
+    const heartbeats = startMemoryHeartbeat(db, ledgerPath, workerId, computation, traceContext?.traceId);
 
     try {
         const manifest = getManifest(config.activeProductLines || [], calculations, runDeps);
@@ -129,11 +184,10 @@ async function handleComputationTask(message, config, dependencies) {
             manifest, previousCategory, dependencyResultHashes
         );
 
-        clearInterval(heartbeat.timer);
+        heartbeats.stop();
         const failureReport = result?.updates?.failureReport || [];
         const successUpdates = result?.updates?.successUpdates || {};
 
-        // [CRITICAL] Propagate Error Stage from inner logic
         if (failureReport.length > 0) {
             const reportedError = failureReport[0].error;
             const errorObj = new Error(reportedError.message);
@@ -144,7 +198,7 @@ async function handleComputationTask(message, config, dependencies) {
         const calcUpdate = successUpdates[normalizeName(computation)] || {};
         const metrics = {
             durationMs:    Date.now() - startTime,
-            peakMemoryMB:  heartbeat.getPeak(),
+            peakMemoryMB:  heartbeats.getPeak(),
             io:            calcUpdate.metrics?.io,
             storage:       calcUpdate.metrics?.storage,
             execution:     calcUpdate.metrics?.execution,
@@ -153,34 +207,22 @@ async function handleComputationTask(message, config, dependencies) {
         };
 
         await db.doc(ledgerPath).update({ status: 'COMPLETED', completedAt: new Date() });
+        // Use the new recorder which also prints JSON for logs
         await recordRunAttempt(db, { date, computation, pass }, 'SUCCESS', null, metrics, triggerReason, resourceTier);
 
     } catch (err) { 
-        clearInterval(heartbeat.timer);
+        heartbeats.stop();
         
         const isDeterministic = ['SHARDING_LIMIT_EXCEEDED', 'QUALITY_CIRCUIT_BREAKER', 'SEMANTIC_GATE'].includes(err.stage);
         
-        // --- STEP 2: ERROR HANDLING ---
-        // If Logic Error OR Max Retries reached, mark FAILED and ACK.
         if (isDeterministic || (message.deliveryAttempt || 1) >= MAX_RETRIES) {
-            
-            const errorPayload = { 
-                message: err.message, 
-                stage: err.stage || 'FATAL' 
-            };
-
-            // This write ensures the Idempotency Gate blocks future retries
-            await db.doc(ledgerPath).set({ 
-                status: 'FAILED', 
-                error: errorPayload, 
-                failedAt: new Date() 
-            }, { merge: true });
+            const errorPayload = { message: err.message, stage: err.stage || 'FATAL' };
 
-            await recordRunAttempt(db, { date, computation, pass }, 'FAILURE', { message: err.message, stage: err.stage || 'FATAL' }, { peakMemoryMB: heartbeat.getPeak() }, triggerReason, resourceTier);
-            return; // ACK
+            await db.doc(ledgerPath).set({ status: 'FAILED', error: errorPayload, failedAt: new Date() }, { merge: true });
+            await recordRunAttempt(db, { date, computation, pass }, 'FAILURE', { message: err.message, stage: err.stage || 'FATAL' }, { peakMemoryMB: heartbeats.getPeak() }, triggerReason, resourceTier);
+            return;
         }
         
-        // Only throw (NACK) for transient system errors (Network, etc)
         throw err;
     }
 }

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

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Structured Logging System for Computation Engine
- * UPDATED: Added 'impossible' category handling to Date Analysis.
+ * UPDATED: Added support for Google Cloud Trace Context injection.
  */
 
 const crypto = require('crypto');
@@ -27,7 +27,8 @@ function generateProcessId(type, identifier, date = '') {
 function formatLogEntry(entry) {
     return JSON.stringify({
         timestamp: entry.timestamp,
-        level: entry.level,
+        level: entry.level, // Google uses 'severity', mapped below
+        severity: entry.severity, 
         processType: entry.processType,
         processId: entry.processId,
         computationName: entry.computationName,
@@ -37,7 +38,9 @@ function formatLogEntry(entry) {
         metadata: entry.metadata,
         stats: entry.stats,
         storage: entry.storage,
-        details: entry.details
+        details: entry.details,
+        // Spread the global Trace fields here
+        ...entry.globalMetadata
     });
 }
 
@@ -51,6 +54,9 @@ class StructuredLogger {
             ...config
         };
         this.activeProcesses = new Map();
+        
+        // [NEW] Store global metadata (like Trace IDs) for this logger instance
+        this.globalMetadata = config.globalMetadata || {}; 
     }
 
     startProcess(processType, computationName = null, date = null) {
@@ -98,6 +104,7 @@ class StructuredLogger {
             console.log(JSON.stringify({
                 timestamp: new Date().toISOString(),
                 level: 'INFO',
+                severity: 'INFO',
                 processType: PROCESS_TYPES.ANALYSIS,
                 date: dateStr,
                 message: `Date Analysis for ${dateStr}`,
@@ -109,7 +116,8 @@ class StructuredLogger {
                     failedDependency: failedDependency.length,
                     skipped: skipped.length
                 },
-                details: analysisReport
+                details: analysisReport,
+                ...this.globalMetadata
             }));
         }
 
@@ -202,9 +210,17 @@ class StructuredLogger {
             delete finalContext.stats; delete finalContext.storage;
         }
 
+        // Map Level to Google Severity
+        let severity = 'INFO';
+        if (numericLevel === LOG_LEVELS.WARN) severity = 'WARNING';
+        else if (numericLevel === LOG_LEVELS.ERROR) severity = 'ERROR';
+        else if (numericLevel === LOG_LEVELS.FATAL) severity = 'CRITICAL';
+        else if (numericLevel === LOG_LEVELS.DEBUG) severity = 'DEBUG';
+
         const entry = {
             timestamp: new Date().toISOString(),
             level: Object.keys(LOG_LEVELS).find(k => LOG_LEVELS[k] === numericLevel) || 'INFO',
+            severity: severity,
             processType,
             processId,
             computationName,
@@ -213,7 +229,8 @@ class StructuredLogger {
             context: typeof finalContext === 'string' ? { error: finalContext } : finalContext,
             metadata: finalMetadata,
             stats: finalStats,
-            storage: finalStorage
+            storage: finalStorage,
+            globalMetadata: this.globalMetadata // [NEW] Pass trace context
         };
 
         if (numericLevel >= LOG_LEVELS.ERROR && this.config.includeStackTrace && finalContext.stack) {
@@ -225,6 +242,7 @@ class StructuredLogger {
         }
 
         if (this.config.enableStructured) {
+            // [CRITICAL] This is what Google Cloud Logging picks up
             console.log(formatLogEntry(entry));
         }
     }

package/functions/computation-system/persistence/RunRecorder.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Utility for recording computation run attempts (The Audit Logger).
  * UPDATED: Stores 'trigger', 'execution' stats, 'cost' metrics, and 'forensics'.
+ * UPDATED: Emits Structured Logs for GCP Observability.
  */
 
 const { FieldValue } = require('../utils/utils'); 
@@ -49,18 +50,15 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
         durationMs:      detailedMetrics.durationMs || 0,
         status:          status,
         
-        // [NEW] Cost & Resource Analysis
-        resourceTier:    resourceTier, // 'standard' or 'high-mem'
+        resourceTier:    resourceTier,
         peakMemoryMB:    detailedMetrics.peakMemoryMB || 0,
         
-        // [NEW] IO Operations (for Cost Calc)
         firestoreOps: {
             reads:   detailedMetrics.io?.reads   || 0,
             writes:  detailedMetrics.io?.writes  || 0,
             deletes: detailedMetrics.io?.deletes || 0
         },
 
-        // [NEW] Code Linkage (Forensics)
         composition: detailedMetrics.composition || null,
 
         trigger: {
@@ -86,7 +84,7 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
         },
 
         anomalies: anomalies,
-        _schemaVersion: '2.3' // Version Bump for Monitoring
+        _schemaVersion: '2.3'
     };
 
     if (error) {
@@ -98,12 +96,29 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
         };
     }
 
-    // Aggregated Stats for Quick Dashboarding
+    // 1. [NEW] Emit Structured Log for GCP Observability
+    // This allows you to query "jsonPayload.event = 'AUDIT_COMPLETE'" in Cloud Logging
+    // independent of Firestore status.
+    console.log(JSON.stringify({
+        event: 'AUDIT_COMPLETE',
+        severity: status === 'SUCCESS' ? 'INFO' : 'ERROR',
+        computation: computation,
+        runId: runId,
+        status: status,
+        metrics: {
+            duration: runEntry.durationMs,
+            memory: runEntry.peakMemoryMB,
+            writes: runEntry.firestoreOps.writes
+        },
+        error: runEntry.error ? runEntry.error.message : null
+    }));
+
+    // 2. Existing Firestore Aggregation Logic
     const statsUpdate = {
         lastRunAt: now,
         lastRunStatus: status,
         totalRuns: FieldValue.increment(1),
-        totalCostAccumulated: FieldValue.increment(0) // Placeholder for future cost adder
+        totalCostAccumulated: FieldValue.increment(0)
     };
 
     if (status === 'SUCCESS') { statsUpdate.successCount = FieldValue.increment(1);

package/functions/computation-system/tools/BuildReporter.js

@@ -1,8 +1,8 @@
 /**
- * FILENAME: bulltrackers-module/functions/computation-system/tools/BuildReporter.js
- * UPGRADED: Offloads heavy logic to a dedicated Cloud Function via Pub/Sub.
- * FEATURES: Patch versioning, data-drift detection (window changes), and checkpointed writes.
- * FIX: Ensures ALL dates in the window are reported, even if analysis fails.
+ * FILENAME: computation-system/tools/BuildReporter.js
+ * PURPOSE: Generates the "Build Report" - a comprehensive audit of the computation system's state.
+ * UPDATED: Trigger logic now strictly depends on Package Version changes (Calculations OR Module).
+ * UPDATED: Added Algorithmic "Dynamic Warnings" for impossibility analysis.
  */
 
 const { analyzeDateExecution } = require('../WorkflowOrchestrator');
@@ -10,30 +10,50 @@ const { fetchComputationStatus, updateComputationStatus } = require('../persiste
 const { normalizeName, getExpectedDateStrings, DEFINITIVE_EARLIEST_DATES, getEarliestDataDates } = require('../utils/utils');
 const { checkRootDataAvailability } = require('../data/AvailabilityChecker');
 const SimRunner = require('../simulation/SimRunner');
-const SYSTEM_EPOCH = require('../system_epoch'); 
+const SYSTEM_EPOCH = require('../system_epoch');
+const REPORTER_EPOCH = require('../reporter_epoch');
 const pLimit = require('p-limit');
 const path = require('path');
 const crypto = require('crypto');
 
-// Load package info for versioning
-const packageJson = require(path.join(__dirname, '..', '..', '..', 'package.json'));
-const packageVersion = packageJson.version;
-
 const BUILD_RECORDS_COLLECTION = 'computation_build_records';
-const BUILD_METADATA_DOC = 'system_build_metadata';
 const SIMHASH_REGISTRY_COLLECTION = 'system_simhash_registry';
-const REPORTER_EPOCH = require('../reporter_epoch')
+
+/**
+ * Resolves version numbers for both the Infrastructure (Module) and the Logic (Calculations).
+ */
+function getPackageVersions() {
+    let moduleVersion = 'unknown';
+    let calcVersion = 'unknown';
+
+    try {
+        const modulepkg = require('../../../../bulltrackers-module/package.json');
+        moduleVersion = modulepkg.version;
+
+    } catch (e) { console.warn('[BuildReporter] Could not resolve Module version', e.message); }
+
+    try {
+        const calcpkg   = require('../../../../calculations/package.json')
+        calcVersion = calcpkg.version;
+        
+    } catch (e2) { console.warn('[BuildReporter] Could not resolve Calculations version', e2.message); }
+        
+
+    return { moduleVersion, calcVersion };
+}
 
 /**
  * Publishes a message to trigger the dedicated Build Reporter Cloud Function.
- * Replaces the old ensureBuildReport that ran locally on module load.
  */
 async function requestBuildReport(config, dependencies) {
     const { pubsubUtils, logger } = dependencies;
+    const { moduleVersion, calcVersion } = getPackageVersions();
+    
     try {
         await pubsubUtils.publish(config.buildReporterTopic, { 
             requestedAt: new Date().toISOString(),
-            packageVersion: packageVersion 
+            moduleVersion,
+            calcVersion
         });
         logger.log('INFO', `[BuildReporter] 🛰️ Trigger message sent to ${config.buildReporterTopic}`);
         return { success: true };
@@ -57,9 +77,6 @@ async function handleBuildReportTrigger(message, context, config, dependencies,
     }
 }
 
-/**
- * Replaces expensive file walking with System Epoch + Manifest Hash.
- */
 function getSystemFingerprint(manifest) {
     const sortedManifestHashes = manifest.map(c => c.hash).sort().join('|');
     return crypto.createHash('sha256')
@@ -67,20 +84,6 @@ function getSystemFingerprint(manifest) {
         .digest('hex');
 }
 
-/**
- * Increments the patch number for the current package version in Firestore.
- */
-async function getNextBuildId(db, version) {
-    const metaRef = db.collection(BUILD_RECORDS_COLLECTION).doc(BUILD_METADATA_DOC);
-    return await db.runTransaction(async (t) => {
-        const doc = await t.get(metaRef);
-        const data = doc.exists ? doc.data() : {};
-        const currentPatch = (data[version] || 0) + 1;
-        t.set(metaRef, { [version]: currentPatch }, { merge: true });
-        return `v${version}_p${currentPatch}`;
-    });
-}
-
 function isDateBeforeAvailability(dateStr, calcManifest) {
     const targetDate = new Date(dateStr + 'T00:00:00Z');
     const deps = calcManifest.rootDataDependencies || [];
@@ -169,63 +172,100 @@ async function verifyBehavioralStability(candidates, manifestMap, dailyStatus, l
 }
 
 /**
- * The main reporter logic. Handles drift detection, minor versioning, 
- * and checkpointed batch writes to Firestore.
+ * Algorithmic Analysis for Dynamic Warnings.
+ * Detects patterns in "Impossible" states (e.g., Weekends, Category-Wide).
+ */
+function generateDynamicWarnings(impossibleStats, categoryStats, totalDates) {
+    const warnings = [];
+
+    for (const [name, stats] of impossibleStats.entries()) {
+        const failureRate = stats.count / totalDates;
+        const categoryData = categoryStats.get(stats.category) || { total: 0, impossible: 0 };
+        const catTotal = Math.max(1, categoryData.total);
+        const catFailureRate = categoryData.impossible / catTotal;
+
+        // Skip negligible errors
+        if (failureRate < 0.05) continue; 
+
+        let type = 'INTERMITTENT_FAILURE';
+        let contextMsg = `Fails on ${stats.count}/${totalDates} dates.`;
+
+        // 1. Weekend Analysis
+        const isWeekendOnly = stats.dates.every(d => {
+            const day = new Date(d + 'T00:00:00Z').getUTCDay();
+            return day === 0 || day === 6; // Sunday or Saturday
+        });
+
+        if (isWeekendOnly && failureRate < 0.35) {
+            type = 'WEEKEND_GAP';
+            contextMsg = 'Computation consistently fails only on weekends (likely price/market data gaps).';
+        } else if (failureRate > 0.95) {
+            type = 'PERMANENT_FAILURE';
+            if (catFailureRate > 0.8) {
+                contextMsg = `Entire category '${stats.category}' is failing (${(catFailureRate*100).toFixed(0)}% fail rate). Systemic issue.`;
+            } else {
+                contextMsg = `Category '${stats.category}' is healthy, but this calculation is 100% impossible. Outlier.`;
+            }
+        }
+
+        warnings.push({
+            computation: name,
+            category: stats.category,
+            pass: stats.pass,
+            type: type,
+            failureRate: (failureRate * 100).toFixed(1) + '%',
+            message: contextMsg,
+            reasons: Array.from(stats.reasons).slice(0, 3) 
+        });
+    }
+
+    return warnings;
+}
+
+/**
+ * The main reporter logic.
  */
 async function generateBuildReport(config, dependencies, manifest) {
     const { db, logger } = dependencies;
-
-    // FIX: Populate the global date registry before using it
-    await getEarliestDataDates(config, dependencies);
+    const { moduleVersion, calcVersion } = getPackageVersions();
     
-    const currentFingerprint = getSystemFingerprint(manifest);
-    const latestBuildDoc = await db.collection(BUILD_RECORDS_COLLECTION).doc('latest').get();
-    const latest = latestBuildDoc.exists ? latestBuildDoc.data() : null;
-
-    // [DATA DRIFT DETECTION]
-    // Force a run if the definitive earliest data date has changed (e.g. new history backfilled)
-    const currentEarliestStr = DEFINITIVE_EARLIEST_DATES.absoluteEarliest?.toISOString() || 'NONE';
-    const lastEarliestStr = latest?.windowEarliest || 'NONE';
-    const windowChanged = currentEarliestStr !== lastEarliestStr;
-
-    const epochChanged = latest?.reporterEpoch !== REPORTER_EPOCH; 
-
-    // If fingerprints match AND the window is the same, we can truly skip.
-    if (latest && 
-        latest.systemFingerprint === currentFingerprint && 
-        !windowChanged && 
-        !epochChanged) { 
-        logger.log('INFO', `[BuildReporter] ⚡ System fingerprint, window, and reporter epoch stable. Skipping report.`);
-        return { success: true, status: 'SKIPPED_IDENTICAL' };
+    // 1. Version-Based Trigger Check
+    // We create a composite ID for this exact code state
+    const buildId = `build_mod-${moduleVersion}_calc-${calcVersion}_${REPORTER_EPOCH}`;
+    
+    const existingDoc = await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).get();
+    if (existingDoc.exists) {
+        const data = existingDoc.data();
+        if (data.status === 'COMPLETED') {
+            logger.log('INFO', `[BuildReporter] ⚡ Report already exists for ${buildId}. Skipping execution.`);
+            return { success: true, status: 'SKIPPED_EXISTING', buildId };
+        }
     }
 
-    // Determine primary reason for logging
-    let reason = 'Code Change';
-    if (epochChanged) reason = 'Master Epoch Override'; 
-    else if (windowChanged) reason = 'Data Window Drift';
+    logger.log('INFO', `[BuildReporter] 🚀 Generating new report for ${buildId}.`);
 
-    // Increment patch version
-    const buildId = await getNextBuildId(db, packageVersion);
-    logger.log('INFO', `[BuildReporter] 🚀 Change Detected. Generating Build ${buildId}. Reason: ${reason}`);
-
-    const today = new Date();
+    // 2. Initialize Data
+    await getEarliestDataDates(config, dependencies); // Ensure dates are loaded
+    const currentFingerprint = getSystemFingerprint(manifest);
     const { absoluteEarliest } = DEFINITIVE_EARLIEST_DATES;
     
-    // Dynamic Window calculation
+    // Dynamic Window
+    const today = new Date();
     let dynamicDaysBack = 90; 
     if (absoluteEarliest) {
         const diffTime = Math.abs(today - absoluteEarliest);
         dynamicDaysBack = Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 2; 
     }
-
     const startDate = new Date();
     startDate.setDate(today.getDate() - dynamicDaysBack);
-    
     const datesToCheck = getExpectedDateStrings(startDate, today);
+
+    // 3. Stats Accumulators
     const manifestMap  = new Map(manifest.map(c => [normalizeName(c.name), c]));
     const simHashCache = new Map();
-
     const reverseGraph = new Map();
+    
+    // Graph for Blast Radius
     manifest.forEach(c => {
         const parentName = normalizeName(c.name);
         if (c.dependencies) {
@@ -237,30 +277,39 @@ async function generateBuildReport(config, dependencies, manifest) {
         }
     });
 
+    // Global Accumulators for Report
+    let totalRun = 0, totalReRun = 0, totalStable = 0, totalErrors = 0;
+    const globalMismatchStats = new Map(); // { stored: 0, mismatch: 0 }
+    const impossibleAnalysis  = new Map(); // { count: 0, dates: [], reasons: Set, category, pass }
+    const categoryStats       = new Map(); // { total: 0, impossible: 0 }
+    const runnablePerDate     = {};
+    const impossiblePerDate   = {};
+
     const reportHeader = { 
         buildId, 
-        packageVersion, 
-        systemFingerprint: currentFingerprint, 
-        reporterEpoch: REPORTER_EPOCH,
-        windowEarliest: currentEarliestStr,
+        sharded: true,
         generatedAt: new Date().toISOString(), 
+        calculationPackageVersion: calcVersion,
+        bulltrackersModulePackageVersion: moduleVersion,
+        reporterEpoch: REPORTER_EPOCH,
         status: 'IN_PROGRESS',
-        summary: {}, 
-        _sharded: true 
+        systemFingerprint: currentFingerprint,
+        earliestWindow: absoluteEarliest ? absoluteEarliest.toISOString().slice(0, 10) : 'UNKNOWN',
+        scanRange: `${datesToCheck[0]} to ${datesToCheck[datesToCheck.length-1]}`,
+        summary: {} 
     };
 
-    // Initialize the build record
     await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).set(reportHeader);
 
-    let totalRun = 0, totalReRun = 0, totalStable = 0, totalErrors = 0;
-    const limit = pLimit(10); // Concurrency for fetching statuses
-
-    // Process dates in chunks of 5 for checkpointed writing
+    // 4. Execution Loop
+    const limit = pLimit(10);
+    
     for (let i = 0; i < datesToCheck.length; i += 5) {
         const dateBatch = datesToCheck.slice(i, i + 5);
         
         const results = await Promise.all(dateBatch.map(dateStr => limit(async () => {
             try {
+                // Fetch State
                 const fetchPromises = [
                     fetchComputationStatus(dateStr, config, dependencies),
                     checkRootDataAvailability(dateStr, config, dependencies, DEFINITIVE_EARLIEST_DATES)
@@ -280,31 +329,73 @@ async function generateBuildReport(config, dependencies, manifest) {
                 const prevDailyStatus = (prevDateStr && prevRes) ? prevRes : (prevDateStr ? {} : null);
                 const rootDataStatus  = availability ? availability.status : { hasPortfolio: false, hasHistory: false };
 
+                // Analyze
                 const analysis = analyzeDateExecution(dateStr, manifest, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
                 const dateSummary = {
-                    run: [], rerun: [], stable: [], blocked: [], impossible: [], uptodate: [],
-                    meta: { totalIncluded: 0, totalExpected: 0, match: false }
+                    run: [], rerun: [], stable: [], blocked: [], impossible: [], uptodate: []
                 };
 
-                const expectedCount = manifest.filter(c => !isDateBeforeAvailability(dateStr, c)).length;
-                dateSummary.meta.totalExpected = expectedCount;
-
-                const pushIfValid = (targetArray, item, extraReason = null) => {
+                // --- Metric Aggregation Logic ---
+                const processItem = (targetArray, item, extraReason) => {
                     const calcManifest = manifestMap.get(item.name);
-                    if (calcManifest && isDateBeforeAvailability(dateStr, calcManifest)) return;
+                    if (calcManifest && isDateBeforeAvailability(dateStr, calcManifest)) return; // Skip invalid dates
+                    
                     const entry = { name: item.name, reason: item.reason || extraReason, pass: calcManifest?.pass || '?' };
-                    if (targetArray === dateSummary.rerun) entry.impact = calculateBlastRadius(item.name, reverseGraph);
+                    
+                    // Stats for Mismatch Rate
+                    if (!globalMismatchStats.has(item.name)) globalMismatchStats.set(item.name, { stored: 0, mismatch: 0 });
+                    const stats = globalMismatchStats.get(item.name);
+                    
+                    // "Stored" implies we have a result or are about to run one. 
+                    // We count Stable + Rerun as "Stored History comparisons"
+                    // Runnable is "New", not "Stored".
+                    if (targetArray === dateSummary.rerun) {
+                         stats.stored++; 
+                         stats.mismatch++;
+                         entry.impact = calculateBlastRadius(item.name, reverseGraph);
+                    } else if (targetArray === dateSummary.stable) {
+                         stats.stored++;
+                    }
+
                     targetArray.push(entry);
                 };
 
-                analysis.runnable.forEach(item => pushIfValid(dateSummary.run, item, "New Calculation"));
+                // Track Impossible Stats
+                analysis.impossible.forEach(item => {
+                    const m = manifestMap.get(item.name);
+                    if (!m) return;
+                    if (!impossibleAnalysis.has(item.name)) {
+                        impossibleAnalysis.set(item.name, { 
+                            count: 0, dates: [], reasons: new Set(), category: m.category, pass: m.pass 
+                        });
+                    }
+                    const imp = impossibleAnalysis.get(item.name);
+                    imp.count++;
+                    imp.dates.push(dateStr);
+                    imp.reasons.add(item.reason);
+                });
+
+                // Track Category Stats (Total vs Impossible)
+                const allEvaluated = [...analysis.runnable, ...analysis.reRuns, ...analysis.skipped, ...analysis.impossible]; // Stable often in skipped
+                allEvaluated.forEach(item => {
+                    const m = manifestMap.get(item.name);
+                    if (!m) return;
+                    if (!categoryStats.has(m.category)) categoryStats.set(m.category, { total: 0, impossible: 0 });
+                    const cat = categoryStats.get(m.category);
+                    cat.total++;
+                    if (analysis.impossible.find(x => x.name === item.name)) cat.impossible++;
+                });
+
+                analysis.runnable.forEach(item => processItem(dateSummary.run, item, "New Calculation"));
 
+                // Handle Re-Runs (SimHash Verification)
                 if (analysis.reRuns.length > 0) {
                     const { trueReRuns, stableUpdates } = await verifyBehavioralStability(analysis.reRuns, manifestMap, dailyStatus, logger, simHashCache, db);
-                    trueReRuns.forEach(item => pushIfValid(dateSummary.rerun, item, "Logic Changed"));
-                    stableUpdates.forEach(item => pushIfValid(dateSummary.stable, item, "Logic Stable"));
+                    trueReRuns.forEach(item => processItem(dateSummary.rerun, item, "Logic Changed"));
+                    stableUpdates.forEach(item => processItem(dateSummary.stable, item, "Logic Stable"));
 
+                    // Auto-Heal Status if Stable
                     if (stableUpdates.length > 0) {
                         const updatesPayload = {};
                         for (const stable of stableUpdates) {
@@ -324,63 +415,84 @@ async function generateBuildReport(config, dependencies, manifest) {
                     }
                 }
 
-                analysis.blocked.forEach(item => pushIfValid(dateSummary.blocked, item));
-                analysis.failedDependency.forEach(item => pushIfValid(dateSummary.blocked, item, "Dependency Missing"));
-                analysis.impossible.forEach(item => pushIfValid(dateSummary.impossible, item));
-                analysis.skipped.forEach(item => pushIfValid(dateSummary.uptodate, item, "Up To Date"));
-
-                const includedCount = dateSummary.run.length + dateSummary.rerun.length + dateSummary.stable.length +
-                                      dateSummary.blocked.length + dateSummary.impossible.length + dateSummary.uptodate.length;
-                dateSummary.meta.totalIncluded = includedCount;
-                dateSummary.meta.match = (includedCount === expectedCount);
+                // Add skipped items to Stable count for metrics
+                analysis.skipped.forEach(item => processItem(dateSummary.stable, item, "Up To Date"));
+                
+                analysis.blocked.forEach(item => processItem(dateSummary.blocked, item));
+                analysis.failedDependency.forEach(item => processItem(dateSummary.blocked, item, "Dependency Missing"));
+                analysis.impossible.forEach(item => processItem(dateSummary.impossible, item));
 
-                // Write detailed date record
-                await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).collection('details').doc(dateStr).set(dateSummary);
+                // Per-Date Metrics
+                const runnableCount = dateSummary.run.length + dateSummary.rerun.length;
+                const impossibleCount = dateSummary.impossible.length;
+                
+                return { 
+                    date: dateStr,
+                    run: dateSummary.run.length, 
+                    rerun: dateSummary.rerun.length, 
+                    stable: dateSummary.stable.length,
+                    runnableCount,
+                    impossibleCount,
+                    error: false,
+                    summaryPayload: dateSummary
+                };
 
-                return { run: dateSummary.run.length, rerun: dateSummary.rerun.length, stable: dateSummary.stable.length, error: false };
             } catch (err) {
                 logger.log('ERROR', `[BuildReporter] Analysis failed for ${dateStr}: ${err.message}`);
-                
-                // [FIX] Write error record so the date appears in the report
-                await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).collection('details').doc(dateStr).set({
-                    error: err.message,
-                    status: 'ANALYSIS_FAILED',
-                    meta: { totalIncluded: 0, totalExpected: 0, match: false }
-                }).catch(e => logger.log('ERROR', `Failed to write error record for ${dateStr}: ${e.message}`));
-                
                 return { run: 0, rerun: 0, stable: 0, error: true };
             }
         })));
 
-        // Accumulate stats and write a progress checkpoint
-        results.forEach(res => { 
-            if (res.error) totalErrors++;
-            else {
+        // Accumulate Batch Results
+        for (const res of results) {
+            if (res.error) {
+                totalErrors++;
+            } else {
                 totalRun += res.run; 
                 totalReRun += res.rerun; 
-                totalStable += res.stable; 
+                totalStable += res.stable;
+                runnablePerDate[res.date] = res.runnableCount;
+                impossiblePerDate[res.date] = res.impossibleCount;
+                
+                // Write detailed record
+                await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).collection('details').doc(res.date).set(res.summaryPayload);
             }
-        });
-        
+        }
+
         await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).update({ 
             checkpoint: `Processed ${Math.min(i + dateBatch.length, datesToCheck.length)}/${datesToCheck.length} dates` 
         });
     }
 
+    // 5. Final Synthesis
+    const hashMismatchMetrics = {};
+    for (const [name, stats] of globalMismatchStats) {
+        if (stats.stored > 0) {
+            hashMismatchMetrics[name] = `${stats.mismatch}/${stats.stored}`;
+        }
+    }
+
+    const dynamicWarnings = generateDynamicWarnings(impossibleAnalysis, categoryStats, datesToCheck.length);
+
     reportHeader.status = 'COMPLETED';
     reportHeader.summary = { 
         totalReRuns: totalReRun, 
         totalNew: totalRun, 
         totalStable: totalStable, 
         totalErrors: totalErrors,
-        scanRange: `${datesToCheck[0]} to ${datesToCheck[datesToCheck.length-1]}` 
+        
+        // Expanded Metrics
+        runnablePerDate,
+        impossiblePerDate,
+        hashMismatches: hashMismatchMetrics,
+        dynamicWarnings: dynamicWarnings
     };
 
-    // Finalize build record and update the 'latest' pointer
+    // Save
     await db.collection(BUILD_RECORDS_COLLECTION).doc(buildId).set(reportHeader);
     await db.collection(BUILD_RECORDS_COLLECTION).doc('latest').set({ ...reportHeader, note: "Latest completed build report." });
     
-    logger.log('SUCCESS', `[BuildReporter] Build ${buildId} completed. Re-runs: ${totalReRun}, Stable: ${totalStable}, New: ${totalRun}, Errors: ${totalErrors}.`);
+    logger.log('SUCCESS', `[BuildReporter] Build ${buildId} completed. Warnings: ${dynamicWarnings.length}`);
     
     return { success: true, buildId, summary: reportHeader.summary };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.339",
+  "version": "1.0.341",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [
@@ -31,7 +31,7 @@
   "dependencies": {
     "@google-cloud/firestore": "^7.11.3",
     "@google-cloud/pubsub": "latest",
-    "aiden-shared-calculations-unified": "^1.0.81",
+    "aiden-shared-calculations-unified": "^1.0.110",
     "cors": "^2.8.5",
     "dotenv": "latest",
     "express": "^4.19.2",
@@ -40,7 +40,8 @@
     "node-graphviz": "^0.1.1",
     "p-limit": "^3.1.0",
     "require-all": "^3.0.0",
-    "sharedsetup": "latest"
+    "sharedsetup": "latest",
+    "@google-cloud/monitoring": "latest"
   },
   "devDependencies": {
     "bulltracker-deployer": "file:../bulltracker-deployer"