@backendkit-labs/auto-learning 0.1.3 → 0.2.0

package/dist/nestjs/index.cjs

@@ -85,8 +85,8 @@ var PatternRegistry = class {
     });
     return (0, import_result.ok)(void 0);
   }
-  getAggregates(windowMinutes) {
-    const result = this.storage.getAggregates(windowMinutes);
+  getAggregates(windowMinutes, windowEnd) {
+    const result = this.storage.getAggregates(windowMinutes, windowEnd);
     if (!result.ok) {
       this.observability.error("Failed to get aggregates", { error: result.error });
       return (0, import_result.fail)(storageError("Failed to get aggregates", result.error));
@@ -120,12 +120,18 @@ var PatternRegistry = class {
       });
     }
     const uniqueEndpoints = new Set(all.map((p) => `${p.method}:${p.path}`));
-    const timestamps = all.map((p) => p.timestamp.getTime());
+    let oldest = all[0].timestamp.getTime();
+    let newest = oldest;
+    for (const p of all) {
+      const t = p.timestamp.getTime();
+      if (t < oldest) oldest = t;
+      if (t > newest) newest = t;
+    }
     return (0, import_result.ok)({
       totalPatterns: all.length,
       uniqueEndpoints: uniqueEndpoints.size,
-      oldestPattern: new Date(Math.min(...timestamps)),
-      newestPattern: new Date(Math.max(...timestamps))
+      oldestPattern: new Date(oldest),
+      newestPattern: new Date(newest)
     });
   }
 };
@@ -165,23 +171,20 @@ var AnomalyDetector = class {
           });
         }
       }
