@lssm/lib.observability 1.42.0 → 1.42.2

package/CHANGELOG.md

@@ -1,14 +1,30 @@
 # @lssm/lib.observability
 
+## 1.42.2
+
+### Patch Changes
+
+- 1f9ac4c: fix
+- Updated dependencies [1f9ac4c]
+  - @lssm/lib.lifecycle@1.42.2
+
+## 1.42.1
+
+### Patch Changes
+
+- f043995: Fix release
+- Updated dependencies [f043995]
+  - @lssm/lib.lifecycle@1.42.1
+
 ## 1.42.0
 
 ### Minor Changes
 
-- 66a5dfd: initial release
+- 8eefd9c: initial release
 
 ### Patch Changes
 
-- Updated dependencies [66a5dfd]
+- Updated dependencies [8eefd9c]
   - @lssm/lib.lifecycle@1.42.0
 
 ## 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaman Ventures, SASU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,8 @@
 # @lssm/lib.observability
 
+Website: https://contractspec.lssm.tech/
+
+
 OpenTelemetry integration for tracing, metrics, and structured logging.
 
 ## Features
@@ -60,6 +63,16 @@ Full docs: https://contractspec.lssm.tech/docs/libraries/observability
 
 
 
+
+
+
+
+
+
+
+
+
+
 
 
 

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

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

package/dist/anomaly/alert-manager.mjs

@@ -1 +1,23 @@
-var e=class{cooldownMs;lastAlert=new Map;constructor(e){this.options=e,this.cooldownMs=e.cooldownMs??6e4}async notify(e,t){let n=`${e.type}:${t.culprit?.id??`none`}`,r=Date.now();r-(this.lastAlert.get(n)??0)<this.cooldownMs||(await this.options.transport({signal:e,analysis:t}),this.lastAlert.set(n,r))}};export{e as AlertManager};
+//#region src/anomaly/alert-manager.ts
+var AlertManager = class {
+	cooldownMs;
+	lastAlert = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		this.cooldownMs = options.cooldownMs ?? 6e4;
+	}
+	async notify(signal, analysis) {
+		const key = `${signal.type}:${analysis.culprit?.id ?? "none"}`;
+		const now = Date.now();
+		if (now - (this.lastAlert.get(key) ?? 0) < this.cooldownMs) return;
+		await this.options.transport({
+			signal,
+			analysis
+		});
+		this.lastAlert.set(key, now);
+	}
+};
+
+//#endregion
+export { AlertManager };
+//# sourceMappingURL=alert-manager.mjs.map

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

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

package/dist/anomaly/anomaly-detector.mjs

@@ -1 +1,58 @@
-import{BaselineCalculator as e}from"./baseline-calculator.mjs";var t=class{baseline;thresholds={errorRateDelta:.5,latencyDelta:.35,throughputDrop:.4,minSamples:10};constructor(t={}){this.baseline=new e,this.thresholds={...this.thresholds,...t}}evaluate(e){let t=this.baseline.update(e);if(t.sampleCount<this.thresholds.minSamples)return[];let n=[],r=this.relativeDelta(e.errorRate,t.errorRate);r>this.thresholds.errorRateDelta&&n.push({type:`error_rate_spike`,delta:r,point:e,baseline:t});let i=this.relativeDelta(e.latencyP99,t.latencyP99);i>this.thresholds.latencyDelta&&n.push({type:`latency_regression`,delta:i,point:e,baseline:t});let a=this.relativeDrop(e.throughput,t.throughput);return a>this.thresholds.throughputDrop&&n.push({type:`throughput_drop`,delta:a,point:e,baseline:t}),n}relativeDelta(e,t){return t===0?0:(e-t)/t}relativeDrop(e,t){return t===0?0:(t-e)/t}};export{t as AnomalyDetector};
+import { BaselineCalculator } from "./baseline-calculator.mjs";
+
+//#region src/anomaly/anomaly-detector.ts
+var AnomalyDetector = class {
+	baseline;
+	thresholds = {
+		errorRateDelta: .5,
+		latencyDelta: .35,
+		throughputDrop: .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;
+	}
+};
+
+//#endregion
+export { AnomalyDetector };
+//# sourceMappingURL=anomaly-detector.mjs.map

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

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

package/dist/anomaly/baseline-calculator.mjs

@@ -1 +1,37 @@
-var e=class{snapshot={latencyP99:0,latencyP95:0,errorRate:0,throughput:0,sampleCount:0};constructor(e=.2){this.alpha=e}update(e){let{sampleCount:t}=this.snapshot,n=t+1,r=t===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,e.latencyP99,r),latencyP95:this.mix(this.snapshot.latencyP95,e.latencyP95,r),errorRate:this.mix(this.snapshot.errorRate,e.errorRate,r),throughput:this.mix(this.snapshot.throughput,e.throughput,r),sampleCount:n},this.snapshot}getSnapshot(){return this.snapshot}mix(e,t,n){return this.snapshot.sampleCount===0?t:e*(1-n)+t*n}};export{e as BaselineCalculator};
+//#region src/anomaly/baseline-calculator.ts
+var BaselineCalculator = class {
+	snapshot = {
+		latencyP99: 0,
+		latencyP95: 0,
+		errorRate: 0,
+		throughput: 0,
+		sampleCount: 0
+	};
+	constructor(alpha = .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;
+	}
+};
+
+//#endregion
+export { BaselineCalculator };
+//# sourceMappingURL=baseline-calculator.mjs.map

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

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

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

