nvent 0.5.3 → 0.5.5

package/dist/runtime/events/utils/stallDetector.js

@@ -1,24 +1,19 @@
-import { useNventLogger, useStreamTopics, $useAnalyzedFlows, useScheduler } from "#imports";
-const DEFAULT_STALL_TIMEOUT = 30 * 60 * 1e3;
-const DEFAULT_CHECK_INTERVAL = 15 * 60 * 1e3;
+import { useNventLogger, useStreamTopics, $useAnalyzedFlows } from "#imports";
 export class FlowStallDetector {
   store;
   config;
   logger = useNventLogger("stall-detector");
-  schedulerJobId;
   started = false;
   constructor(store, config = {}) {
     this.store = store;
     this.config = {
-      stallTimeout: config.stallTimeout ?? DEFAULT_STALL_TIMEOUT,
-      checkInterval: config.checkInterval ?? DEFAULT_CHECK_INTERVAL,
-      enablePeriodicCheck: config.enablePeriodicCheck ?? true
+      enabled: config.enabled ?? true
     };
   }
   /**
-   * Start the periodic stall detector
-   * Should be called once per instance after adapters are initialized
+   * Start the stall detector
    * Runs startup recovery to clean up flows from previous server instances
+   * Note: Periodic checking removed - now uses per-flow scheduler jobs
    */
   async start() {
     if (this.started) {
@@ -27,108 +22,14 @@ export class FlowStallDetector {
     }
     this.started = true;
     await this.runStartupRecovery();
-    this.logger.info(`Stall detector started - periodicCheck: ${this.config.enablePeriodicCheck}, stallTimeout: ${this.config.stallTimeout / 1e3}s, checkInterval: ${this.config.checkInterval / 1e3}s`);
+    this.logger.info("Stall detector started - using per-flow scheduler jobs for stall timeouts");
   }
   /**
-   * Get the configuration for scheduling
-   * Returns config needed by flowWiring to register the scheduler job
-   */
-  getScheduleConfig() {
-    return {
-      enabled: this.config.enablePeriodicCheck,
-      interval: this.config.checkInterval,
-      stallTimeout: this.config.stallTimeout
-    };
-  }
-  /**
-   * Set the scheduler job ID (called from flowWiring after scheduling)
-   */
-  setSchedulerJobId(jobId) {
-    this.schedulerJobId = jobId;
-  }
-  /**
-   * Stop the periodic stall detector
+   * Stop the stall detector
    */
   async stop() {
-    if (this.schedulerJobId) {
-      try {
-        const scheduler = useScheduler();
-        await scheduler.unschedule(this.schedulerJobId);
-        this.schedulerJobId = void 0;
-        this.logger.info("Stopped periodic stall detector");
-      } catch (error) {
-        this.logger.error(`Failed to stop stall detector: ${error.message}`);
-      }
-    }
     this.started = false;
-  }
-  /**
-   * Get stall timeout for a specific flow
-   * Uses flow-specific timeout from analyzed metadata, falls back to global config
-   */
-  async getFlowStallTimeout(flowName) {
-    try {
-      const analyzedFlows = $useAnalyzedFlows();
-      const flowMeta = analyzedFlows.find((f) => f.id === flowName);
-      if (flowMeta?.stallTimeout) {
-        this.logger.debug(`Using flow-specific stall timeout for '${flowName}': ${flowMeta.stallTimeout / 1e3}s`);
-        return flowMeta.stallTimeout;
-      }
-    } catch (error) {
-      this.logger.warn(`Failed to get flow-specific stall timeout for '${flowName}': ${error.message}`);
-    }
-    return this.config.stallTimeout;
-  }
-  /**
-   * Update activity timestamp for a flow
-   * Should be called on every step event (started, completed, failed, retry)
-   */
-  async updateActivity(flowName, runId) {
-    const { StoreSubjects } = useStreamTopics();
-    const indexKey = StoreSubjects.flowRunIndex(flowName);
-    try {
-      if (!this.store.index.update) {
-        this.logger.warn("Store does not support indexUpdate, cannot update activity");
-        return;
-      }
-      await this.store.index.update(indexKey, runId, {
-        lastActivityAt: Date.now()
-      });
-    } catch (error) {
-      this.logger.warn(`Failed to update flow activity for '${flowName}' runId '${runId}': ${error.message}`);
-    }
-  }
-  /**
-   * Check if a specific flow is stalled (lazy detection)
-   * Returns true if the flow should be marked as stalled
-   * v0.5: Await-aware - uses flow-specific timeout and skips awaiting flows
-   */
-  async isStalled(flowName, runId) {
-    const { StoreSubjects } = useStreamTopics();
-    const indexKey = StoreSubjects.flowRunIndex(flowName);
-    try {
-      if (!this.store.index.get) return false;
-      const flowEntry = await this.store.index.get(indexKey, runId);
-      if (!flowEntry?.metadata) return false;
-      if (flowEntry.metadata.status !== "running") return false;
-      const awaitingSteps = flowEntry.metadata.awaitingSteps || {};
-      const hasActiveAwaits = Object.keys(awaitingSteps).length > 0;
-      if (hasActiveAwaits) {
-        this.logger.debug(`Flow '${flowName}' runId '${runId}' has active awaits [${Object.keys(awaitingSteps).join(", ")}], skipping stall check`);
-        return false;
-      }
-      const stallTimeout = await this.getFlowStallTimeout(flowName);
-      const lastActivity = flowEntry.metadata.lastActivityAt || flowEntry.metadata.startedAt || 0;
-      const timeSinceActivity = Date.now() - lastActivity;
-      if (timeSinceActivity > stallTimeout) {
-        this.logger.info(`Flow detected as stalled (lazy check) - '${flowName}' runId '${runId}': ${Math.round(timeSinceActivity / 1e3)}s since activity (timeout: ${stallTimeout / 1e3}s)`);
-        return true;
-      }
-      return false;
-    } catch (error) {
-      this.logger.warn(`Failed to check if flow is stalled for '${flowName}' runId '${runId}': ${error.message}`);
-      return false;
-    }
+    this.logger.info("Stall detector stopped");
   }
   /**
    * Mark a flow as stalled
@@ -171,72 +72,6 @@ export class FlowStallDetector {
       this.logger.error(`Failed to mark flow as stalled for '${flowName}' runId '${runId}': ${error.message}`);
     }
   }
-  /**
-   * Check all running flows and mark stalled ones
-   * This is called by the periodic background job
-   *
-   * Note: This method requires knowledge of which flows exist.
-   * For now, we'll need to pass flow names to check, or iterate known flows from registry.
-   */
-  async checkFlowsForStalls(flowNames) {
-    this.logger.info(`Running periodic stall check for ${flowNames.length} flows`);
-    try {
-      if (!this.store.index.get || !this.store.index.read) {
-        this.logger.warn("Store does not support required index operations");
-        return;
-      }
-      const { StoreSubjects } = useStreamTopics();
-      let checkedCount = 0;
-      let stalledCount = 0;
-      for (const flowName of flowNames) {
-        const indexKey = StoreSubjects.flowRunIndex(flowName);
-        const flowStallTimeout = await this.getFlowStallTimeout(flowName);
-        const entries = await this.store.index.read(indexKey, { limit: 1e3 });
-        for (const entry of entries) {
-          if (!entry.metadata) continue;
-          checkedCount++;
-          if (entry.metadata.status !== "running" && entry.metadata.status !== "awaiting") continue;
-          const awaitingSteps = entry.metadata.awaitingSteps || {};
-          const awaitingStepNames = Object.keys(awaitingSteps);
-          if (awaitingStepNames.length > 0) {
-            let hasOverdueAwaits = false;
-            let hasLegacyAwait = false;
-            for (const stepName of awaitingStepNames) {
-              const awaitState = awaitingSteps[stepName];
-              if (awaitState?.status === "awaiting") {
-                if (!awaitState.timeoutAt) {
-                  hasLegacyAwait = true;
-                } else if (Date.now() > awaitState.timeoutAt) {
-                  hasOverdueAwaits = true;
-                  break;
-                }
-              }
-            }
-            if (hasOverdueAwaits) {
-              await this.markAsStalled(flowName, entry.id, "Await pattern timed out");
-              stalledCount++;
-              continue;
-            }
-            if (hasLegacyAwait) {
-              this.logger.debug(`Skipping flow with legacy await (no timeout) - '${flowName}' runId '${entry.id}'`);
-            }
-            continue;
-          }
-          const lastActivity = entry.metadata.lastActivityAt || entry.metadata.startedAt || 0;
-          const timeSinceActivity = Date.now() - lastActivity;
-          if (timeSinceActivity > flowStallTimeout) {
-            await this.markAsStalled(flowName, entry.id, "Periodic check detected no activity");
-            stalledCount++;
-          }
-        }
-      }
-      this.logger.info(`Periodic stall check completed - checked: ${checkedCount}, stalled: ${stalledCount}`);
-    } catch (error) {
-      this.logger.error("Failed to run periodic stall check", {
-        error: error.message
-      });
-    }
-  }
   /**
    * Run startup recovery to clean up flows left in running state from previous server instance
    * This marks all running flows as stalled since their in-memory state is lost
@@ -402,32 +237,13 @@ export class FlowStallDetector {
       this.logger.error(`Failed to validate flow stats: ${error.message}`);
     }
   }
-  /**
-   * Internal method for periodic checks
-   * Gets flow names from registry and checks them
-   */
-  async checkAllRunningFlows() {
-    try {
-      const analyzedFlows = $useAnalyzedFlows();
-      const flowNames = analyzedFlows.map((f) => f.id).filter(Boolean);
-      if (flowNames.length === 0) {
-        this.logger.debug("No flows registered, skipping stall check");
-        return;
-      }
-      await this.checkFlowsForStalls(flowNames);
-    } catch (error) {
-      this.logger.error(`Failed to run periodic stall check: ${error.message}`);
-    }
-  }
   /**
    * Get stall detector statistics
    */
   getStats() {
     return {
       enabled: this.started,
-      periodicCheckEnabled: this.config.enablePeriodicCheck,
-      stallTimeout: this.config.stallTimeout,
-      checkInterval: this.config.checkInterval
+      mode: "per-flow-scheduler"
     };
   }
 }