@contractspec/lib.observability 3.7.17 → 3.7.19

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @contractspec/lib.observability
 
+## 3.7.19
+
+### Patch Changes
+
+- Updated dependencies because of Expand ContractSpec authoring with preset-driven workspace setup, shell completion, packaged workspace schema artifacts, and richer form and UI surfaces across the CLI, editors, and shared runtimes.
+  - @contractspec/lib.contracts-spec@5.3.0
+  - @contractspec/lib.contracts-integrations@3.8.11
+  - @contractspec/lib.lifecycle@3.7.19
+
+## 3.7.18
+
+### Patch Changes
+
+- chore: auto-bump internal dependents
+- Updated dependencies because of chore: auto-bump internal dependents
+- Updated dependencies because of Introduce the Builder v3 control plane as a governed authoring layer over external execution providers.
+- Updated dependencies because of Implement ContractSpec Connect as a first-class spec, runtime, and CLI workflow.
+  - @contractspec/lib.contracts-integrations@3.8.10
+  - @contractspec/lib.lifecycle@3.7.18
+  - @contractspec/lib.contracts-spec@5.2.0
+
 ## 3.7.17
 
 ### Patch Changes

package/dist/anomaly/alert-manager.js

@@ -1,24 +1,2 @@
 // @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
-};
+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/anomaly/anomaly-detector.js

@@ -1,102 +1,2 @@
 // @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
-};
+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/anomaly/baseline-calculator.js

@@ -1,40 +1,2 @@
 // @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
-};
+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/anomaly/root-cause-analyzer.js

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