@contractspec/lib.observability 3.7.16 → 3.7.18

package/dist/intent/aggregator.js

@@ -1,110 +1,2 @@
 // @bun
-// src/intent/aggregator.ts
-var DEFAULT_WINDOW_MS = 15 * 60 * 1000;
-
-class IntentAggregator {
-  windowMs;
-  sequenceSampleSize;
-  samples = [];
-  constructor(options = {}) {
-    this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
-    this.sequenceSampleSize = options.sequenceSampleSize ?? 1000;
-  }
-  add(sample) {
-    this.samples.push(sample);
-  }
-  flush(now = new Date) {
-    const minTimestamp = now.getTime() - this.windowMs;
-    const windowSamples = this.samples.filter((sample) => sample.timestamp.getTime() >= minTimestamp);
-    this.samples.length = 0;
-    const metrics = this.aggregateMetrics(windowSamples);
-    const sequences = this.buildSequences(windowSamples);
-    const timestamps = windowSamples.map((sample) => sample.timestamp.getTime());
-    return {
-      metrics,
-      sequences,
-      sampleCount: windowSamples.length,
-      windowStart: timestamps.length ? new Date(Math.min(...timestamps)) : undefined,
-      windowEnd: timestamps.length ? new Date(Math.max(...timestamps)) : undefined
-    };
-  }
-  aggregateMetrics(samples) {
-    if (!samples.length)
-      return [];
-    const groups = new Map;
-    for (const sample of samples) {
-      const key = `${sample.operation.name}.v${sample.operation.version}`;
-      const arr = groups.get(key) ?? [];
-      arr.push(sample);
-      groups.set(key, arr);
-    }
-    return [...groups.values()].map((group) => {
-      const first = group[0];
-      if (!first)
-        throw new Error("Empty group in aggregation");
-      const durations = group.map((s) => s.durationMs).sort((a, b) => a - b);
-      const errors = group.filter((s) => !s.success);
-      const totalCalls = group.length;
-      const topErrors = errors.reduce((acc, sample) => {
-        if (!sample.errorCode)
-          return acc;
-        acc[sample.errorCode] = (acc[sample.errorCode] ?? 0) + 1;
-        return acc;
-      }, {});
-      const timestamps = group.map((s) => s.timestamp.getTime());
-      return {
-        operation: first.operation,
-        totalCalls,
-        successRate: (totalCalls - errors.length) / totalCalls,
-        errorRate: errors.length / totalCalls,
-        averageLatencyMs: durations.reduce((sum, value) => sum + value, 0) / totalCalls,
-        p95LatencyMs: percentile(durations, 0.95),
-        p99LatencyMs: percentile(durations, 0.99),
-        maxLatencyMs: Math.max(...durations),
-        windowStart: new Date(Math.min(...timestamps)),
-        windowEnd: new Date(Math.max(...timestamps)),
-        topErrors
-      };
-    });
-  }
-  buildSequences(samples) {
-    const byTrace = new Map;
-    for (const sample of samples.slice(-this.sequenceSampleSize)) {
-      if (!sample.traceId)
-        continue;
-      const arr = byTrace.get(sample.traceId) ?? [];
-      arr.push(sample);
-      byTrace.set(sample.traceId, arr);
-    }
-    const sequences = {};
-    for (const events of byTrace.values()) {
-      const ordered = events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      const steps = ordered.map((event) => event.operation.name);
-      if (steps.length < 2)
-        continue;
-      const key = `${steps.join(">")}@${ordered[0]?.tenantId ?? "global"}`;
-      const existing = sequences[key];
-      if (existing) {
-        existing.count += 1;
-      } else {
-        sequences[key] = {
-          steps,
-          tenantId: ordered[0]?.tenantId,
-          count: 1
-        };
-      }
-    }
-    return Object.values(sequences).sort((a, b) => b.count - a.count);
-  }
-}
-function percentile(values, ratio) {
-  if (!values.length)
-    return 0;
-  if (values.length === 1)
-    return values[0] ?? 0;
-  const index = Math.min(values.length - 1, Math.floor(ratio * values.length));
-  return values[index] ?? 0;
-}
-export {
-  IntentAggregator
-};
+class u{windowMs;sequenceSampleSize;samples=[];constructor(t={}){this.windowMs=t.windowMs??900000,this.sequenceSampleSize=t.sequenceSampleSize??1000}add(t){this.samples.push(t)}flush(t=new Date){let i=t.getTime()-this.windowMs,e=this.samples.filter((o)=>o.timestamp.getTime()>=i);this.samples.length=0;let r=this.aggregateMetrics(e),n=this.buildSequences(e),a=e.map((o)=>o.timestamp.getTime());return{metrics:r,sequences:n,sampleCount:e.length,windowStart:a.length?new Date(Math.min(...a)):void 0,windowEnd:a.length?new Date(Math.max(...a)):void 0}}aggregateMetrics(t){if(!t.length)return[];let i=new Map;for(let e of t){let r=`${e.operation.name}.v${e.operation.version}`,n=i.get(r)??[];n.push(e),i.set(r,n)}return[...i.values()].map((e)=>{let r=e[0];if(!r)throw Error("Empty group in aggregation");let n=e.map((s)=>s.durationMs).sort((s,c)=>s-c),a=e.filter((s)=>!s.success),o=e.length,g=a.reduce((s,c)=>{if(!c.errorCode)return s;return s[c.errorCode]=(s[c.errorCode]??0)+1,s},{}),m=e.map((s)=>s.timestamp.getTime());return{operation:r.operation,totalCalls:o,successRate:(o-a.length)/o,errorRate:a.length/o,averageLatencyMs:n.reduce((s,c)=>s+c,0)/o,p95LatencyMs:p(n,0.95),p99LatencyMs:p(n,0.99),maxLatencyMs:Math.max(...n),windowStart:new Date(Math.min(...m)),windowEnd:new Date(Math.max(...m)),topErrors:g}})}buildSequences(t){let i=new Map;for(let r of t.slice(-this.sequenceSampleSize)){if(!r.traceId)continue;let n=i.get(r.traceId)??[];n.push(r),i.set(r.traceId,n)}let e={};for(let r of i.values()){let n=r.sort((m,s)=>m.timestamp.getTime()-s.timestamp.getTime()),a=n.map((m)=>m.operation.name);if(a.length<2)continue;let o=`${a.join(">")}@${n[0]?.tenantId??"global"}`,g=e[o];if(g)g.count+=1;else e[o]={steps:a,tenantId:n[0]?.tenantId,count:1}}return Object.values(e).sort((r,n)=>n.count-r.count)}}function p(t,i){if(!t.length)return 0;if(t.length===1)return t[0]??0;let e=Math.min(t.length-1,Math.floor(i*t.length));return t[e]??0}export{u as IntentAggregator};