@@ -1 +1,27 @@
-var e=class{constructor(e=900*1e3){this.lookbackMs=e}analyze(e,t){let n=new Date(e.point.timestamp.getTime()-this.lookbackMs),r=t.filter(e=>e.deployedAt>=n).sort((e,t)=>t.deployedAt.getTime()-e.deployedAt.getTime()),i=[],a;return r.length>0?(a=r[0],i.push(`Closest deployment ${a.id} (${a.operation}) at ${a.deployedAt.toISOString()}`)):i.push(`No deployments found within lookback window.`),e.type===`latency_regression`&&i.push(`Verify recent schema changes and external dependency latency.`),e.type===`error_rate_spike`&&i.push(`Check SLO monitor for correlated incidents.`),{signal:e,culprit:a,notes:i}}};export{e as RootCauseAnalyzer};
+//#region src/anomaly/root-cause-analyzer.ts
+var RootCauseAnalyzer = class {
+	constructor(lookbackMs = 900 * 1e3) {
+		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
+		};
+	}
+};
+
+//#endregion
+export { RootCauseAnalyzer };
+//# sourceMappingURL=root-cause-analyzer.mjs.map

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+import { BaselineCalculator } from "./anomaly/baseline-calculator.mjs";
+import { AnomalyDetector, AnomalySignal, AnomalyThresholds } from "./anomaly/anomaly-detector.mjs";
+import { RootCauseAnalysis, RootCauseAnalyzer } from "./anomaly/root-cause-analyzer.mjs";
+import { AlertManager } from "./anomaly/alert-manager.mjs";
+import { getTracer, traceAsync, traceSync } from "./tracing/index.mjs";
+import { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics } from "./metrics/index.mjs";
+import { LogEntry, LogLevel, Logger, logger } from "./logging/index.mjs";
+import { IntentAggregator, IntentAggregatorSnapshot, TelemetrySample } from "./intent/aggregator.mjs";
+import { TracingMiddlewareOptions, createTracingMiddleware } from "./tracing/middleware.mjs";
+import { IntentDetector, IntentSignal, IntentSignalType } from "./intent/detector.mjs";
+import { EvolutionPipeline, EvolutionPipelineEvent, EvolutionPipelineOptions } from "./pipeline/evolution-pipeline.mjs";
+import { LifecycleKpiPipeline, LifecycleKpiPipelineOptions, LifecyclePipelineEvent } from "./pipeline/lifecycle-pipeline.mjs";
+export { AlertManager, AnomalyDetector, type AnomalySignal, type AnomalyThresholds, BaselineCalculator, EvolutionPipeline, type EvolutionPipelineEvent, type EvolutionPipelineOptions, IntentAggregator, type IntentAggregatorSnapshot, IntentDetector, type IntentSignal, type IntentSignalType, LifecycleKpiPipeline, type LifecycleKpiPipelineOptions, type LifecyclePipelineEvent, type LogEntry, type LogLevel, Logger, type RootCauseAnalysis, RootCauseAnalyzer, type TelemetrySample, type TracingMiddlewareOptions, createCounter, createHistogram, createTracingMiddleware, createUpDownCounter, getMeter, getTracer, logger, standardMetrics, traceAsync, traceSync };

package/dist/index.mjs

@@ -1 +1,14 @@
-import{getTracer as e,traceAsync as t,traceSync as n}from"./tracing/index.mjs";import{createCounter as r,createHistogram as i,createUpDownCounter as a,getMeter as o,standardMetrics as s}from"./metrics/index.mjs";import{Logger as c,logger as l}from"./logging/index.mjs";import{createTracingMiddleware as u}from"./tracing/middleware.mjs";import{IntentAggregator as d}from"./intent/aggregator.mjs";import{IntentDetector as f}from"./intent/detector.mjs";import{EvolutionPipeline as p}from"./pipeline/evolution-pipeline.mjs";import{LifecycleKpiPipeline as m}from"./pipeline/lifecycle-pipeline.mjs";import{BaselineCalculator as h}from"./anomaly/baseline-calculator.mjs";import{AnomalyDetector as g}from"./anomaly/anomaly-detector.mjs";import{RootCauseAnalyzer as _}from"./anomaly/root-cause-analyzer.mjs";import{AlertManager as v}from"./anomaly/alert-manager.mjs";export{v as AlertManager,g as AnomalyDetector,h as BaselineCalculator,p as EvolutionPipeline,d as IntentAggregator,f as IntentDetector,m as LifecycleKpiPipeline,c as Logger,_ as RootCauseAnalyzer,r as createCounter,i as createHistogram,u as createTracingMiddleware,a as createUpDownCounter,o as getMeter,e as getTracer,l as logger,s as standardMetrics,t as traceAsync,n as traceSync};
+import { getTracer, traceAsync, traceSync } from "./tracing/index.mjs";
+import { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics } from "./metrics/index.mjs";
+import { Logger, logger } from "./logging/index.mjs";
+import { createTracingMiddleware } from "./tracing/middleware.mjs";
+import { IntentAggregator } from "./intent/aggregator.mjs";
+import { IntentDetector } from "./intent/detector.mjs";
+import { EvolutionPipeline } from "./pipeline/evolution-pipeline.mjs";
+import { LifecycleKpiPipeline } from "./pipeline/lifecycle-pipeline.mjs";
+import { BaselineCalculator } from "./anomaly/baseline-calculator.mjs";
+import { AnomalyDetector } from "./anomaly/anomaly-detector.mjs";
+import { RootCauseAnalyzer } from "./anomaly/root-cause-analyzer.mjs";
+import { AlertManager } from "./anomaly/alert-manager.mjs";
+
+export { AlertManager, AnomalyDetector, BaselineCalculator, EvolutionPipeline, IntentAggregator, IntentDetector, LifecycleKpiPipeline, Logger, RootCauseAnalyzer, createCounter, createHistogram, createTracingMiddleware, createUpDownCounter, getMeter, getTracer, logger, standardMetrics, traceAsync, traceSync };

package/dist/intent/aggregator.d.mts

