@contractspec/lib.observability 3.7.16 → 3.7.18

package/dist/node/index.js

@@ -1,1128 +1,5 @@
-// 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);
-  }
-}
-
-// 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;
-  }
-}
-
-// 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 };
-  }
-}
-
-// 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;
-}
-
-// 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(" → ");
-      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;
-  }
-}
-
-// 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");
-
-// 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")
-};
-
-// src/pipeline/evolution-pipeline.ts
-import { EventEmitter } from "node:events";
-class EvolutionPipeline {
-  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 = 5 * 60 * 1000) {
-    this.stop();
-    this.timer = setInterval(() => {
-      this.run();
-    }, intervalMs);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = undefined;
-    }
-  }
-  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);
-  }
-}
-
-// src/pipeline/lifecycle-pipeline.ts
-import { EventEmitter as EventEmitter2 } from "node:events";
-import { getStageLabel } from "@contractspec/lib.lifecycle";
-class LifecycleKpiPipeline {
-  assessmentCounter;
-  confidenceHistogram;
-  stageUpDownCounter;
-  emitter;
-  lowConfidenceThreshold;
-  currentStageByTenant = new Map;
-  constructor(options = {}) {
-    const meterName = options.meterName ?? "@contractspec/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 EventEmitter2;
-    this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? 0.4;
-  }
-  recordAssessment(assessment, tenantId) {
-    const stageLabel = getStageLabel(assessment.stage);
-    const attributes = { stage: stageLabel, 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 !== undefined) {
-      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 }
-    });
-  }
-}
-
-// src/telemetry/model-selection-telemetry.ts
-class ModelSelectionTelemetry {
-  provider;
-  eventName;
-  constructor(provider, options) {
-    this.provider = provider;
-    this.eventName = options?.eventName ?? "$model_selection";
-  }
-  async trackSelection(distinctId, properties) {
-    await this.provider.capture({
-      distinctId,
-      event: this.eventName,
-      timestamp: new Date,
-      properties: {
-        $model_id: properties.modelId,
-        $model_provider: properties.providerKey,
-        $model_score: properties.score,
-        $model_dimension: properties.dimension ?? null,
-        $model_reason: properties.reason,
-        $model_alternatives_count: properties.alternativesCount,
-        $model_cost_estimate_input: properties.costEstimateInput ?? null,
-        $model_cost_estimate_output: properties.costEstimateOutput ?? null,
-        $model_selection_duration_ms: properties.selectionDurationMs ?? null
-      }
-    });
-  }
-}
-
-// src/telemetry/posthog-baseline-reader.ts
-class PosthogBaselineReader {
-  reader;
-  eventPrefix;
-  constructor(reader, options = {}) {
-    this.reader = reader;
-    this.eventPrefix = options.eventPrefix ?? "observability";
-  }
-  async readSamples(input) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  properties.operation as operationName,",
-        "  properties.version as version,",
-        "  properties.durationMs as durationMs,",
-        "  properties.success as success,",
-        "  properties.errorCode as errorCode,",
-        "  properties.tenantId as tenantId,",
-        "  properties.traceId as traceId,",
-        "  properties.metadata as metadata,",
-        "  distinct_id as actorId,",
-        "  timestamp as timestamp",
-        "from events",
-        `where ${buildOperationWhereClause(this.eventPrefix, input)}`,
-        "order by timestamp desc",
-        `limit ${input.limit ?? 1000}`
-      ].join(`
-`),
-      values: buildOperationValues(input)
-    });
-    return mapTelemetrySamples(result);
-  }
-  async readAggregatedMetrics(operation, windowDays = 7) {
-    const dateRange = buildWindowRange(windowDays);
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  count() as totalCalls,",
-        "  avg(properties.durationMs) as averageLatencyMs,",
-        "  quantile(0.95)(properties.durationMs) as p95LatencyMs,",
-        "  quantile(0.99)(properties.durationMs) as p99LatencyMs,",
-        "  max(properties.durationMs) as maxLatencyMs,",
-        "  sum(if(properties.success = 1, 1, 0)) as successCount,",
-        "  sum(if(properties.success = 0, 1, 0)) as errorCount",
-        "from events",
-        `where ${buildOperationWhereClause(this.eventPrefix, {
-          operations: [operation],
-          dateRange
-        })}`
-      ].join(`
-`),
-      values: buildOperationValues({
-        operations: [operation],
-        dateRange
-      })
-    });
-    const stats = mapAggregatedMetrics(result, operation, dateRange);
-    if (!stats)
-      return null;
-    const topErrors = await this.readTopErrors(operation, dateRange);
-    return {
-      ...stats,
-      topErrors
-    };
-  }
-  async readOperationSequences(dateRange) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  properties.sequences as sequences",
-        "from events",
-        `where event = {eventName}`,
-        dateRange?.from ? "and timestamp >= {dateFrom}" : "",
-        dateRange?.to ? "and timestamp < {dateTo}" : "",
-        "order by timestamp desc",
-        "limit 50"
-      ].filter(Boolean).join(`
-`),
-      values: {
-        eventName: `${this.eventPrefix}.window`,
-        dateFrom: toIsoString(dateRange?.from),
-        dateTo: toIsoString(dateRange?.to)
-      }
-    });
-    return mergeSequences(result);
-  }
-  async readTopErrors(operation, dateRange) {
-    const result = await this.queryHogQL({
-      query: [
-        "select",
-        "  properties.errorCode as errorCode,",
-        "  count() as errorCount",
-        "from events",
-        `where ${buildOperationWhereClause(this.eventPrefix, {
-          operations: [operation],
-          dateRange
-        })} and properties.success = 0`,
-        "group by errorCode",
-        "order by errorCount desc",
-        "limit 5"
-      ].join(`
-`),
-      values: buildOperationValues({
-        operations: [operation],
-        dateRange
-      })
-    });
-    const rows = mapRows(result);
-    return rows.reduce((acc, row) => {
-      const code = asString(row.errorCode);
-      if (!code)
-        return acc;
-      acc[code] = asNumber(row.errorCount);
-      return acc;
-    }, {});
-  }
-  async queryHogQL(input) {
-    if (!this.reader.queryHogQL) {
-      throw new Error("Analytics reader does not support HogQL queries.");
-    }
-    return this.reader.queryHogQL(input);
-  }
-}
-function buildOperationWhereClause(eventPrefix, input) {
-  const clauses = [`event = '${eventPrefix}.operation'`];
-  if (input.operations?.length) {
-    clauses.push(`(${buildOperationFilters(input.operations)})`);
-  }
-  if (input.dateRange?.from) {
-    clauses.push("timestamp >= {dateFrom}");
-  }
-  if (input.dateRange?.to) {
-    clauses.push("timestamp < {dateTo}");
-  }
-  return clauses.join(" and ");
-}
-function buildOperationValues(input) {
-  const values = {
-    dateFrom: toIsoString(input.dateRange?.from),
-    dateTo: toIsoString(input.dateRange?.to)
-  };
-  input.operations?.forEach((op, index) => {
-    values[`operationName${index}`] = op.name;
-    values[`operationVersion${index}`] = op.version;
-  });
-  return values;
-}
-function buildOperationFilters(operations) {
-  return operations.map((_op, index) => `(properties.operation = {operationName${index}} and properties.version = {operationVersion${index}})`).join(" or ");
-}
-function mapTelemetrySamples(result) {
-  const rows = mapRows(result);
-  return rows.flatMap((row) => {
-    const operationName = asString(row.operationName);
-    const version = asString(row.version);
-    const timestamp = asDate(row.timestamp);
-    if (!operationName || !version || !timestamp) {
-      return [];
-    }
-    return [
-      {
-        operation: { name: operationName, version },
-        durationMs: asNumber(row.durationMs),
-        success: asBoolean(row.success),
-        timestamp,
-        errorCode: asOptionalString(row.errorCode) ?? undefined,
-        tenantId: asOptionalString(row.tenantId) ?? undefined,
-        traceId: asOptionalString(row.traceId) ?? undefined,
-        actorId: asOptionalString(row.actorId) ?? undefined,
-        metadata: isRecord(row.metadata) ? row.metadata : undefined
-      }
-    ];
-  });
-}
-function mapAggregatedMetrics(result, operation, dateRange) {
-  const rows = mapRows(result);
-  const row = rows[0];
-  if (!row)
-    return null;
-  const totalCalls = asNumber(row.totalCalls);
-  if (!totalCalls)
-    return null;
-  const successCount = asNumber(row.successCount);
-  const errorCount = asNumber(row.errorCount);
-  const windowStart = toDate(dateRange.from) ?? new Date;
-  const windowEnd = toDate(dateRange.to) ?? new Date;
-  return {
-    operation,
-    totalCalls,
-    successRate: totalCalls ? successCount / totalCalls : 0,
-    errorRate: totalCalls ? errorCount / totalCalls : 0,
-    averageLatencyMs: asNumber(row.averageLatencyMs),
-    p95LatencyMs: asNumber(row.p95LatencyMs),
-    p99LatencyMs: asNumber(row.p99LatencyMs),
-    maxLatencyMs: asNumber(row.maxLatencyMs),
-    windowStart,
-    windowEnd,
-    topErrors: {}
-  };
-}
-function mergeSequences(result) {
-  const rows = mapRows(result);
-  const merged = new Map;
-  rows.forEach((row) => {
-    const sequences = row.sequences;
-    if (!Array.isArray(sequences))
-      return;
-    sequences.forEach((sequence) => {
-      if (!isRecord(sequence))
-        return;
-      const steps = Array.isArray(sequence.steps) ? sequence.steps.filter((step) => typeof step === "string") : [];
-      if (steps.length === 0)
-        return;
-      const tenantId = typeof sequence.tenantId === "string" ? sequence.tenantId : undefined;
-      const count = typeof sequence.count === "number" && Number.isFinite(sequence.count) ? sequence.count : 0;
-      const key = `${tenantId ?? "global"}:${steps.join(">")}`;
-      const existing = merged.get(key);
-      if (existing) {
-        existing.count += count;
-      } else {
-        merged.set(key, { steps, tenantId, count });
-      }
-    });
-  });
-  return [...merged.values()];
-}
-function mapRows(result) {
-  if (!Array.isArray(result.results) || !Array.isArray(result.columns)) {
-    return [];
-  }
-  const columns = result.columns;
-  return result.results.flatMap((row) => {
-    if (!Array.isArray(row))
-      return [];
-    const record = {};
-    columns.forEach((column, index) => {
-      record[column] = row[index];
-    });
-    return [record];
-  });
-}
-function buildWindowRange(windowDays) {
-  const windowEnd = new Date;
-  const windowStart = new Date(windowEnd.getTime() - windowDays * 24 * 60 * 60 * 1000);
-  return {
-    from: windowStart,
-    to: windowEnd
-  };
-}
-function asString(value) {
-  if (typeof value === "string" && value.trim())
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  return null;
-}
-function asOptionalString(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  return null;
-}
-function asNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed))
-      return parsed;
-  }
-  return 0;
-}
-function asBoolean(value) {
-  if (typeof value === "boolean")
-    return value;
-  if (typeof value === "number")
-    return value !== 0;
-  if (typeof value === "string")
-    return value.toLowerCase() === "true";
-  return false;
-}
-function asDate(value) {
-  if (value instanceof Date)
-    return value;
-  if (typeof value === "string" || typeof value === "number") {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime()))
-      return date;
-  }
-  return null;
-}
-function toIsoString(value) {
-  if (!value)
-    return;
-  return typeof value === "string" ? value : value.toISOString();
-}
-function toDate(value) {
-  if (!value)
-    return null;
-  return value instanceof Date ? value : new Date(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/telemetry/posthog-telemetry.ts
-class PosthogTelemetryProvider {
-  provider;
-  eventPrefix;
-  includeMetadata;
-  constructor(provider, options = {}) {
-    this.provider = provider;
-    this.eventPrefix = options.eventPrefix ?? "observability";
-    this.includeMetadata = options.includeMetadata ?? false;
-  }
-  async captureSample(sample) {
-    await this.provider.capture({
-      distinctId: sample.actorId ?? sample.tenantId ?? "unknown",
-      event: `${this.eventPrefix}.operation`,
-      timestamp: sample.timestamp,
-      properties: {
-        operation: sample.operation.name,
-        version: sample.operation.version,
-        durationMs: sample.durationMs,
-        success: sample.success,
-        errorCode: sample.errorCode ?? null,
-        tenantId: sample.tenantId ?? null,
-        traceId: sample.traceId ?? null,
-        ...this.includeMetadata && sample.metadata ? { metadata: sample.metadata } : {}
-      }
-    });
-  }
-  async captureSnapshot(snapshot) {
-    await this.provider.capture({
-      distinctId: "system",
-      event: `${this.eventPrefix}.window`,
-      timestamp: snapshot.windowEnd ?? new Date,
-      properties: {
-        sampleCount: snapshot.sampleCount,
-        metricsCount: snapshot.metrics.length,
-        sequencesCount: snapshot.sequences.length,
-        windowStart: snapshot.windowStart?.toISOString() ?? null,
-        windowEnd: snapshot.windowEnd?.toISOString() ?? null,
-        ...this.includeMetadata ? {
-          metrics: snapshot.metrics.map((metric) => ({
-            operation: metric.operation.name,
-            version: metric.operation.version,
-            totalCalls: metric.totalCalls,
-            successRate: metric.successRate,
-            errorRate: metric.errorRate,
-            averageLatencyMs: metric.averageLatencyMs,
-            p95LatencyMs: metric.p95LatencyMs,
-            p99LatencyMs: metric.p99LatencyMs,
-            maxLatencyMs: metric.maxLatencyMs,
-            topErrors: metric.topErrors
-          })),
-          sequences: snapshot.sequences
-        } : {}
-      }
-    });
-  }
-}
-
-// src/tracing/core.ts
-import {
-  SpanStatusCode,
-  trace as trace2
-} from "@opentelemetry/api";
-var DEFAULT_TRACER_NAME = "@contractspec/lib.observability";
-function getTracer(name = DEFAULT_TRACER_NAME) {
-  return trace2.getTracer(name);
-}
-async function traceAsync(name, fn, tracerName) {
-  const tracer = getTracer(tracerName);
-  return tracer.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) {
-  const tracer = getTracer(tracerName);
-  return tracer.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();
-    }
-  });
-}
-
-// src/tracing/model-selection.span.ts
-async function traceModelSelection(fn, input) {
-  const startMs = performance.now();
-  return traceAsync("model.selection", async (span) => {
-    const result = await fn();
-    const durationMs = performance.now() - startMs;
-    span.setAttribute("model.selected", input.modelId);
-    span.setAttribute("model.provider", input.providerKey);
-    span.setAttribute("model.score", input.score);
-    span.setAttribute("model.alternatives_count", input.alternativesCount);
-    span.setAttribute("model.selection_duration_ms", durationMs);
-    span.setAttribute("model.reason", input.reason);
-    if (input.dimension) {
-      span.setAttribute("model.dimension", input.dimension);
-    }
-    if (input.constraints) {
-      span.setAttribute("model.constraints", JSON.stringify(input.constraints));
-    }
-    return result;
-  });
-}
-// src/tracing/middleware.ts
-function createTracingMiddleware(options = {}) {
-  return async (req, next) => {
-    const method = req.method;
-    const url = new URL(req.url);
-    const path = 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) / 1000;
-        standardMetrics.httpDuration.record(duration, {
-          method,
-          path,
-          status: response.status.toString()
-        });
-        emitTelemetrySample({
-          req,
-          res: response,
-          span,
-          success: true,
-          durationMs: duration * 1000,
-          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: new Date,
-    errorCode: !success && error instanceof Error ? error.name : success ? undefined : "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);
-}
-export {
-  traceSync,
-  traceModelSelection,
-  traceAsync,
-  standardMetrics,
-  logger,
-  getTracer,
-  getMeter,
-  createUpDownCounter,
-  createTracingMiddleware,
-  createHistogram,
-  createCounter,
-  RootCauseAnalyzer,
-  PosthogTelemetryProvider,
-  PosthogBaselineReader,
-  ModelSelectionTelemetry,
-  Logger,
-  LifecycleKpiPipeline,
-  IntentDetector,
-  IntentAggregator,
-  EvolutionPipeline,
-  BaselineCalculator,
-  AnomalyDetector,
-  AlertManager
-};
+class q{options;cooldownMs;lastAlert=new Map;constructor(e){this.options=e;this.cooldownMs=e.cooldownMs??60000}async notify(e,t){let r=`${e.type}:${t.culprit?.id??"none"}`,s=Date.now(),n=this.lastAlert.get(r)??0;if(s-n<this.cooldownMs)return;await this.options.transport({signal:e,analysis:t}),this.lastAlert.set(r,s)}}class y{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,s=t===0?1:this.alpha;return this.snapshot={latencyP99:this.mix(this.snapshot.latencyP99,e.latencyP99,s),latencyP95:this.mix(this.snapshot.latencyP95,e.latencyP95,s),errorRate:this.mix(this.snapshot.errorRate,e.errorRate,s),throughput:this.mix(this.snapshot.throughput,e.throughput,s),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 O{baseline;thresholds={errorRateDelta:0.5,latencyDelta:0.35,throughputDrop:0.4,minSamples:10};constructor(e={}){this.baseline=new y,this.thresholds={...this.thresholds,...e}}evaluate(e){let t=this.baseline.update(e);if(t.sampleCount<this.thresholds.minSamples)return[];let r=[],s=this.relativeDelta(e.errorRate,t.errorRate);if(s>this.thresholds.errorRateDelta)r.push({type:"error_rate_spike",delta:s,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}}class k{lookbackMs;constructor(e=900000){this.lookbackMs=e}analyze(e,t){let r=new Date(e.point.timestamp.getTime()-this.lookbackMs),s=t.filter((a)=>a.deployedAt>=r).sort((a,l)=>l.deployedAt.getTime()-a.deployedAt.getTime()),n=[],o;if(s.length>0){if(o=s[0],o)n.push(`Closest deployment ${o.id} (${o.operation}) at ${o.deployedAt.toISOString()}`)}else n.push("No deployments found within lookback window.");if(e.type==="latency_regression")n.push("Verify recent schema changes and external dependency latency.");if(e.type==="error_rate_spike")n.push("Check SLO monitor for correlated incidents.");return{signal:e,culprit:o,notes:n}}}class f{windowMs;sequenceSampleSize;samples=[];constructor(e={}){this.windowMs=e.windowMs??900000,this.sequenceSampleSize=e.sequenceSampleSize??1000}add(e){this.samples.push(e)}flush(e=new Date){let t=e.getTime()-this.windowMs,r=this.samples.filter((a)=>a.timestamp.getTime()>=t);this.samples.length=0;let s=this.aggregateMetrics(r),n=this.buildSequences(r),o=r.map((a)=>a.timestamp.getTime());return{metrics:s,sequences:n,sampleCount:r.length,windowStart:o.length?new Date(Math.min(...o)):void 0,windowEnd:o.length?new Date(Math.max(...o)):void 0}}aggregateMetrics(e){if(!e.length)return[];let t=new Map;for(let r of e){let s=`${r.operation.name}.v${r.operation.version}`,n=t.get(s)??[];n.push(r),t.set(s,n)}return[...t.values()].map((r)=>{let s=r[0];if(!s)throw Error("Empty group in aggregation");let n=r.map((i)=>i.durationMs).sort((i,p)=>i-p),o=r.filter((i)=>!i.success),a=r.length,l=o.reduce((i,p)=>{if(!p.errorCode)return i;return i[p.errorCode]=(i[p.errorCode]??0)+1,i},{}),c=r.map((i)=>i.timestamp.getTime());return{operation:s.operation,totalCalls:a,successRate:(a-o.length)/a,errorRate:o.length/a,averageLatencyMs:n.reduce((i,p)=>i+p,0)/a,p95LatencyMs:_(n,0.95),p99LatencyMs:_(n,0.99),maxLatencyMs:Math.max(...n),windowStart:new Date(Math.min(...c)),windowEnd:new Date(Math.max(...c)),topErrors:l}})}buildSequences(e){let t=new Map;for(let s of e.slice(-this.sequenceSampleSize)){if(!s.traceId)continue;let n=t.get(s.traceId)??[];n.push(s),t.set(s.traceId,n)}let r={};for(let s of t.values()){let n=s.sort((c,i)=>c.timestamp.getTime()-i.timestamp.getTime()),o=n.map((c)=>c.operation.name);if(o.length<2)continue;let a=`${o.join(">")}@${n[0]?.tenantId??"global"}`,l=r[a];if(l)l.count+=1;else r[a]={steps:o,tenantId:n[0]?.tenantId,count:1}}return Object.values(r).sort((s,n)=>n.count-s.count)}}function _(e,t){if(!e.length)return 0;if(e.length===1)return e[0]??0;let r=Math.min(e.length-1,Math.floor(t*e.length));return e[r]??0}import{randomUUID as w}from"crypto";var v={errorRateThreshold:0.05,latencyP99ThresholdMs:750,throughputDropThreshold:0.3,minSequenceLength:3};class S{options;constructor(e={}){this.options={errorRateThreshold:e.errorRateThreshold??v.errorRateThreshold,latencyP99ThresholdMs:e.latencyP99ThresholdMs??v.latencyP99ThresholdMs,throughputDropThreshold:e.throughputDropThreshold??v.throughputDropThreshold,minSequenceLength:e.minSequenceLength??v.minSequenceLength}}detectFromMetrics(e,t){let r=[],s=new Map((t??[]).map((n)=>[`${n.operation.name}.v${n.operation.version}`,n]));for(let n of e){if(n.errorRate>=this.options.errorRateThreshold){r.push({id:w(),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:w(),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 o=s.get(`${n.operation.name}.v${n.operation.version}`);if(o){let a=(o.totalCalls-n.totalCalls)/Math.max(o.totalCalls,1);if(a>=this.options.throughputDropThreshold)r.push({id:w(),type:"throughput-drop",operation:n.operation,confidence:Math.min(1,a/this.options.throughputDropThreshold),description:`Throughput dropped ${(a*100).toFixed(1)}% vs baseline`,metadata:{baselineCalls:o.totalCalls,currentCalls:n.totalCalls},evidence:[{type:"metric",description:"throughput-drop",data:{baselineCalls:o.totalCalls,currentCalls:n.totalCalls}}]})}}return r}detectSequentialIntents(e){let t=[];for(let r of e){if(r.steps.length<this.options.minSequenceLength)continue;let s=r.steps.join(" → ");t.push({id:w(),type:"missing-workflow-step",confidence:0.6,description:`Repeated workflow detected: ${s}`,metadata:{steps:r.steps,tenantId:r.tenantId,occurrences:r.count},evidence:[{type:"sequence",description:"sequential-calls",data:{steps:r.steps,count:r.count}}]})}return t}}import{context as K,trace as V}from"@opentelemetry/api";class I{serviceName;constructor(e){this.serviceName=e}log(e,t,r={}){let s=V.getSpan(K.active()),n=s?.spanContext().traceId,o=s?.spanContext().spanId,a={timestamp:new Date().toISOString(),service:this.serviceName,level:e,message:t,traceId:n,spanId:o,...r};console.log(JSON.stringify(a))}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)}}var J=new I(process.env.OTEL_SERVICE_NAME||"unknown-service");import{metrics as G}from"@opentelemetry/api";var X="@contractspec/lib.observability";function M(e=X){return G.getMeter(e)}function m(e,t,r){return M(r).createCounter(e,{description:t})}function D(e,t,r){return M(r).createUpDownCounter(e,{description:t})}function g(e,t,r){return M(r).createHistogram(e,{description:t})}var h={httpRequests:m("http_requests_total","Total HTTP requests"),httpDuration:g("http_request_duration_seconds","HTTP request duration"),operationErrors:m("operation_errors_total","Total operation errors"),workflowDuration:g("workflow_duration_seconds","Workflow execution duration")};import{EventEmitter as Y}from"node:events";class ${detector;aggregator;emitter;onIntent;onSnapshot;timer;previousMetrics;constructor(e={}){this.detector=e.detector??new S,this.aggregator=e.aggregator??new f,this.emitter=e.emitter??new Y,this.onIntent=e.onIntent,this.onSnapshot=e.onSnapshot}ingest(e){this.aggregator.add(e)}on(e){this.emitter.on("event",e)}start(e=300000){this.stop(),this.timer=setInterval(()=>{this.run()},e)}stop(){if(this.timer)clearInterval(this.timer),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);if(!e.sampleCount)return;let t=this.detector.detectFromMetrics(e.metrics,this.previousMetrics),r=this.detector.detectSequentialIntents(e.sequences);this.previousMetrics=e.metrics;let s=[...t,...r];for(let n of s){if(this.onIntent)await this.onIntent(n);this.emit({type:"intent.detected",payload:n})}}emit(e){this.emitter.emit("event",e)}}import{EventEmitter as Z}from"node:events";import{getStageLabel as x}from"@contractspec/lib.lifecycle";class N{assessmentCounter;confidenceHistogram;stageUpDownCounter;emitter;lowConfidenceThreshold;currentStageByTenant=new Map;constructor(e={}){let t=e.meterName??"@contractspec/lib.lifecycle-kpi";this.assessmentCounter=m("lifecycle_assessments_total","Total lifecycle assessments",t),this.confidenceHistogram=g("lifecycle_assessment_confidence","Lifecycle assessment confidence distribution",t),this.stageUpDownCounter=D("lifecycle_stage_tenants","Current tenants per lifecycle stage",t),this.emitter=e.emitter??new Z,this.lowConfidenceThreshold=e.lowConfidenceThreshold??0.4}recordAssessment(e,t){let s={stage:x(e.stage),tenantId:t};if(this.assessmentCounter.add(1,s),this.confidenceHistogram.record(e.confidence,s),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 r=this.currentStageByTenant.get(t);if(r===e)return;if(r!==void 0)this.stageUpDownCounter.add(-1,{stage:x(r),tenantId:t});this.stageUpDownCounter.add(1,{stage:x(e),tenantId:t}),this.currentStageByTenant.set(t,e),this.emitter.emit("event",{type:"stage.changed",payload:{tenantId:t,previousStage:r,nextStage:e}})}}class H{provider;eventName;constructor(e,t){this.provider=e,this.eventName=t?.eventName??"$model_selection"}async trackSelection(e,t){await this.provider.capture({distinctId:e,event:this.eventName,timestamp:new Date,properties:{$model_id:t.modelId,$model_provider:t.providerKey,$model_score:t.score,$model_dimension:t.dimension??null,$model_reason:t.reason,$model_alternatives_count:t.alternativesCount,$model_cost_estimate_input:t.costEstimateInput??null,$model_cost_estimate_output:t.costEstimateOutput??null,$model_selection_duration_ms:t.selectionDurationMs??null}})}}class F{reader;eventPrefix;constructor(e,t={}){this.reader=e,this.eventPrefix=t.eventPrefix??"observability"}async readSamples(e){let t=await this.queryHogQL({query:["select","  properties.operation as operationName,","  properties.version as version,","  properties.durationMs as durationMs,","  properties.success as success,","  properties.errorCode as errorCode,","  properties.tenantId as tenantId,","  properties.traceId as traceId,","  properties.metadata as metadata,","  distinct_id as actorId,","  timestamp as timestamp","from events",`where ${L(this.eventPrefix,e)}`,"order by timestamp desc",`limit ${e.limit??1000}`].join(`
+`),values:E(e)});return te(t)}async readAggregatedMetrics(e,t=7){let r=oe(t),s=await this.queryHogQL({query:["select","  count() as totalCalls,","  avg(properties.durationMs) as averageLatencyMs,","  quantile(0.95)(properties.durationMs) as p95LatencyMs,","  quantile(0.99)(properties.durationMs) as p99LatencyMs,","  max(properties.durationMs) as maxLatencyMs,","  sum(if(properties.success = 1, 1, 0)) as successCount,","  sum(if(properties.success = 0, 1, 0)) as errorCount","from events",`where ${L(this.eventPrefix,{operations:[e],dateRange:r})}`].join(`
+`),values:E({operations:[e],dateRange:r})}),n=re(s,e,r);if(!n)return null;let o=await this.readTopErrors(e,r);return{...n,topErrors:o}}async readOperationSequences(e){let t=await this.queryHogQL({query:["select","  properties.sequences as sequences","from events","where event = {eventName}",e?.from?"and timestamp >= {dateFrom}":"",e?.to?"and timestamp < {dateTo}":"","order by timestamp desc","limit 50"].filter(Boolean).join(`
+`),values:{eventName:`${this.eventPrefix}.window`,dateFrom:R(e?.from),dateTo:R(e?.to)}});return ne(t)}async readTopErrors(e,t){let r=await this.queryHogQL({query:["select","  properties.errorCode as errorCode,","  count() as errorCount","from events",`where ${L(this.eventPrefix,{operations:[e],dateRange:t})} and properties.success = 0`,"group by errorCode","order by errorCount desc","limit 5"].join(`
+`),values:E({operations:[e],dateRange:t})});return T(r).reduce((n,o)=>{let a=P(o.errorCode);if(!a)return n;return n[a]=u(o.errorCount),n},{})}async queryHogQL(e){if(!this.reader.queryHogQL)throw Error("Analytics reader does not support HogQL queries.");return this.reader.queryHogQL(e)}}function L(e,t){let r=[`event = '${e}.operation'`];if(t.operations?.length)r.push(`(${ee(t.operations)})`);if(t.dateRange?.from)r.push("timestamp >= {dateFrom}");if(t.dateRange?.to)r.push("timestamp < {dateTo}");return r.join(" and ")}function E(e){let t={dateFrom:R(e.dateRange?.from),dateTo:R(e.dateRange?.to)};return e.operations?.forEach((r,s)=>{t[`operationName${s}`]=r.name,t[`operationVersion${s}`]=r.version}),t}function ee(e){return e.map((t,r)=>`(properties.operation = {operationName${r}} and properties.version = {operationVersion${r}})`).join(" or ")}function te(e){return T(e).flatMap((r)=>{let s=P(r.operationName),n=P(r.version),o=ae(r.timestamp);if(!s||!n||!o)return[];return[{operation:{name:s,version:n},durationMs:u(r.durationMs),success:se(r.success),timestamp:o,errorCode:b(r.errorCode)??void 0,tenantId:b(r.tenantId)??void 0,traceId:b(r.traceId)??void 0,actorId:b(r.actorId)??void 0,metadata:B(r.metadata)?r.metadata:void 0}]})}function re(e,t,r){let n=T(e)[0];if(!n)return null;let o=u(n.totalCalls);if(!o)return null;let a=u(n.successCount),l=u(n.errorCount),c=U(r.from)??new Date,i=U(r.to)??new Date;return{operation:t,totalCalls:o,successRate:o?a/o:0,errorRate:o?l/o:0,averageLatencyMs:u(n.averageLatencyMs),p95LatencyMs:u(n.p95LatencyMs),p99LatencyMs:u(n.p99LatencyMs),maxLatencyMs:u(n.maxLatencyMs),windowStart:c,windowEnd:i,topErrors:{}}}function ne(e){let t=T(e),r=new Map;return t.forEach((s)=>{let n=s.sequences;if(!Array.isArray(n))return;n.forEach((o)=>{if(!B(o))return;let a=Array.isArray(o.steps)?o.steps.filter((W)=>typeof W==="string"):[];if(a.length===0)return;let l=typeof o.tenantId==="string"?o.tenantId:void 0,c=typeof o.count==="number"&&Number.isFinite(o.count)?o.count:0,i=`${l??"global"}:${a.join(">")}`,p=r.get(i);if(p)p.count+=c;else r.set(i,{steps:a,tenantId:l,count:c})})}),[...r.values()]}function T(e){if(!Array.isArray(e.results)||!Array.isArray(e.columns))return[];let t=e.columns;return e.results.flatMap((r)=>{if(!Array.isArray(r))return[];let s={};return t.forEach((n,o)=>{s[n]=r[o]}),[s]})}function oe(e){let t=new Date;return{from:new Date(t.getTime()-e*24*60*60*1000),to:t}}function P(e){if(typeof e==="string"&&e.trim())return e;if(typeof e==="number")return String(e);return null}function b(e){if(typeof e==="string")return e;if(typeof e==="number")return String(e);return null}function u(e){if(typeof e==="number"&&Number.isFinite(e))return e;if(typeof e==="string"&&e.trim()){let t=Number(e);if(Number.isFinite(t))return t}return 0}function se(e){if(typeof e==="boolean")return e;if(typeof e==="number")return e!==0;if(typeof e==="string")return e.toLowerCase()==="true";return!1}function ae(e){if(e instanceof Date)return e;if(typeof e==="string"||typeof e==="number"){let t=new Date(e);if(!Number.isNaN(t.getTime()))return t}return null}function R(e){if(!e)return;return typeof e==="string"?e:e.toISOString()}function U(e){if(!e)return null;return e instanceof Date?e:new Date(e)}function B(e){return typeof e==="object"&&e!==null}class Q{provider;eventPrefix;includeMetadata;constructor(e,t={}){this.provider=e,this.eventPrefix=t.eventPrefix??"observability",this.includeMetadata=t.includeMetadata??!1}async captureSample(e){await this.provider.capture({distinctId:e.actorId??e.tenantId??"unknown",event:`${this.eventPrefix}.operation`,timestamp:e.timestamp,properties:{operation:e.operation.name,version:e.operation.version,durationMs:e.durationMs,success:e.success,errorCode:e.errorCode??null,tenantId:e.tenantId??null,traceId:e.traceId??null,...this.includeMetadata&&e.metadata?{metadata:e.metadata}:{}}})}async captureSnapshot(e){await this.provider.capture({distinctId:"system",event:`${this.eventPrefix}.window`,timestamp:e.windowEnd??new Date,properties:{sampleCount:e.sampleCount,metricsCount:e.metrics.length,sequencesCount:e.sequences.length,windowStart:e.windowStart?.toISOString()??null,windowEnd:e.windowEnd?.toISOString()??null,...this.includeMetadata?{metrics:e.metrics.map((t)=>({operation:t.operation.name,version:t.operation.version,totalCalls:t.totalCalls,successRate:t.successRate,errorRate:t.errorRate,averageLatencyMs:t.averageLatencyMs,p95LatencyMs:t.p95LatencyMs,p99LatencyMs:t.p99LatencyMs,maxLatencyMs:t.maxLatencyMs,topErrors:t.topErrors})),sequences:e.sequences}:{}}})}}import{SpanStatusCode as C,trace as ie}from"@opentelemetry/api";var ce="@contractspec/lib.observability";function A(e=ce){return ie.getTracer(e)}async function d(e,t,r){return A(r).startActiveSpan(e,async(n)=>{try{let o=await t(n);return n.setStatus({code:C.OK}),o}catch(o){throw n.recordException(o),n.setStatus({code:C.ERROR,message:o instanceof Error?o.message:String(o)}),o}finally{n.end()}})}function j(e,t,r){return A(r).startActiveSpan(e,(n)=>{try{let o=t(n);return n.setStatus({code:C.OK}),o}catch(o){throw n.recordException(o),n.setStatus({code:C.ERROR,message:o instanceof Error?o.message:String(o)}),o}finally{n.end()}})}async function le(e,t){let r=performance.now();return d("model.selection",async(s)=>{let n=await e(),o=performance.now()-r;if(s.setAttribute("model.selected",t.modelId),s.setAttribute("model.provider",t.providerKey),s.setAttribute("model.score",t.score),s.setAttribute("model.alternatives_count",t.alternativesCount),s.setAttribute("model.selection_duration_ms",o),s.setAttribute("model.reason",t.reason),t.dimension)s.setAttribute("model.dimension",t.dimension);if(t.constraints)s.setAttribute("model.constraints",JSON.stringify(t.constraints));return n})}function pe(e={}){return async(t,r)=>{let s=t.method,o=new URL(t.url).pathname;h.httpRequests.add(1,{method:s,path:o});let a=performance.now();return d(`HTTP ${s} ${o}`,async(l)=>{l.setAttribute("http.method",s),l.setAttribute("http.url",t.url);try{let c=await r();l.setAttribute("http.status_code",c.status);let i=(performance.now()-a)/1000;return h.httpDuration.record(i,{method:s,path:o,status:c.status.toString()}),z({req:t,res:c,span:l,success:!0,durationMs:i*1000,options:e}),c}catch(c){throw h.operationErrors.add(1,{method:s,path:o}),z({req:t,span:l,success:!1,durationMs:performance.now()-a,error:c,options:e}),c}})}}function z({req:e,res:t,span:r,success:s,durationMs:n,error:o,options:a}){if(!a.onSample||!a.resolveOperation)return;let l=a.resolveOperation({req:e,res:t});if(!l)return;let c={operation:l,durationMs:n,success:s,timestamp:new Date,errorCode:!s&&o instanceof Error?o.name:s?void 0:"unknown",tenantId:a.tenantResolver?.(e),actorId:a.actorResolver?.(e),traceId:r.spanContext().traceId,metadata:{method:e.method,path:new URL(e.url).pathname,status:t?.status}};a.onSample(c)}export{j as traceSync,le as traceModelSelection,d as traceAsync,h as standardMetrics,J as logger,A as getTracer,M as getMeter,D as createUpDownCounter,pe as createTracingMiddleware,g as createHistogram,m as createCounter,k as RootCauseAnalyzer,Q as PosthogTelemetryProvider,F as PosthogBaselineReader,H as ModelSelectionTelemetry,I as Logger,N as LifecycleKpiPipeline,S as IntentDetector,f as IntentAggregator,$ as EvolutionPipeline,y as BaselineCalculator,O as AnomalyDetector,q as AlertManager};