package/dist/intent/detector.js

@@ -1,133 +1,2 @@
 // @bun
-// src/intent/detector.ts
-import { randomUUID } from "crypto";
-var DEFAULTS = {
-  errorRateThreshold: 0.05,
-  latencyP99ThresholdMs: 750,
-  throughputDropThreshold: 0.3,
-  minSequenceLength: 3
-};
-
-class IntentDetector {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      errorRateThreshold: options.errorRateThreshold ?? DEFAULTS.errorRateThreshold,
-      latencyP99ThresholdMs: options.latencyP99ThresholdMs ?? DEFAULTS.latencyP99ThresholdMs,
-      throughputDropThreshold: options.throughputDropThreshold ?? DEFAULTS.throughputDropThreshold,
-      minSequenceLength: options.minSequenceLength ?? DEFAULTS.minSequenceLength
-    };
-  }
-  detectFromMetrics(current, previous) {
-    const signals = [];
-    const baseline = new Map((previous ?? []).map((metric) => [
-      `${metric.operation.name}.v${metric.operation.version}`,
-      metric
-    ]));
-    for (const metric of current) {
-      if (metric.errorRate >= this.options.errorRateThreshold) {
-        signals.push({
-          id: randomUUID(),
-          type: "error-spike",
-          operation: metric.operation,
-          confidence: Math.min(1, metric.errorRate / this.options.errorRateThreshold),
-          description: `Error rate ${metric.errorRate.toFixed(2)} exceeded threshold`,
-          metadata: {
-            errorRate: metric.errorRate,
-            topErrors: metric.topErrors
-          },
-          evidence: [
-            {
-              type: "metric",
-              description: "error-rate",
-              data: {
-                errorRate: metric.errorRate,
-                threshold: this.options.errorRateThreshold
-              }
-            }
-          ]
-        });
-        continue;
-      }
-      if (metric.p99LatencyMs >= this.options.latencyP99ThresholdMs) {
-        signals.push({
-          id: randomUUID(),
-          type: "latency-regression",
-          operation: metric.operation,
-          confidence: Math.min(1, metric.p99LatencyMs / this.options.latencyP99ThresholdMs),
-          description: `P99 latency ${metric.p99LatencyMs}ms exceeded threshold`,
-          metadata: { p99LatencyMs: metric.p99LatencyMs },
-          evidence: [
-            {
-              type: "metric",
-              description: "p99-latency",
-              data: {
-                p99LatencyMs: metric.p99LatencyMs,
-                threshold: this.options.latencyP99ThresholdMs
-              }
-            }
-          ]
-        });
-        continue;
-      }
-      const base = baseline.get(`${metric.operation.name}.v${metric.operation.version}`);
-      if (base) {
-        const drop = (base.totalCalls - metric.totalCalls) / Math.max(base.totalCalls, 1);
-        if (drop >= this.options.throughputDropThreshold) {
-          signals.push({
-            id: randomUUID(),
-            type: "throughput-drop",
-            operation: metric.operation,
-            confidence: Math.min(1, drop / this.options.throughputDropThreshold),
-            description: `Throughput dropped ${(drop * 100).toFixed(1)}% vs baseline`,
-            metadata: {
-              baselineCalls: base.totalCalls,
-              currentCalls: metric.totalCalls
-            },
-            evidence: [
-              {
-                type: "metric",
-                description: "throughput-drop",
-                data: {
-                  baselineCalls: base.totalCalls,
-                  currentCalls: metric.totalCalls
-                }
-              }
-            ]
-          });
-        }
-      }
-    }
-    return signals;
-  }
-  detectSequentialIntents(sequences) {
-    const signals = [];
-    for (const sequence of sequences) {
-      if (sequence.steps.length < this.options.minSequenceLength)
-        continue;
-      const description = sequence.steps.join(" \u2192 ");
-      signals.push({
-        id: randomUUID(),
-        type: "missing-workflow-step",
-        confidence: 0.6,
-        description: `Repeated workflow detected: ${description}`,
-        metadata: {
-          steps: sequence.steps,
-          tenantId: sequence.tenantId,
-          occurrences: sequence.count
-        },
-        evidence: [
-          {
-            type: "sequence",
-            description: "sequential-calls",
-            data: { steps: sequence.steps, count: sequence.count }
-          }
-        ]
-      });
-    }
-    return signals;
-  }
-}
-export {
-  IntentDetector
-};
+import{randomUUID as s}from"crypto";var a={errorRateThreshold:0.05,latencyP99ThresholdMs:750,throughputDropThreshold:0.3,minSequenceLength:3};class c{options;constructor(r={}){this.options={errorRateThreshold:r.errorRateThreshold??a.errorRateThreshold,latencyP99ThresholdMs:r.latencyP99ThresholdMs??a.latencyP99ThresholdMs,throughputDropThreshold:r.throughputDropThreshold??a.throughputDropThreshold,minSequenceLength:r.minSequenceLength??a.minSequenceLength}}detectFromMetrics(r,n){let t=[],i=new Map((n??[]).map((e)=>[`${e.operation.name}.v${e.operation.version}`,e]));for(let e of r){if(e.errorRate>=this.options.errorRateThreshold){t.push({id:s(),type:"error-spike",operation:e.operation,confidence:Math.min(1,e.errorRate/this.options.errorRateThreshold),description:`Error rate ${e.errorRate.toFixed(2)} exceeded threshold`,metadata:{errorRate:e.errorRate,topErrors:e.topErrors},evidence:[{type:"metric",description:"error-rate",data:{errorRate:e.errorRate,threshold:this.options.errorRateThreshold}}]});continue}if(e.p99LatencyMs>=this.options.latencyP99ThresholdMs){t.push({id:s(),type:"latency-regression",operation:e.operation,confidence:Math.min(1,e.p99LatencyMs/this.options.latencyP99ThresholdMs),description:`P99 latency ${e.p99LatencyMs}ms exceeded threshold`,metadata:{p99LatencyMs:e.p99LatencyMs},evidence:[{type:"metric",description:"p99-latency",data:{p99LatencyMs:e.p99LatencyMs,threshold:this.options.latencyP99ThresholdMs}}]});continue}let o=i.get(`${e.operation.name}.v${e.operation.version}`);if(o){let p=(o.totalCalls-e.totalCalls)/Math.max(o.totalCalls,1);if(p>=this.options.throughputDropThreshold)t.push({id:s(),type:"throughput-drop",operation:e.operation,confidence:Math.min(1,p/this.options.throughputDropThreshold),description:`Throughput dropped ${(p*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:o.totalCalls,currentCalls:e.totalCalls},evidence:[{type:"metric",description:"throughput-drop",data:{baselineCalls:o.totalCalls,currentCalls:e.totalCalls}}]})}}return t}detectSequentialIntents(r){let n=[];for(let t of r){if(t.steps.length<this.options.minSequenceLength)continue;let i=t.steps.join(" \u2192 ");n.push({id:s(),type:"missing-workflow-step",confidence:0.6,description:`Repeated workflow detected: ${i}`,metadata:{steps:t.steps,tenantId:t.tenantId,occurrences:t.count},evidence:[{type:"sequence",description:"sequential-calls",data:{steps:t.steps,count:t.count}}]})}return n}}export{c as IntentDetector};

package/dist/logging/index.js

@@ -1,42 +1,2 @@
 // @bun
-// src/logging/index.ts
-import { context, trace } from "@opentelemetry/api";
-
-class Logger {
-  serviceName;
-  constructor(serviceName) {
-    this.serviceName = serviceName;
-  }
-  log(level, message, meta = {}) {
-    const span = trace.getSpan(context.active());
-    const traceId = span?.spanContext().traceId;
-    const spanId = span?.spanContext().spanId;
-    const entry = {
-      timestamp: new Date().toISOString(),
-      service: this.serviceName,
-      level,
-      message,
-      traceId,
-      spanId,
-      ...meta
-    };
-    console.log(JSON.stringify(entry));
-  }
-  debug(message, meta) {
-    this.log("debug", message, meta);
-  }
-  info(message, meta) {
-    this.log("info", message, meta);
-  }
-  warn(message, meta) {
-    this.log("warn", message, meta);
-  }
-  error(message, meta) {
-    this.log("error", message, meta);
-  }
-}
-var logger = new Logger(process.env.OTEL_SERVICE_NAME || "unknown-service");
-export {
-  logger,
-  Logger
-};
+import{context as c,trace as a}from"@opentelemetry/api";class t{serviceName;constructor(n){this.serviceName=n}log(n,e,o={}){let r=a.getSpan(c.active()),s=r?.spanContext().traceId,i=r?.spanContext().spanId,g={timestamp:new Date().toISOString(),service:this.serviceName,level:n,message:e,traceId:s,spanId:i,...o};console.log(JSON.stringify(g))}debug(n,e){this.log("debug",n,e)}info(n,e){this.log("info",n,e)}warn(n,e){this.log("warn",n,e)}error(n,e){this.log("error",n,e)}}var l=new t(process.env.OTEL_SERVICE_NAME||"unknown-service");export{l as logger,t as Logger};

package/dist/metrics/index.js

@@ -1,31 +1,2 @@
 // @bun
-// src/metrics/index.ts
-import {
-  metrics
-} from "@opentelemetry/api";
-var DEFAULT_METER_NAME = "@contractspec/lib.observability";
-function getMeter(name = DEFAULT_METER_NAME) {
-  return metrics.getMeter(name);
-}
-function createCounter(name, description, meterName) {
-  return getMeter(meterName).createCounter(name, { description });
-}
-function createUpDownCounter(name, description, meterName) {
-  return getMeter(meterName).createUpDownCounter(name, { description });
-}
-function createHistogram(name, description, meterName) {
-  return getMeter(meterName).createHistogram(name, { description });
-}
-var standardMetrics = {
-  httpRequests: createCounter("http_requests_total", "Total HTTP requests"),
-  httpDuration: createHistogram("http_request_duration_seconds", "HTTP request duration"),
-  operationErrors: createCounter("operation_errors_total", "Total operation errors"),
-  workflowDuration: createHistogram("workflow_duration_seconds", "Workflow execution duration")
-};
-export {
-  standardMetrics,
-  getMeter,
-  createUpDownCounter,
-  createHistogram,
-  createCounter
-};
+import{metrics as i}from"@opentelemetry/api";var u="@contractspec/lib.observability";function o(t=u){return i.getMeter(t)}function n(t,r,e){return o(e).createCounter(t,{description:r})}function p(t,r,e){return o(e).createUpDownCounter(t,{description:r})}function s(t,r,e){return o(e).createHistogram(t,{description:r})}var c={httpRequests:n("http_requests_total","Total HTTP requests"),httpDuration:s("http_request_duration_seconds","HTTP request duration"),operationErrors:n("operation_errors_total","Total operation errors"),workflowDuration:s("workflow_duration_seconds","Workflow execution duration")};export{c as standardMetrics,o as getMeter,p as createUpDownCounter,s as createHistogram,n as createCounter};

package/dist/node/anomaly/alert-manager.js

@@ -1,23 +1 @@
-// src/anomaly/alert-manager.ts
-class AlertManager {
-  options;
-  cooldownMs;
-  lastAlert = new Map;
-  constructor(options) {
-    this.options = options;
-    this.cooldownMs = options.cooldownMs ?? 60000;
-  }
-  async notify(signal, analysis) {
-    const key = `${signal.type}:${analysis.culprit?.id ?? "none"}`;
-    const now = Date.now();
-    const last = this.lastAlert.get(key) ?? 0;
-    if (now - last < this.cooldownMs) {
-      return;
-    }
-    await this.options.transport({ signal, analysis });
-    this.lastAlert.set(key, now);
-  }
-}
-export {
-  AlertManager
-};
+class r{options;cooldownMs;lastAlert=new Map;constructor(o){this.options=o;this.cooldownMs=o.cooldownMs??60000}async notify(o,t){let a=`${o.type}:${t.culprit?.id??"none"}`,n=Date.now(),e=this.lastAlert.get(a)??0;if(n-e<this.cooldownMs)return;await this.options.transport({signal:o,analysis:t}),this.lastAlert.set(a,n)}}export{r as AlertManager};

package/dist/node/anomaly/anomaly-detector.js

@@ -1,101 +1 @@
-// src/anomaly/baseline-calculator.ts
-class BaselineCalculator {
-  alpha;
-  snapshot = {
-    latencyP99: 0,
-    latencyP95: 0,
-    errorRate: 0,
-    throughput: 0,
-    sampleCount: 0
-  };
-  constructor(alpha = 0.2) {
-    this.alpha = alpha;
-  }
-  update(point) {
-    const { sampleCount } = this.snapshot;
-    const nextCount = sampleCount + 1;
-    const weight = sampleCount === 0 ? 1 : this.alpha;
-    this.snapshot = {
-      latencyP99: this.mix(this.snapshot.latencyP99, point.latencyP99, weight),
-      latencyP95: this.mix(this.snapshot.latencyP95, point.latencyP95, weight),
-      errorRate: this.mix(this.snapshot.errorRate, point.errorRate, weight),
-      throughput: this.mix(this.snapshot.throughput, point.throughput, weight),
-      sampleCount: nextCount
-    };
-    return this.snapshot;
-  }
-  getSnapshot() {
-    return this.snapshot;
-  }
-  mix(current, next, weight) {
-    if (this.snapshot.sampleCount === 0) {
-      return next;
-    }
-    return current * (1 - weight) + next * weight;
-  }
-}
-
-// src/anomaly/anomaly-detector.ts
-class AnomalyDetector {
-  baseline;
-  thresholds = {
-    errorRateDelta: 0.5,
-    latencyDelta: 0.35,
-    throughputDrop: 0.4,
-    minSamples: 10
-  };
-  constructor(options = {}) {
-    this.baseline = new BaselineCalculator;
-    this.thresholds = { ...this.thresholds, ...options };
-  }
-  evaluate(point) {
-    const baselineSnapshot = this.baseline.update(point);
-    if (baselineSnapshot.sampleCount < this.thresholds.minSamples) {
-      return [];
-    }
-    const signals = [];
-    const errorDelta = this.relativeDelta(point.errorRate, baselineSnapshot.errorRate);
-    if (errorDelta > this.thresholds.errorRateDelta) {
-      signals.push({
-        type: "error_rate_spike",
-        delta: errorDelta,
-        point,
-        baseline: baselineSnapshot
-      });
-    }
-    const latencyDelta = this.relativeDelta(point.latencyP99, baselineSnapshot.latencyP99);
-    if (latencyDelta > this.thresholds.latencyDelta) {
-      signals.push({
-        type: "latency_regression",
-        delta: latencyDelta,
-        point,
-        baseline: baselineSnapshot
-      });
-    }
-    const throughputDelta = this.relativeDrop(point.throughput, baselineSnapshot.throughput);
-    if (throughputDelta > this.thresholds.throughputDrop) {
-      signals.push({
-        type: "throughput_drop",
-        delta: throughputDelta,
-        point,
-        baseline: baselineSnapshot
-      });
-    }
-    return signals;
-  }
-  relativeDelta(value, baseline) {
-    if (baseline === 0) {
-      return 0;
-    }
-    return (value - baseline) / baseline;
-  }
-  relativeDrop(value, baseline) {
-    if (baseline === 0) {
-      return 0;
-    }
-    return (baseline - value) / baseline;
-  }
-}
-export {
-  AnomalyDetector
-};
+class s{alpha;snapshot={latencyP99:0,latencyP95:0,errorRate:0,throughput:0,sampleCount:0};constructor(e=0.2){this.alpha=e}update(e){let{sampleCount:t}=this.snapshot,r=t+1,a=t===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,e.latencyP99,a),latencyP95:this.mix(this.snapshot.latencyP95,e.latencyP95,a),errorRate:this.mix(this.snapshot.errorRate,e.errorRate,a),throughput:this.mix(this.snapshot.throughput,e.throughput,a),sampleCount:r},this.snapshot}getSnapshot(){return this.snapshot}mix(e,t,r){if(this.snapshot.sampleCount===0)return t;return e*(1-r)+t*r}}class l{baseline;thresholds={errorRateDelta:0.5,latencyDelta:0.35,throughputDrop:0.4,minSamples:10};constructor(e={}){this.baseline=new s,this.thresholds={...this.thresholds,...e}}evaluate(e){let t=this.baseline.update(e);if(t.sampleCount<this.thresholds.minSamples)return[];let r=[],a=this.relativeDelta(e.errorRate,t.errorRate);if(a>this.thresholds.errorRateDelta)r.push({type:"error_rate_spike",delta:a,point:e,baseline:t});let n=this.relativeDelta(e.latencyP99,t.latencyP99);if(n>this.thresholds.latencyDelta)r.push({type:"latency_regression",delta:n,point:e,baseline:t});let o=this.relativeDrop(e.throughput,t.throughput);if(o>this.thresholds.throughputDrop)r.push({type:"throughput_drop",delta:o,point:e,baseline:t});return r}relativeDelta(e,t){if(t===0)return 0;return(e-t)/t}relativeDrop(e,t){if(t===0)return 0;return(t-e)/t}}export{l as AnomalyDetector};

package/dist/node/anomaly/baseline-calculator.js

@@ -1,39 +1 @@
-// src/anomaly/baseline-calculator.ts
-class BaselineCalculator {
-  alpha;
-  snapshot = {
-    latencyP99: 0,
-    latencyP95: 0,
-    errorRate: 0,
-    throughput: 0,
-    sampleCount: 0
-  };
-  constructor(alpha = 0.2) {
-    this.alpha = alpha;
-  }
-  update(point) {
-    const { sampleCount } = this.snapshot;
-    const nextCount = sampleCount + 1;
-    const weight = sampleCount === 0 ? 1 : this.alpha;
-    this.snapshot = {
-      latencyP99: this.mix(this.snapshot.latencyP99, point.latencyP99, weight),
-      latencyP95: this.mix(this.snapshot.latencyP95, point.latencyP95, weight),
-      errorRate: this.mix(this.snapshot.errorRate, point.errorRate, weight),
-      throughput: this.mix(this.snapshot.throughput, point.throughput, weight),
-      sampleCount: nextCount
-    };
-    return this.snapshot;
-  }
-  getSnapshot() {
-    return this.snapshot;
-  }
-  mix(current, next, weight) {
-    if (this.snapshot.sampleCount === 0) {
-      return next;
-    }
-    return current * (1 - weight) + next * weight;
-  }
-}
-export {
-  BaselineCalculator
-};
+class a{alpha;snapshot={latencyP99:0,latencyP95:0,errorRate:0,throughput:0,sampleCount:0};constructor(t=0.2){this.alpha=t}update(t){let{sampleCount:e}=this.snapshot,n=e+1,r=e===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,t.latencyP99,r),latencyP95:this.mix(this.snapshot.latencyP95,t.latencyP95,r),errorRate:this.mix(this.snapshot.errorRate,t.errorRate,r),throughput:this.mix(this.snapshot.throughput,t.throughput,r),sampleCount:n},this.snapshot}getSnapshot(){return this.snapshot}mix(t,e,n){if(this.snapshot.sampleCount===0)return e;return t*(1-n)+e*n}}export{a as BaselineCalculator};

package/dist/node/anomaly/root-cause-analyzer.js

@@ -1,31 +1 @@
-// src/anomaly/root-cause-analyzer.ts
-class RootCauseAnalyzer {
-  lookbackMs;
-  constructor(lookbackMs = 15 * 60 * 1000) {
-    this.lookbackMs = lookbackMs;
-  }
-  analyze(signal, deployments) {
-    const windowStart = new Date(signal.point.timestamp.getTime() - this.lookbackMs);
-    const candidates = deployments.filter((deployment) => deployment.deployedAt >= windowStart).sort((a, b) => b.deployedAt.getTime() - a.deployedAt.getTime());
-    const notes = [];
-    let culprit;
-    if (candidates.length > 0) {
-      culprit = candidates[0];
-      if (culprit) {
-        notes.push(`Closest deployment ${culprit.id} (${culprit.operation}) at ${culprit.deployedAt.toISOString()}`);
-      }
-    } else {
-      notes.push("No deployments found within lookback window.");
-    }
-    if (signal.type === "latency_regression") {
-      notes.push("Verify recent schema changes and external dependency latency.");
-    }
-    if (signal.type === "error_rate_spike") {
-      notes.push("Check SLO monitor for correlated incidents.");
-    }
-    return { signal, culprit, notes };
-  }
-}
-export {
-  RootCauseAnalyzer
-};
+class l{lookbackMs;constructor(t=900000){this.lookbackMs=t}analyze(t,i){let s=new Date(t.point.timestamp.getTime()-this.lookbackMs),r=i.filter((n)=>n.deployedAt>=s).sort((n,a)=>a.deployedAt.getTime()-n.deployedAt.getTime()),o=[],e;if(r.length>0){if(e=r[0],e)o.push(`Closest deployment ${e.id} (${e.operation}) at ${e.deployedAt.toISOString()}`)}else o.push("No deployments found within lookback window.");if(t.type==="latency_regression")o.push("Verify recent schema changes and external dependency latency.");if(t.type==="error_rate_spike")o.push("Check SLO monitor for correlated incidents.");return{signal:t,culprit:e,notes:o}}}export{l as RootCauseAnalyzer};