@@ -0,0 +1,60 @@
+//#region src/intent/aggregator.d.ts
+interface TelemetrySample {
+  operation: {
+    name: string;
+    version: number;
+  };
+  durationMs: number;
+  success: boolean;
+  timestamp: Date;
+  errorCode?: string;
+  tenantId?: string;
+  traceId?: string;
+  actorId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface AggregatedOperationMetrics {
+  operation: {
+    name: string;
+    version: number;
+  };
+  totalCalls: number;
+  successRate: number;
+  errorRate: number;
+  averageLatencyMs: number;
+  p95LatencyMs: number;
+  p99LatencyMs: number;
+  maxLatencyMs: number;
+  windowStart: Date;
+  windowEnd: Date;
+  topErrors: Record<string, number>;
+}
+interface OperationSequence {
+  steps: string[];
+  tenantId?: string;
+  count: number;
+}
+interface IntentAggregatorSnapshot {
+  metrics: AggregatedOperationMetrics[];
+  sequences: OperationSequence[];
+  sampleCount: number;
+  windowStart?: Date;
+  windowEnd?: Date;
+}
+interface IntentAggregatorOptions {
+  windowMs?: number;
+  sequenceSampleSize?: number;
+}
+declare class IntentAggregator {
+  private readonly windowMs;
+  private readonly sequenceSampleSize;
+  private readonly samples;
+  constructor(options?: IntentAggregatorOptions);
+  add(sample: TelemetrySample): void;
+  flush(now?: Date): IntentAggregatorSnapshot;
+  private aggregateMetrics;
+  private buildSequences;
+}
+//#endregion
+export { AggregatedOperationMetrics, IntentAggregator, IntentAggregatorOptions, IntentAggregatorSnapshot, OperationSequence, TelemetrySample };
+//# sourceMappingURL=aggregator.d.mts.map

package/dist/intent/aggregator.mjs

@@ -1 +1,98 @@
-var e=class{windowMs;sequenceSampleSize;samples=[];constructor(e={}){this.windowMs=e.windowMs??9e5,this.sequenceSampleSize=e.sequenceSampleSize??1e3}add(e){this.samples.push(e)}flush(e=new Date){let t=e.getTime()-this.windowMs,n=this.samples.filter(e=>e.timestamp.getTime()>=t);this.samples.length=0;let r=this.aggregateMetrics(n),i=this.buildSequences(n),a=n.map(e=>e.timestamp.getTime());return{metrics:r,sequences:i,sampleCount:n.length,windowStart:a.length?new Date(Math.min(...a)):void 0,windowEnd:a.length?new Date(Math.max(...a)):void 0}}aggregateMetrics(e){if(!e.length)return[];let n=new Map;for(let t of e){let e=`${t.operation.name}.v${t.operation.version}`,r=n.get(e)??[];r.push(t),n.set(e,r)}return[...n.values()].map(e=>{let n=e.map(e=>e.durationMs).sort((e,t)=>e-t),r=e.filter(e=>!e.success),i=e.length,a=r.reduce((e,t)=>(t.errorCode&&(e[t.errorCode]=(e[t.errorCode]??0)+1),e),{}),o=e.map(e=>e.timestamp.getTime());return{operation:e[0].operation,totalCalls:i,successRate:(i-r.length)/i,errorRate:r.length/i,averageLatencyMs:n.reduce((e,t)=>e+t,0)/i,p95LatencyMs:t(n,.95),p99LatencyMs:t(n,.99),maxLatencyMs:Math.max(...n),windowStart:new Date(Math.min(...o)),windowEnd:new Date(Math.max(...o)),topErrors:a}})}buildSequences(e){let t=new Map;for(let n of e.slice(-this.sequenceSampleSize)){if(!n.traceId)continue;let e=t.get(n.traceId)??[];e.push(n),t.set(n.traceId,e)}let n={};for(let[e,r]of t.entries()){let e=r.sort((e,t)=>e.timestamp.getTime()-t.timestamp.getTime()),t=e.map(e=>e.operation.name);if(t.length<2)continue;let i=`${t.join(`>`)}@${e[0]?.tenantId??`global`}`,a=n[i];a?a.count+=1:n[i]={steps:t,tenantId:e[0]?.tenantId,count:1}}return Object.values(n).sort((e,t)=>t.count-e.count)}};function t(e,t){return e.length?e.length===1?e[0]:e[Math.min(e.length-1,Math.floor(t*e.length))]:0}export{e as IntentAggregator};
+//#region src/intent/aggregator.ts
+const DEFAULT_WINDOW_MS = 900 * 1e3;
+var IntentAggregator = class {
+	windowMs;
+	sequenceSampleSize;
+	samples = [];
+	constructor(options = {}) {
+		this.windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+		this.sequenceSampleSize = options.sequenceSampleSize ?? 1e3;
+	}
+	add(sample) {
+		this.samples.push(sample);
+	}
+	flush(now = /* @__PURE__ */ 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)) : void 0,
+			windowEnd: timestamps.length ? new Date(Math.max(...timestamps)) : void 0
+		};
+	}
+	aggregateMetrics(samples) {
+		if (!samples.length) return [];
+		const groups = /* @__PURE__ */ 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, .95),
+				p99LatencyMs: percentile(durations, .99),
+				maxLatencyMs: Math.max(...durations),
+				windowStart: new Date(Math.min(...timestamps)),
+				windowEnd: new Date(Math.max(...timestamps)),
+				topErrors
+			};
+		});
+	}
+	buildSequences(samples) {
+		const byTrace = /* @__PURE__ */ 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;
+	return values[Math.min(values.length - 1, Math.floor(ratio * values.length))] ?? 0;
+}
+
+//#endregion
+export { IntentAggregator };
+//# sourceMappingURL=aggregator.mjs.map

package/dist/intent/detector.d.mts