-      if (current.statusCode >= 500 && baseline.errorCount >= 3) {
-        const currentErrorRate = 1;
-        if (currentErrorRate > baseline.errorRate * 2 && currentErrorRate > this.config.errorRateThreshold) {
-          reports.push({
-            id: (0, import_uuid.v4)(),
-            endpoint: current.path,
-            method: current.method,
-            severity: "high",
-            metric: "error_rate",
-            expectedValue: baseline.errorRate,
-            actualValue: currentErrorRate,
-            deviation: currentErrorRate / Math.max(baseline.errorRate, 1e-3),
-            detectedAt: /* @__PURE__ */ new Date()
-          });
-        }
+      if (current.statusCode >= 500 && baseline.errorRate < this.config.errorRateThreshold) {
+        reports.push({
+          id: (0, import_uuid.v4)(),
+          endpoint: current.path,
+          method: current.method,
+          severity: "high",
+          metric: "error_rate",
+          expectedValue: baseline.errorRate,
+          actualValue: 1,
+          deviation: 1 / Math.max(baseline.errorRate, 1e-3),
+          detectedAt: /* @__PURE__ */ new Date()
+        });
       }
-      return (0, import_result2.ok)(reports.length > 0 ? reports[0] : null);
+      return (0, import_result2.ok)(reports);
     } catch (e) {
       return (0, import_result2.fail)(
         anomalyDetectionFailed(
@@ -197,11 +200,13 @@ var AnomalyDetector = class {
         baselineMap.set(`${b.method}:${b.path}`, b);
       }
       const reports = [];
+      const seenUnknown = /* @__PURE__ */ new Set();
       for (const pattern of windowPatterns) {
         const key = `${pattern.method}:${pattern.path}`;
         const baseline = baselineMap.get(key);
         if (!baseline) {
-          if (this.config.enableUnknownEndpointDetection) {
+          if (this.config.enableUnknownEndpointDetection && !seenUnknown.has(key)) {
+            seenUnknown.add(key);
             reports.push({
               id: (0, import_uuid.v4)(),
               endpoint: pattern.path,
@@ -217,8 +222,8 @@ var AnomalyDetector = class {
           continue;
         }
         const result = this.analyze(pattern, baseline);
-        if (result.ok && result.value) {
-          reports.push(result.value);
+        if (result.ok) {
+          reports.push(...result.value);
         }
       }
       return (0, import_result2.ok)(reports);
@@ -246,7 +251,8 @@ var DEFAULT_TUNER_CONFIG = {
   minTimeoutMs: 1e3,
   maxTimeoutMs: 3e4,
   smoothingFactor: 0.3,
-  adjustmentStepMs: 500
+  adjustmentStepMs: 500,
+  cooldownMs: 6e4
 };
 
 // src/core/config-tuner/config-tuner.ts
@@ -281,48 +287,11 @@ var ConfigTuner = class {
     if (aggregates.length === 0) {
       return (0, import_result3.ok)(this.getCurrentConfig());
     }
-    const newConfig = {
-      circuitBreaker: { ...this.currentConfig.circuitBreaker },
-      bulkhead: { ...this.currentConfig.bulkhead },
-      httpClient: { ...this.currentConfig.httpClient }
-    };
-    const changedSections = /* @__PURE__ */ new Set();
-    const maxP95 = Math.max(...aggregates.map((a) => a.p95Ms));
-    const targetTimeout = Math.min(
-      Math.max(maxP95 * 2, this.config.minTimeoutMs),
-      this.config.maxTimeoutMs
-    );
-    if (Math.abs(targetTimeout - newConfig.httpClient.timeoutMs) > this.config.adjustmentStepMs) {
-      newConfig.httpClient.timeoutMs = this.smoothValue(newConfig.httpClient.timeoutMs, targetTimeout);
-      changedSections.add("httpClient");
-    }
-    const avgErrorRate = aggregates.reduce((sum, a) => sum + a.errorRate, 0) / aggregates.length;
-    if (avgErrorRate > 0.1) {
-      newConfig.httpClient.maxRetries = Math.min(newConfig.httpClient.maxRetries + 1, 5);
-      changedSections.add("httpClient");
-    } else if (avgErrorRate < 0.01 && newConfig.httpClient.maxRetries > 1) {
-      newConfig.httpClient.maxRetries = Math.max(newConfig.httpClient.maxRetries - 1, 0);
-      changedSections.add("httpClient");
-    }
-    const criticalAnomalies = anomalies.filter(
-      (a) => a.severity === "critical" || a.severity === "high"
-    ).length;
-    if (criticalAnomalies > 0) {
-      newConfig.circuitBreaker.failureThreshold = Math.max(
-        this.currentConfig.circuitBreaker.failureThreshold - 10 * criticalAnomalies,
-        10
-      );
-      changedSections.add("circuitBreaker");
-    } else if (anomalies.length === 0) {
-      newConfig.circuitBreaker.failureThreshold = Math.min(
-        this.currentConfig.circuitBreaker.failureThreshold + 5,
-        80
-      );
-      changedSections.add("circuitBreaker");
-    }
+    const newConfig = this.computeNext(aggregates, anomalies);
+    const changedSections = this.diffSections(this.currentConfig, newConfig);
     if (changedSections.size > 0) {
       const now = Date.now();
-      if (now - this.lastChangeAt > 6e4) {
+      if (now - this.lastChangeAt > this.config.cooldownMs) {
         this.currentConfig = newConfig;
         this.lastChangeAt = now;
         const saveResult = this.storage.saveConfig(newConfig);
@@ -359,6 +328,57 @@ var ConfigTuner = class {
   }
   onConfigChange(callback) {
     this.listeners.push(callback);
+    return () => {
+      const idx = this.listeners.indexOf(callback);
+      if (idx >= 0) this.listeners.splice(idx, 1);
+    };
+  }
+  // Pure computation — derives the next config from aggregates and anomalies
+  // without mutating any state or applying cooldown checks.
+  computeNext(aggregates, anomalies) {
+    const next = {
+      circuitBreaker: { ...this.currentConfig.circuitBreaker },
+      bulkhead: { ...this.currentConfig.bulkhead },
+      httpClient: { ...this.currentConfig.httpClient }
+    };
+    const maxP95 = Math.max(...aggregates.map((a) => a.p95Ms));
+    const targetTimeout = Math.min(
+      Math.max(maxP95 * 2, this.config.minTimeoutMs),
+      this.config.maxTimeoutMs
+    );
+    if (Math.abs(targetTimeout - next.httpClient.timeoutMs) > this.config.adjustmentStepMs) {
+      next.httpClient.timeoutMs = this.smoothValue(next.httpClient.timeoutMs, targetTimeout);
+    }
+    const avgErrorRate = aggregates.reduce((sum, a) => sum + a.errorRate, 0) / aggregates.length;
+    if (avgErrorRate > 0.1) {
+      next.httpClient.maxRetries = Math.min(next.httpClient.maxRetries + 1, 5);
+    } else if (avgErrorRate < 0.01 && next.httpClient.maxRetries > 1) {
+      next.httpClient.maxRetries = Math.max(next.httpClient.maxRetries - 1, 0);
+    }
+    const criticalAnomalies = anomalies.filter(
+      (a) => a.severity === "critical" || a.severity === "high"
+    ).length;
+    if (criticalAnomalies > 0) {
+      next.circuitBreaker.failureThreshold = Math.max(
+        this.currentConfig.circuitBreaker.failureThreshold - 10 * criticalAnomalies,
+        10
+      );
+    } else if (anomalies.length === 0) {
+      next.circuitBreaker.failureThreshold = Math.min(
+        this.currentConfig.circuitBreaker.failureThreshold + 5,
+        80
+      );
+    }
+    return next;
+  }
+  diffSections(prev, next) {
+    const changed = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(next)) {
+      if (JSON.stringify(next[key]) !== JSON.stringify(prev[key])) {
+        changed.add(key);
+      }
+    }
+    return changed;
   }
   smoothValue(current, target) {
     return current + (target - current) * this.config.smoothingFactor;
@@ -370,7 +390,7 @@ var DEFAULT_LOOP_CONFIG = {
   defaultIntervalMs: 6e4,
   windowSizeMinutes: 5,
   minSamplesBeforeTuning: 10,
-  cooldownBetweenChangesMs: 12e4
+  pruneTtlHours: 24
 };
 
 // src/core/feedback-loop/feedback-loop.ts
@@ -391,6 +411,7 @@ var FeedbackLoop = class {
   storage;
   observability;
   timerId = null;
+  isProcessing = false;
   config;
   cycleListeners = [];
   start(intervalMs) {
@@ -400,14 +421,20 @@ var FeedbackLoop = class {
     }
     const interval = intervalMs ?? this.config.defaultIntervalMs;
     this.observability.info("Feedback loop started", { intervalMs: interval });
-    this.timerId = setInterval(() => {
-      this.runOnce().then((result) => {
+    this.timerId = setInterval(async () => {
+      if (this.isProcessing) {
+        this.observability.warn("Skipping cycle: previous cycle still running");
+        return;
+      }
+      this.isProcessing = true;
+      try {
+        const result = await this.runOnce();
         if (!result.ok) {
-          this.observability.error("Feedback loop cycle failed", {
-            error: result.error
-          });
+          this.observability.error("Feedback loop cycle failed", { error: result.error });
         }
-      });
+      } finally {
+        this.isProcessing = false;
+      }
     }, interval);
   }
   stop() {
@@ -425,11 +452,10 @@ var FeedbackLoop = class {
   async runOnce() {
     const cycleId = (0, import_uuid2.v4)();
     const startTime = Date.now();
+    const windowEnd = /* @__PURE__ */ new Date();
+    const windowStart = new Date(windowEnd.getTime() - this.config.windowSizeMinutes * 6e4);
     this.observability.debug("Feedback cycle started", { cycleId });
-    const patternsResult = this.storage.getPatterns(
-      new Date(Date.now() - this.config.windowSizeMinutes * 6e4),
-      /* @__PURE__ */ new Date()
-    );
+    const patternsResult = this.storage.getPatterns(windowStart, windowEnd);
     if (!patternsResult.ok) {
       return (0, import_result4.fail)(storageError("Failed to collect patterns", patternsResult.error));
     }
@@ -450,7 +476,8 @@ var FeedbackLoop = class {
       return (0, import_result4.ok)(skippedEvent);
     }
     const aggregatesResult = this.patternRegistry.getAggregates(
-      this.config.windowSizeMinutes
+      this.config.windowSizeMinutes,
+      windowEnd
     );
     if (!aggregatesResult.ok) {
       return (0, import_result4.fail)(aggregatesResult.error);
@@ -462,7 +489,10 @@ var FeedbackLoop = class {
     }
     const anomalies = anomaliesResult.value;
     for (const anomaly of anomalies) {
-      this.storage.saveAnomaly(anomaly);
+      const saveAnomalyResult = this.storage.saveAnomaly(anomaly);
+      if (!saveAnomalyResult.ok) {
+        this.observability.warn("Failed to persist anomaly", { error: saveAnomalyResult.error });
+      }
     }
     if (anomalies.length > 0) {
       this.observability.warn("Anomalies detected", {
@@ -471,12 +501,12 @@ var FeedbackLoop = class {
       });
       this.observability.incrementMetric("anomalies.detected", anomalies.length);
     }
+    const previousConfig = this.configTuner.getCurrentConfig();
     const tuneResult = this.configTuner.tune(aggregates, anomalies);
     if (!tuneResult.ok) {
       return (0, import_result4.fail)(tuneResult.error);
     }
     const newConfig = tuneResult.value;
-    const previousConfig = this.configTuner.getCurrentConfig();
     const configChanges = {};
     for (const key of Object.keys(newConfig)) {
       if (JSON.stringify(newConfig[key]) !== JSON.stringify(previousConfig[key])) {
@@ -499,6 +529,11 @@ var FeedbackLoop = class {
     for (const listener of this.cycleListeners) {
       listener(cycleEvent);
     }
+    const pruneCutoff = new Date(Date.now() - this.config.pruneTtlHours * 36e5);
+    const pruneResult = this.storage.prune(pruneCutoff);
+    if (pruneResult.ok && pruneResult.value > 0) {
+      this.observability.debug("Pruned old records", { count: pruneResult.value });
+    }
     this.observability.info("Feedback cycle completed", {
       cycleId,
       patternsProcessed: cycleEvent.patternsProcessed,
@@ -511,6 +546,10 @@ var FeedbackLoop = class {
   }
   onCycle(callback) {
     this.cycleListeners.push(callback);
+    return () => {
+      const idx = this.cycleListeners.indexOf(callback);
+      if (idx >= 0) this.cycleListeners.splice(idx, 1);
+    };
   }
 };
 
@@ -521,6 +560,11 @@ var DEFAULT_CONFIG2 = {
   bulkhead: { maxConcurrentCalls: 10 },
   httpClient: { timeoutMs: 1e4, maxRetries: 3 }
 };
+var DEFAULT_LIMITS = {
+  maxPatterns: 1e4,
+  maxAnomalies: 1e3,
+  maxCycles: 1e3
+};
 function percentile(sorted, p) {
   if (sorted.length === 0) return 0;
   const index = Math.ceil(p / 100 * sorted.length) - 1;
@@ -531,9 +575,16 @@ var InMemoryStorage = class {
   anomalies = [];
   config = { ...DEFAULT_CONFIG2 };
   cycles = [];
+  limits;
+  constructor(limits) {
+    this.limits = { ...DEFAULT_LIMITS, ...limits };
+  }
   savePattern(pattern) {
     try {
       this.patterns.push(pattern);
+      if (this.patterns.length > this.limits.maxPatterns) {
+        this.patterns.shift();
+      }
       return (0, import_result5.ok)(void 0);
     } catch (e) {
       return (0, import_result5.fail)(storageError("Failed to save pattern", e));
@@ -550,26 +601,30 @@ var InMemoryStorage = class {
       return (0, import_result5.fail)(storageError("Failed to get patterns", e));
     }
   }
-  getAggregates(windowMinutes) {
+  getAggregates(windowMinutes, windowEnd) {
     try {
-      const cutoff = new Date(Date.now() - windowMinutes * 6e4);
-      const recent = this.patterns.filter((p) => p.timestamp >= cutoff);
+      const end = windowEnd ?? /* @__PURE__ */ new Date();
+      const cutoff = new Date(end.getTime() - windowMinutes * 6e4);
+      const recent = this.patterns.filter((p) => p.timestamp >= cutoff && p.timestamp <= end);
       const groups = /* @__PURE__ */ new Map();
       for (const p of recent) {
-        const key = `${p.method}:${p.path}`;
-        if (!groups.has(key)) groups.set(key, []);
-        groups.get(key).push(p);
+        const key = `${p.method}\0${p.path}`;
+        let g = groups.get(key);
+        if (!g) {
+          g = { method: p.method, path: p.path, items: [] };
+          groups.set(key, g);
+        }
+        g.items.push(p);
       }
       const aggregates = [];
-      for (const [key, items] of groups) {
-        const [method, path] = key.split(":");
+      for (const { method, path, items } of groups.values()) {
         const durations = items.map((i) => i.durationMs).sort((a, b) => a - b);
         const errors = items.filter((i) => i.statusCode >= 500).length;
         aggregates.push({
           method,
           path,
           windowStart: cutoff,
-          windowEnd: /* @__PURE__ */ new Date(),
+          windowEnd: end,
           count: items.length,
           avgDurationMs: durations.reduce((a, b) => a + b, 0) / durations.length,
           p50Ms: percentile(durations, 50),
@@ -587,6 +642,9 @@ var InMemoryStorage = class {
   saveAnomaly(report) {
     try {
       this.anomalies.push(report);
+      if (this.anomalies.length > this.limits.maxAnomalies) {
+        this.anomalies.shift();
+      }
       return (0, import_result5.ok)(void 0);
     } catch (e) {
       return (0, import_result5.fail)(storageError("Failed to save anomaly", e));
@@ -625,6 +683,9 @@ var InMemoryStorage = class {
   saveCycleEvent(event) {
     try {
       this.cycles.push(event);
+      if (this.cycles.length > this.limits.maxCycles) {
+        this.cycles.shift();
+      }
       return (0, import_result5.ok)(void 0);
     } catch (e) {
       return (0, import_result5.fail)(storageError("Failed to save cycle event", e));
@@ -713,10 +774,10 @@ var AutoLearningCore = class _AutoLearningCore {
     return this.feedbackLoop.runOnce();
   }
   onConfigChange(callback) {
-    this.configTuner.onConfigChange(callback);
+    return this.configTuner.onConfigChange(callback);
   }
   onCycle(callback) {
-    this.feedbackLoop.onCycle(callback);
+    return this.feedbackLoop.onCycle(callback);
   }
 };
 
@@ -738,6 +799,7 @@ var AutoLearningInterceptor = class {
   reflector;
   core;
   intercept(context, next) {
+    if (context.getType() !== "http") return next.handle();
     const options = this.reflector.get(
       AUTO_LEARN_METADATA,
       context.getHandler()
@@ -748,26 +810,42 @@ var AutoLearningInterceptor = class {
     const start = Date.now();
     const req = context.switchToHttp().getRequest();
     const { method, path } = this.extractRequestInfo(req);
+    const record = (statusCode) => {
+      const result = this.core.recordPattern({
+        method,
+        path,
+        statusCode,
+        durationMs: Date.now() - start,
+        timestamp: /* @__PURE__ */ new Date(),
+        metadata: this.buildMetadata(req, options)
+      });
+      if (!result.ok) {
+        this.core.observability.error("Failed to record pattern", { error: result.error });
+      }
+    };
     return next.handle().pipe(
-      (0, import_rxjs.tap)(() => {
-        const duration = Date.now() - start;
-        const status = context.switchToHttp().getResponse().statusCode;
-        this.core.recordPattern({
-          method,
-          path,
-          statusCode: status,
-          durationMs: duration,
-          timestamp: /* @__PURE__ */ new Date(),
-          metadata: options.customMetadata ? options.customMetadata(req) : void 0
-        });
+      (0, import_rxjs.tap)({
+        next: () => record(context.switchToHttp().getResponse().statusCode),
+        error: (err) => {
+          const status = typeof err?.getStatus === "function" ? err.getStatus() : err?.status ?? 500;
+          record(status);
+        }
       })
     );
   }
   extractRequestInfo(req) {
     const method = req.method ?? "UNKNOWN";
-    const path = req.route?.path ?? req.path ?? req.url ?? "/";
+    const raw = req.route?.path ?? req.path ?? req.url ?? "/";
+    const path = raw.split("?")[0];
     return { method, path };
   }
+  buildMetadata(req, options) {
+    const meta = {};
+    if (options.trackParams && req.params) meta.params = req.params;
+    if (options.trackBody && req.body) meta.body = req.body;
+    if (options.customMetadata) Object.assign(meta, options.customMetadata(req));
+    return Object.keys(meta).length > 0 ? meta : void 0;
+  }
 };
 AutoLearningInterceptor = __decorateClass([
   (0, import_common.Injectable)(),
@@ -787,11 +865,23 @@ var AutoLearningAdaptersService = class {
   moduleRef;
   cbRegistry = null;
   bhRegistry = null;
+  unsubConfigChange = null;
   async onModuleInit() {
     await this.resolveRegistries();
     if (this.cbRegistry || this.bhRegistry) {
-      this.core.onConfigChange((config) => this.applyConfig(config));
+      this.unsubConfigChange = this.core.onConfigChange((config) => this.applyConfig(config));
+    }
+  }
+  onApplicationBootstrap() {
+    if (this.options.autoStart !== false) {
+      this.core.startFeedbackLoop(this.options.intervalMs);
+    }
+  }
+  onModuleDestroy() {
+    if (this.core.isFeedbackLoopRunning()) {
+      this.core.stopFeedbackLoop();
     }
+    this.unsubConfigChange?.();
   }
   async resolveRegistries() {
     if (this.options.adapters?.circuitBreaker) {