@contractspec/lib.observability 1.57.0 → 1.59.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @contractspec/lib.observability
 
+## 1.59.0
+
+### Minor Changes
+
+- 1a0cf44: fix: publishConfig not supported by bun
+
+### Patch Changes
+
+- Updated dependencies [1a0cf44]
+  - @contractspec/lib.contracts@1.59.0
+  - @contractspec/lib.lifecycle@1.59.0
+
+## 1.58.0
+
+### Minor Changes
+
+- d1f0fd0: chore: Migrate non-app package builds from tsdown to shared Bun tooling, add `@contractspec/tool.bun`, and standardize `prebuild`/`build`/`typecheck` with platform-aware exports and `tsc` declaration emission into `dist`.
+
+### Patch Changes
+
+- Updated dependencies [d1f0fd0]
+- Updated dependencies [4355a9e]
+  - @contractspec/lib.contracts@1.58.0
+  - @contractspec/lib.lifecycle@1.58.0
+
 ## 1.57.0
 
 ### Minor Changes

package/dist/anomaly/alert-manager.d.ts

@@ -0,0 +1,17 @@
+import type { AnomalySignal } from './anomaly-detector';
+import type { RootCauseAnalysis } from './root-cause-analyzer';
+export interface AlertManagerOptions {
+    cooldownMs?: number;
+    transport: (payload: {
+        signal: AnomalySignal;
+        analysis: RootCauseAnalysis;
+    }) => Promise<void> | void;
+}
+export declare class AlertManager {
+    private readonly options;
+    private readonly cooldownMs;
+    private readonly lastAlert;
+    constructor(options: AlertManagerOptions);
+    notify(signal: AnomalySignal, analysis: RootCauseAnalysis): Promise<void>;
+}
+//# sourceMappingURL=alert-manager.d.ts.map

package/dist/anomaly/alert-manager.js

@@ -0,0 +1,24 @@
+// @bun
+// 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
+};

package/dist/anomaly/anomaly-detector.d.ts

@@ -0,0 +1,22 @@
+import { BaselineCalculator, type MetricPoint } from './baseline-calculator';
+export interface AnomalyThresholds {
+    errorRateDelta?: number;
+    latencyDelta?: number;
+    throughputDrop?: number;
+    minSamples?: number;
+}
+export interface AnomalySignal {
+    type: 'error_rate_spike' | 'latency_regression' | 'throughput_drop';
+    delta: number;
+    point: MetricPoint;
+    baseline: ReturnType<BaselineCalculator['getSnapshot']>;
+}
+export declare class AnomalyDetector {
+    private readonly baseline;
+    private readonly thresholds;
+    constructor(options?: AnomalyThresholds);
+    evaluate(point: MetricPoint): AnomalySignal[];
+    private relativeDelta;
+    private relativeDrop;
+}
+//# sourceMappingURL=anomaly-detector.d.ts.map

package/dist/anomaly/anomaly-detector.js

@@ -0,0 +1,102 @@
+// @bun
+// 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
+};

package/dist/anomaly/baseline-calculator.d.ts

@@ -0,0 +1,23 @@
+export interface MetricPoint {
+    latencyP99: number;
+    latencyP95: number;
+    errorRate: number;
+    throughput: number;
+    timestamp: Date;
+}
+export interface BaselineSnapshot {
+    latencyP99: number;
+    latencyP95: number;
+    errorRate: number;
+    throughput: number;
+    sampleCount: number;
+}
+export declare class BaselineCalculator {
+    private readonly alpha;
+    private snapshot;
+    constructor(alpha?: number);
+    update(point: MetricPoint): BaselineSnapshot;
+    getSnapshot(): BaselineSnapshot;
+    private mix;
+}
+//# sourceMappingURL=baseline-calculator.d.ts.map

package/dist/anomaly/baseline-calculator.js

@@ -0,0 +1,40 @@
+// @bun
+// 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
+};

package/dist/anomaly/root-cause-analyzer.d.ts

@@ -0,0 +1,19 @@
+import type { AnomalySignal } from './anomaly-detector';
+export interface DeploymentEvent {
+    id: string;
+    operation: string;
+    deployedAt: Date;
+    stage?: string;
+    status: 'in_progress' | 'completed' | 'rolled_back';
+}
+export interface RootCauseAnalysis {
+    signal: AnomalySignal;
+    culprit?: DeploymentEvent;
+    notes: string[];
+}
+export declare class RootCauseAnalyzer {
+    private readonly lookbackMs;
+    constructor(lookbackMs?: number);
+    analyze(signal: AnomalySignal, deployments: DeploymentEvent[]): RootCauseAnalysis;
+}
+//# sourceMappingURL=root-cause-analyzer.d.ts.map

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

@@ -0,0 +1,32 @@
+// @bun
+// 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
+};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { getTracer, traceAsync, traceSync } from './tracing';
+export { getMeter, createCounter, createUpDownCounter, createHistogram, standardMetrics, } from './metrics';
+export { Logger, logger } from './logging';
+export { createTracingMiddleware, type TracingMiddlewareOptions, } from './tracing/middleware';
+export { IntentAggregator, type IntentAggregatorSnapshot, type TelemetrySample, } from './intent/aggregator';
+export { IntentDetector, type IntentSignal, type IntentSignalType, } from './intent/detector';
+export { EvolutionPipeline, type EvolutionPipelineEvent, type EvolutionPipelineOptions, } from './pipeline/evolution-pipeline';
+export { LifecycleKpiPipeline, type LifecycleKpiPipelineOptions, type LifecyclePipelineEvent, } from './pipeline/lifecycle-pipeline';
+export { PosthogTelemetryProvider, type PosthogTelemetryProviderOptions, } from './telemetry/posthog-telemetry';
+export { PosthogBaselineReader } from './telemetry/posthog-baseline-reader';
+export type { LogLevel, LogEntry } from './logging';
+export { BaselineCalculator } from './anomaly/baseline-calculator';
+export { AnomalyDetector, type AnomalySignal, type AnomalyThresholds, } from './anomaly/anomaly-detector';
+export { RootCauseAnalyzer, type RootCauseAnalysis, } from './anomaly/root-cause-analyzer';
+export { AlertManager } from './anomaly/alert-manager';
+//# sourceMappingURL=index.d.ts.map