@@ -0,0 +1,32 @@
+import { AggregatedOperationMetrics, OperationSequence } from "./aggregator.mjs";
+
+//#region src/intent/detector.d.ts
+type IntentSignalType = 'latency-regression' | 'error-spike' | 'throughput-drop' | 'missing-workflow-step';
+interface IntentSignal {
+  id: string;
+  type: IntentSignalType;
+  operation?: AggregatedOperationMetrics['operation'];
+  confidence: number;
+  description: string;
+  metadata?: Record<string, unknown>;
+  evidence: {
+    type: 'metric' | 'sequence' | 'anomaly';
+    description: string;
+    data?: Record<string, unknown>;
+  }[];
+}
+interface IntentDetectorOptions {
+  errorRateThreshold?: number;
+  latencyP99ThresholdMs?: number;
+  throughputDropThreshold?: number;
+  minSequenceLength?: number;
+}
+declare class IntentDetector {
+  private readonly options;
+  constructor(options?: IntentDetectorOptions);
+  detectFromMetrics(current: AggregatedOperationMetrics[], previous?: AggregatedOperationMetrics[]): IntentSignal[];
+  detectSequentialIntents(sequences: OperationSequence[]): IntentSignal[];
+}
+//#endregion
+export { IntentDetector, IntentDetectorOptions, IntentSignal, IntentSignalType };
+//# sourceMappingURL=detector.d.mts.map

package/dist/intent/detector.mjs

@@ -1 +1,122 @@
-import{randomUUID as e}from"node:crypto";const t={errorRateThreshold:.05,latencyP99ThresholdMs:750,throughputDropThreshold:.3,minSequenceLength:3};var n=class{options;constructor(e={}){this.options={errorRateThreshold:e.errorRateThreshold??t.errorRateThreshold,latencyP99ThresholdMs:e.latencyP99ThresholdMs??t.latencyP99ThresholdMs,throughputDropThreshold:e.throughputDropThreshold??t.throughputDropThreshold,minSequenceLength:e.minSequenceLength??t.minSequenceLength}}detectFromMetrics(t,n){let r=[],i=new Map((n??[]).map(e=>[`${e.operation.name}.v${e.operation.version}`,e]));for(let n of t){if(n.errorRate>=this.options.errorRateThreshold){r.push({id:e(),type:`error-spike`,operation:n.operation,confidence:Math.min(1,n.errorRate/this.options.errorRateThreshold),description:`Error rate ${n.errorRate.toFixed(2)} exceeded threshold`,metadata:{errorRate:n.errorRate,topErrors:n.topErrors},evidence:[{type:`metric`,description:`error-rate`,data:{errorRate:n.errorRate,threshold:this.options.errorRateThreshold}}]});continue}if(n.p99LatencyMs>=this.options.latencyP99ThresholdMs){r.push({id:e(),type:`latency-regression`,operation:n.operation,confidence:Math.min(1,n.p99LatencyMs/this.options.latencyP99ThresholdMs),description:`P99 latency ${n.p99LatencyMs}ms exceeded threshold`,metadata:{p99LatencyMs:n.p99LatencyMs},evidence:[{type:`metric`,description:`p99-latency`,data:{p99LatencyMs:n.p99LatencyMs,threshold:this.options.latencyP99ThresholdMs}}]});continue}let t=i.get(`${n.operation.name}.v${n.operation.version}`);if(t){let i=(t.totalCalls-n.totalCalls)/Math.max(t.totalCalls,1);i>=this.options.throughputDropThreshold&&r.push({id:e(),type:`throughput-drop`,operation:n.operation,confidence:Math.min(1,i/this.options.throughputDropThreshold),description:`Throughput dropped ${(i*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls},evidence:[{type:`metric`,description:`throughput-drop`,data:{baselineCalls:t.totalCalls,currentCalls:n.totalCalls}}]})}}return r}detectSequentialIntents(t){let n=[];for(let r of t){if(r.steps.length<this.options.minSequenceLength)continue;let t=r.steps.join(` → `);n.push({id:e(),type:`missing-workflow-step`,confidence:.6,description:`Repeated workflow detected: ${t}`,metadata:{steps:r.steps,tenantId:r.tenantId,occurrences:r.count},evidence:[{type:`sequence`,description:`sequential-calls`,data:{steps:r.steps,count:r.count}}]})}return n}};export{n as IntentDetector};
+import { randomUUID } from "node:crypto";
+
+//#region src/intent/detector.ts
+const DEFAULTS = {
+	errorRateThreshold: .05,
+	latencyP99ThresholdMs: 750,
+	throughputDropThreshold: .3,
+	minSequenceLength: 3
+};
+var IntentDetector = class {
+	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(" → ");
+			signals.push({
+				id: randomUUID(),
+				type: "missing-workflow-step",
+				confidence: .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;
+	}
+};
+
+//#endregion
+export { IntentDetector };
+//# sourceMappingURL=detector.mjs.map

package/dist/logging/index.d.mts

@@ -0,0 +1,20 @@
+//#region src/logging/index.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LogEntry {
+  level: LogLevel;
+  message: string;
+  [key: string]: unknown;
+}
+declare class Logger {
+  private readonly serviceName;
+  constructor(serviceName: string);
+  private log;
+  debug(message: string, meta?: Record<string, unknown>): void;
+  info(message: string, meta?: Record<string, unknown>): void;
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+}
+declare const logger: Logger;
+//#endregion
+export { LogEntry, LogLevel, Logger, logger };
+//# sourceMappingURL=index.d.mts.map

package/dist/logging/index.mjs

@@ -1 +1,40 @@
-import{context as e,trace as t}from"@opentelemetry/api";var n=class{constructor(e){this.serviceName=e}log(n,r,i={}){let a=t.getSpan(e.active()),o=a?.spanContext().traceId,s=a?.spanContext().spanId,c={timestamp:new Date().toISOString(),service:this.serviceName,level:n,message:r,traceId:o,spanId:s,...i};console.log(JSON.stringify(c))}debug(e,t){this.log(`debug`,e,t)}info(e,t){this.log(`info`,e,t)}warn(e,t){this.log(`warn`,e,t)}error(e,t){this.log(`error`,e,t)}};const r=new n(process.env.OTEL_SERVICE_NAME||`unknown-service`);export{n as Logger,r as logger};
+import { context, trace } from "@opentelemetry/api";
+
+//#region src/logging/index.ts
+var Logger = class {
+	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: (/* @__PURE__ */ 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);
+	}
+};
+const logger = new Logger(process.env.OTEL_SERVICE_NAME || "unknown-service");
+
+//#endregion
+export { Logger, logger };
+//# sourceMappingURL=index.mjs.map

package/dist/metrics/index.d.mts

@@ -0,0 +1,17 @@
+import * as _opentelemetry_api0 from "@opentelemetry/api";
+import { Counter, Histogram, Meter, UpDownCounter } from "@opentelemetry/api";
+
+//#region src/metrics/index.d.ts
+declare function getMeter(name?: string): Meter;
+declare function createCounter(name: string, description?: string, meterName?: string): Counter;
+declare function createUpDownCounter(name: string, description?: string, meterName?: string): UpDownCounter;
+declare function createHistogram(name: string, description?: string, meterName?: string): Histogram;
+declare const standardMetrics: {
+  httpRequests: Counter<_opentelemetry_api0.Attributes>;
+  httpDuration: Histogram<_opentelemetry_api0.Attributes>;
+  operationErrors: Counter<_opentelemetry_api0.Attributes>;
+  workflowDuration: Histogram<_opentelemetry_api0.Attributes>;
+};
+//#endregion
+export { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics };
+//# sourceMappingURL=index.d.mts.map

package/dist/metrics/index.mjs

@@ -1 +1,26 @@
-import{metrics as e}from"@opentelemetry/api";function t(t=`@lssm/lib.observability`){return e.getMeter(t)}function n(e,n,r){return t(r).createCounter(e,{description:n})}function r(e,n,r){return t(r).createUpDownCounter(e,{description:n})}function i(e,n,r){return t(r).createHistogram(e,{description:n})}const a={httpRequests:n(`http_requests_total`,`Total HTTP requests`),httpDuration:i(`http_request_duration_seconds`,`HTTP request duration`),operationErrors:n(`operation_errors_total`,`Total operation errors`),workflowDuration:i(`workflow_duration_seconds`,`Workflow execution duration`)};export{n as createCounter,i as createHistogram,r as createUpDownCounter,t as getMeter,a as standardMetrics};
+import { metrics } from "@opentelemetry/api";
+
+//#region src/metrics/index.ts
+const DEFAULT_METER_NAME = "@lssm/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 });
+}
+const 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")
+};
+
+//#endregion
+export { createCounter, createHistogram, createUpDownCounter, getMeter, standardMetrics };
+//# sourceMappingURL=index.mjs.map

package/dist/pipeline/evolution-pipeline.d.mts

@@ -0,0 +1,40 @@
+import { IntentAggregator, IntentAggregatorSnapshot, TelemetrySample } from "../intent/aggregator.mjs";
+import { IntentDetector, IntentSignal } from "../intent/detector.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/evolution-pipeline.d.ts
+type EvolutionPipelineEvent = {
+  type: 'intent.detected';
+  payload: IntentSignal;
+} | {
+  type: 'telemetry.window';
+  payload: {
+    sampleCount: number;
+  };
+};
+interface EvolutionPipelineOptions {
+  detector?: IntentDetector;
+  aggregator?: IntentAggregator;
+  emitter?: EventEmitter;
+  onIntent?: (intent: IntentSignal) => Promise<void> | void;
+  onSnapshot?: (snapshot: IntentAggregatorSnapshot) => Promise<void> | void;
+}
+declare class EvolutionPipeline {
+  private readonly detector;
+  private readonly aggregator;
+  private readonly emitter;
+  private readonly onIntent?;
+  private readonly onSnapshot?;
+  private timer?;
+  private previousMetrics?;
+  constructor(options?: EvolutionPipelineOptions);
+  ingest(sample: TelemetrySample): void;
+  on(listener: (event: EvolutionPipelineEvent) => void): void;
+  start(intervalMs?: number): void;
+  stop(): void;
+  run(): Promise<void>;
+  private emit;
+}
+//#endregion
+export { EvolutionPipeline, EvolutionPipelineEvent, EvolutionPipelineOptions };
+//# sourceMappingURL=evolution-pipeline.d.mts.map

package/dist/pipeline/evolution-pipeline.mjs

@@ -1 +1,66 @@
-import{IntentAggregator as e}from"../intent/aggregator.mjs";import{IntentDetector as t}from"../intent/detector.mjs";import{EventEmitter as n}from"node:events";var r=class{detector;aggregator;emitter;onIntent;onSnapshot;timer;previousMetrics;constructor(r={}){this.detector=r.detector??new t,this.aggregator=r.aggregator??new e,this.emitter=r.emitter??new n,this.onIntent=r.onIntent,this.onSnapshot=r.onSnapshot}ingest(e){this.aggregator.add(e)}on(e){this.emitter.on(`event`,e)}start(e=300*1e3){this.stop(),this.timer=setInterval(()=>{this.run()},e)}stop(){this.timer&&=(clearInterval(this.timer),void 0)}async run(){let e=this.aggregator.flush();if(this.emit({type:`telemetry.window`,payload:{sampleCount:e.sampleCount}}),this.onSnapshot&&await this.onSnapshot(e),!e.sampleCount)return;let t=this.detector.detectFromMetrics(e.metrics,this.previousMetrics),n=this.detector.detectSequentialIntents(e.sequences);this.previousMetrics=e.metrics;let r=[...t,...n];for(let e of r)this.onIntent&&await this.onIntent(e),this.emit({type:`intent.detected`,payload:e})}emit(e){this.emitter.emit(`event`,e)}};export{r as EvolutionPipeline};
+import { IntentAggregator } from "../intent/aggregator.mjs";
+import { IntentDetector } from "../intent/detector.mjs";
+import { EventEmitter } from "node:events";
+
+//#region src/pipeline/evolution-pipeline.ts
+var EvolutionPipeline = class {
+	detector;
+	aggregator;
+	emitter;
+	onIntent;
+	onSnapshot;
+	timer;
+	previousMetrics;
+	constructor(options = {}) {
+		this.detector = options.detector ?? new IntentDetector();
+		this.aggregator = options.aggregator ?? new IntentAggregator();
+		this.emitter = options.emitter ?? new EventEmitter();
+		this.onIntent = options.onIntent;
+		this.onSnapshot = options.onSnapshot;
+	}
+	ingest(sample) {
+		this.aggregator.add(sample);
+	}
+	on(listener) {
+		this.emitter.on("event", listener);
+	}
+	start(intervalMs = 300 * 1e3) {
+		this.stop();
+		this.timer = setInterval(() => {
+			this.run();
+		}, intervalMs);
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+	}
+	async run() {
+		const snapshot = this.aggregator.flush();
+		this.emit({
+			type: "telemetry.window",
+			payload: { sampleCount: snapshot.sampleCount }
+		});
+		if (this.onSnapshot) await this.onSnapshot(snapshot);
+		if (!snapshot.sampleCount) return;
+		const metricSignals = this.detector.detectFromMetrics(snapshot.metrics, this.previousMetrics);
+		const sequenceSignals = this.detector.detectSequentialIntents(snapshot.sequences);
+		this.previousMetrics = snapshot.metrics;
+		const signals = [...metricSignals, ...sequenceSignals];
+		for (const signal of signals) {
+			if (this.onIntent) await this.onIntent(signal);
+			this.emit({
+				type: "intent.detected",
+				payload: signal
+			});
+		}
+	}
+	emit(event) {
+		this.emitter.emit("event", event);
+	}
+};
+
+//#endregion
+export { EvolutionPipeline };
+//# sourceMappingURL=evolution-pipeline.mjs.map

package/dist/pipeline/lifecycle-pipeline.d.mts

@@ -0,0 +1,44 @@
+import { EventEmitter } from "node:events";
+import { LifecycleAssessment, LifecycleStage } from "@lssm/lib.lifecycle";
+
+//#region src/pipeline/lifecycle-pipeline.d.ts
+type LifecyclePipelineEvent = {
+  type: 'assessment.recorded';
+  payload: {
+    tenantId?: string;
+    stage: LifecycleStage;
+  };
+} | {
+  type: 'stage.changed';
+  payload: {
+    tenantId?: string;
+    previousStage?: LifecycleStage;
+    nextStage: LifecycleStage;
+  };
+} | {
+  type: 'confidence.low';
+  payload: {
+    tenantId?: string;
+    confidence: number;
+  };
+};
+interface LifecycleKpiPipelineOptions {
+  meterName?: string;
+  emitter?: EventEmitter;
+  lowConfidenceThreshold?: number;
+}
+declare class LifecycleKpiPipeline {
+  private readonly assessmentCounter;
+  private readonly confidenceHistogram;
+  private readonly stageUpDownCounter;
+  private readonly emitter;
+  private readonly lowConfidenceThreshold;
+  private readonly currentStageByTenant;
+  constructor(options?: LifecycleKpiPipelineOptions);
+  recordAssessment(assessment: LifecycleAssessment, tenantId?: string): void;
+  on(listener: (event: LifecyclePipelineEvent) => void): void;
+  private ensureStageCounters;
+}
+//#endregion
+export { LifecycleKpiPipeline, LifecycleKpiPipelineOptions, LifecyclePipelineEvent };
+//# sourceMappingURL=lifecycle-pipeline.d.mts.map

package/dist/pipeline/lifecycle-pipeline.mjs

@@ -1 +1,73 @@
-import{createCounter as e,createHistogram as t,createUpDownCounter as n}from"../metrics/index.mjs";import{EventEmitter as r}from"node:events";import{getStageLabel as i}from"@lssm/lib.lifecycle";var a=class{assessmentCounter;confidenceHistogram;stageUpDownCounter;emitter;lowConfidenceThreshold;currentStageByTenant=new Map;constructor(i={}){let a=i.meterName??`@lssm/lib.lifecycle-kpi`;this.assessmentCounter=e(`lifecycle_assessments_total`,`Total lifecycle assessments`,a),this.confidenceHistogram=t(`lifecycle_assessment_confidence`,`Lifecycle assessment confidence distribution`,a),this.stageUpDownCounter=n(`lifecycle_stage_tenants`,`Current tenants per lifecycle stage`,a),this.emitter=i.emitter??new r,this.lowConfidenceThreshold=i.lowConfidenceThreshold??.4}recordAssessment(e,t){let n={stage:i(e.stage),tenantId:t};this.assessmentCounter.add(1,n),this.confidenceHistogram.record(e.confidence,n),this.ensureStageCounters(e.stage,t),this.emitter.emit(`event`,{type:`assessment.recorded`,payload:{tenantId:t,stage:e.stage}}),e.confidence<this.lowConfidenceThreshold&&this.emitter.emit(`event`,{type:`confidence.low`,payload:{tenantId:t,confidence:e.confidence}})}on(e){this.emitter.on(`event`,e)}ensureStageCounters(e,t){if(!t)return;let n=this.currentStageByTenant.get(t);n!==e&&(n!==void 0&&this.stageUpDownCounter.add(-1,{stage:i(n),tenantId:t}),this.stageUpDownCounter.add(1,{stage:i(e),tenantId:t}),this.currentStageByTenant.set(t,e),this.emitter.emit(`event`,{type:`stage.changed`,payload:{tenantId:t,previousStage:n,nextStage:e}}))}};export{a as LifecycleKpiPipeline};
+import { createCounter, createHistogram, createUpDownCounter } from "../metrics/index.mjs";
+import { EventEmitter } from "node:events";
+import { getStageLabel } from "@lssm/lib.lifecycle";
+
+//#region src/pipeline/lifecycle-pipeline.ts
+var LifecycleKpiPipeline = class {
+	assessmentCounter;
+	confidenceHistogram;
+	stageUpDownCounter;
+	emitter;
+	lowConfidenceThreshold;
+	currentStageByTenant = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		const meterName = options.meterName ?? "@lssm/lib.lifecycle-kpi";
+		this.assessmentCounter = createCounter("lifecycle_assessments_total", "Total lifecycle assessments", meterName);
+		this.confidenceHistogram = createHistogram("lifecycle_assessment_confidence", "Lifecycle assessment confidence distribution", meterName);
+		this.stageUpDownCounter = createUpDownCounter("lifecycle_stage_tenants", "Current tenants per lifecycle stage", meterName);
+		this.emitter = options.emitter ?? new EventEmitter();
+		this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? .4;
+	}
+	recordAssessment(assessment, tenantId) {
+		const attributes = {
+			stage: getStageLabel(assessment.stage),
+			tenantId
+		};
+		this.assessmentCounter.add(1, attributes);
+		this.confidenceHistogram.record(assessment.confidence, attributes);
+		this.ensureStageCounters(assessment.stage, tenantId);
+		this.emitter.emit("event", {
+			type: "assessment.recorded",
+			payload: {
+				tenantId,
+				stage: assessment.stage
+			}
+		});
+		if (assessment.confidence < this.lowConfidenceThreshold) this.emitter.emit("event", {
+			type: "confidence.low",
+			payload: {
+				tenantId,
+				confidence: assessment.confidence
+			}
+		});
+	}
+	on(listener) {
+		this.emitter.on("event", listener);
+	}
+	ensureStageCounters(stage, tenantId) {
+		if (!tenantId) return;
+		const previous = this.currentStageByTenant.get(tenantId);
+		if (previous === stage) return;
+		if (previous !== void 0) this.stageUpDownCounter.add(-1, {
+			stage: getStageLabel(previous),
+			tenantId
+		});
+		this.stageUpDownCounter.add(1, {
+			stage: getStageLabel(stage),
+			tenantId
+		});
+		this.currentStageByTenant.set(tenantId, stage);
+		this.emitter.emit("event", {
+			type: "stage.changed",
+			payload: {
+				tenantId,
+				previousStage: previous,
+				nextStage: stage
+			}
+		});
+	}
+};
+
+//#endregion
+export { LifecycleKpiPipeline };
+//# sourceMappingURL=lifecycle-pipeline.mjs.map

package/dist/tracing/index.d.mts

@@ -0,0 +1,9 @@
+import { Span, Tracer } from "@opentelemetry/api";
+
+//#region src/tracing/index.d.ts
+declare function getTracer(name?: string): Tracer;
+declare function traceAsync<T>(name: string, fn: (span: Span) => Promise<T>, tracerName?: string): Promise<T>;
+declare function traceSync<T>(name: string, fn: (span: Span) => T, tracerName?: string): T;
+//#endregion
+export { getTracer, traceAsync, traceSync };
+//# sourceMappingURL=index.d.mts.map

package/dist/tracing/index.mjs

@@ -1 +1,47 @@
-import{SpanStatusCode as e,trace as t}from"@opentelemetry/api";function n(e=`@lssm/lib.observability`){return t.getTracer(e)}async function r(t,r,i){return n(i).startActiveSpan(t,async t=>{try{let n=await r(t);return t.setStatus({code:e.OK}),n}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}function i(t,r,i){return n(i).startActiveSpan(t,t=>{try{let n=r(t);return t.setStatus({code:e.OK}),n}catch(n){throw t.recordException(n),t.setStatus({code:e.ERROR,message:n instanceof Error?n.message:String(n)}),n}finally{t.end()}})}export{n as getTracer,r as traceAsync,i as traceSync};
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+
+//#region src/tracing/index.ts
+const DEFAULT_TRACER_NAME = "@lssm/lib.observability";
+function getTracer(name = DEFAULT_TRACER_NAME) {
+	return trace.getTracer(name);
+}
+async function traceAsync(name, fn, tracerName) {
+	return getTracer(tracerName).startActiveSpan(name, async (span) => {
+		try {
+			const result = await fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+function traceSync(name, fn, tracerName) {
+	return getTracer(tracerName).startActiveSpan(name, (span) => {
+		try {
+			const result = fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+
+//#endregion
+export { getTracer, traceAsync, traceSync };
+//# sourceMappingURL=index.mjs.map

package/dist/tracing/middleware.d.mts

@@ -0,0 +1,19 @@
+import { TelemetrySample } from "../intent/aggregator.mjs";
+
+//#region src/tracing/middleware.d.ts
+interface TracingMiddlewareOptions {
+  resolveOperation?: (input: {
+    req: Request;
+    res?: Response;
+  }) => {
+    name: string;
+    version: number;
+  } | undefined;
+  onSample?: (sample: TelemetrySample) => void;
+  tenantResolver?: (req: Request) => string | undefined;
+  actorResolver?: (req: Request) => string | undefined;
+}
+declare function createTracingMiddleware(options?: TracingMiddlewareOptions): (req: Request, next: () => Promise<Response>) => Promise<Response>;
+//#endregion
+export { TracingMiddlewareOptions, createTracingMiddleware };
+//# sourceMappingURL=middleware.d.mts.map

package/dist/tracing/middleware.mjs

@@ -1 +1,80 @@
-import{traceAsync as e}from"./index.mjs";import{standardMetrics as t}from"../metrics/index.mjs";function n(n={}){return async(i,a)=>{let o=i.method,s=new URL(i.url).pathname;t.httpRequests.add(1,{method:o,path:s});let c=performance.now();return e(`HTTP ${o} ${s}`,async e=>{e.setAttribute(`http.method`,o),e.setAttribute(`http.url`,i.url);try{let l=await a();e.setAttribute(`http.status_code`,l.status);let u=(performance.now()-c)/1e3;return t.httpDuration.record(u,{method:o,path:s,status:l.status.toString()}),r({req:i,res:l,span:e,success:!0,durationMs:u*1e3,options:n}),l}catch(a){throw t.operationErrors.add(1,{method:o,path:s}),r({req:i,span:e,success:!1,durationMs:performance.now()-c,error:a,options:n}),a}})}}function r({req:e,res:t,span:n,success:r,durationMs:i,error:a,options:o}){if(!o.onSample||!o.resolveOperation)return;let s=o.resolveOperation({req:e,res:t});if(!s)return;let c={operation:s,durationMs:i,success:r,timestamp:new Date,errorCode:!r&&a instanceof Error?a.name:r?void 0:`unknown`,tenantId:o.tenantResolver?.(e),actorId:o.actorResolver?.(e),traceId:n.spanContext().traceId,metadata:{method:e.method,path:new URL(e.url).pathname,status:t?.status}};o.onSample(c)}export{n as createTracingMiddleware};
+import { traceAsync } from "./index.mjs";
+import { standardMetrics } from "../metrics/index.mjs";
+
+//#region src/tracing/middleware.ts
+function createTracingMiddleware(options = {}) {
+	return async (req, next) => {
+		const method = req.method;
+		const path = new URL(req.url).pathname;
+		standardMetrics.httpRequests.add(1, {
+			method,
+			path
+		});
+		const startTime = performance.now();
+		return traceAsync(`HTTP ${method} ${path}`, async (span) => {
+			span.setAttribute("http.method", method);
+			span.setAttribute("http.url", req.url);
+			try {
+				const response = await next();
+				span.setAttribute("http.status_code", response.status);
+				const duration = (performance.now() - startTime) / 1e3;
+				standardMetrics.httpDuration.record(duration, {
+					method,
+					path,
+					status: response.status.toString()
+				});
+				emitTelemetrySample({
+					req,
+					res: response,
+					span,
+					success: true,
+					durationMs: duration * 1e3,
+					options
+				});
+				return response;
+			} catch (error) {
+				standardMetrics.operationErrors.add(1, {
+					method,
+					path
+				});
+				emitTelemetrySample({
+					req,
+					span,
+					success: false,
+					durationMs: performance.now() - startTime,
+					error,
+					options
+				});
+				throw error;
+			}
+		});
+	};
+}
+function emitTelemetrySample({ req, res, span, success, durationMs, error, options }) {
+	if (!options.onSample || !options.resolveOperation) return;
+	const operation = options.resolveOperation({
+		req,
+		res
+	});
+	if (!operation) return;
+	const sample = {
+		operation,
+		durationMs,
+		success,
+		timestamp: /* @__PURE__ */ new Date(),
+		errorCode: !success && error instanceof Error ? error.name : success ? void 0 : "unknown",
+		tenantId: options.tenantResolver?.(req),
+		actorId: options.actorResolver?.(req),
+		traceId: span.spanContext().traceId,
+		metadata: {
+			method: req.method,
+			path: new URL(req.url).pathname,
+			status: res?.status
+		}
+	};
+	options.onSample(sample);
+}
+
+//#endregion
+export { createTracingMiddleware };
+//# sourceMappingURL=middleware.mjs.map

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@lssm/lib.observability",
-  "version": "1.42.0",
+  "version": "1.42.2",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "publish:pkg:canary": "bun publish:pkg --tag canary",
-    "build": "bun build:bundle && bun build:types",
+    "build": "bun build:types && bun build:bundle",
     "build:bundle": "tsdown",
     "build:types": "tsc --noEmit",
     "dev": "bun build:bundle --watch",
@@ -17,28 +17,30 @@
     "test": "bun run"
   },
   "dependencies": {
-    "@lssm/lib.lifecycle": "1.42.0"
+    "@lssm/lib.lifecycle": "1.42.2"
   },
   "peerDependencies": {
     "@opentelemetry/api": "*"
   },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "@lssm/tool.tsdown": "1.42.2",
+    "@lssm/tool.typescript": "1.42.2",
+    "typescript": "^5.9.3"
   },
   "exports": {
-    ".": "./src/index.ts",
-    "./anomaly/alert-manager": "./src/anomaly/alert-manager.ts",
-    "./anomaly/anomaly-detector": "./src/anomaly/anomaly-detector.ts",
-    "./anomaly/baseline-calculator": "./src/anomaly/baseline-calculator.ts",
-    "./anomaly/root-cause-analyzer": "./src/anomaly/root-cause-analyzer.ts",
-    "./intent/aggregator": "./src/intent/aggregator.ts",
-    "./intent/detector": "./src/intent/detector.ts",
-    "./logging": "./src/logging/index.ts",
-    "./metrics": "./src/metrics/index.ts",
-    "./pipeline/evolution-pipeline": "./src/pipeline/evolution-pipeline.ts",
-    "./pipeline/lifecycle-pipeline": "./src/pipeline/lifecycle-pipeline.ts",
-    "./tracing": "./src/tracing/index.ts",
-    "./tracing/middleware": "./src/tracing/middleware.ts",
+    ".": "./dist/index.mjs",
+    "./anomaly/alert-manager": "./dist/anomaly/alert-manager.mjs",
+    "./anomaly/anomaly-detector": "./dist/anomaly/anomaly-detector.mjs",
+    "./anomaly/baseline-calculator": "./dist/anomaly/baseline-calculator.mjs",
+    "./anomaly/root-cause-analyzer": "./dist/anomaly/root-cause-analyzer.mjs",
+    "./intent/aggregator": "./dist/intent/aggregator.mjs",
+    "./intent/detector": "./dist/intent/detector.mjs",
+    "./logging": "./dist/logging/index.mjs",
+    "./metrics": "./dist/metrics/index.mjs",
+    "./pipeline/evolution-pipeline": "./dist/pipeline/evolution-pipeline.mjs",
+    "./pipeline/lifecycle-pipeline": "./dist/pipeline/lifecycle-pipeline.mjs",
+    "./tracing": "./dist/tracing/index.mjs",
+    "./tracing/middleware": "./dist/tracing/middleware.mjs",
     "./*": "./*"
   },
   "module": "./dist/index.mjs",
@@ -59,6 +61,13 @@
       "./tracing": "./dist/tracing/index.mjs",
       "./tracing/middleware": "./dist/tracing/middleware.mjs",
       "./*": "./*"
-    }
+    },
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lssm-tech/contractspec.git",
+    "directory": "packages/libs/observability"
   }
 }