@lssm/lib.observability 0.2.2 → 0.4.0

package/src/pipeline/lifecycle-pipeline.ts

@@ -1,105 +0,0 @@
-import { EventEmitter } from 'node:events';
-import type { LifecycleAssessment, LifecycleStage } from '@lssm/lib.lifecycle';
-import { getStageLabel } from '@lssm/lib.lifecycle';
-import {
-  createCounter,
-  createHistogram,
-  createUpDownCounter,
-} from '../metrics';
-
-export 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 };
-    };
-
-export interface LifecycleKpiPipelineOptions {
-  meterName?: string;
-  emitter?: EventEmitter;
-  lowConfidenceThreshold?: number;
-}
-
-export class LifecycleKpiPipeline {
-  private readonly assessmentCounter;
-  private readonly confidenceHistogram;
-  private readonly stageUpDownCounter;
-  private readonly emitter: EventEmitter;
-  private readonly lowConfidenceThreshold: number;
-  private readonly currentStageByTenant = new Map<string, LifecycleStage>();
-
-  constructor(options: LifecycleKpiPipelineOptions = {}) {
-    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 ?? 0.4;
-  }
-
-  recordAssessment(assessment: LifecycleAssessment, tenantId?: string) {
-    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 },
-    } satisfies LifecyclePipelineEvent);
-
-    if (assessment.confidence < this.lowConfidenceThreshold) {
-      this.emitter.emit('event', {
-        type: 'confidence.low',
-        payload: { tenantId, confidence: assessment.confidence },
-      } satisfies LifecyclePipelineEvent);
-    }
-  }
-
-  on(listener: (event: LifecyclePipelineEvent) => void) {
-    this.emitter.on('event', listener);
-  }
-
-  private ensureStageCounters(stage: LifecycleStage, tenantId?: string) {
-    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 },
-    } satisfies LifecyclePipelineEvent);
-  }
-}

package/src/tracing/index.ts

@@ -1,61 +0,0 @@
-import {
-  trace,
-  context,
-  SpanStatusCode,
-  type Span,
-  type Tracer,
-} from '@opentelemetry/api';
-
-const DEFAULT_TRACER_NAME = '@lssm/lib.observability';
-
-export function getTracer(name: string = DEFAULT_TRACER_NAME): Tracer {
-  return trace.getTracer(name);
-}
-
-export async function traceAsync<T>(
-  name: string,
-  fn: (span: Span) => Promise<T>,
-  tracerName?: string
-): Promise<T> {
-  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 as Error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-
-export function traceSync<T>(
-  name: string,
-  fn: (span: Span) => T,
-  tracerName?: string
-): T {
-  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 as Error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error),
-      });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}

package/src/tracing/middleware.ts

@@ -1,111 +0,0 @@
-import type { Span } from '@opentelemetry/api';
-import { traceAsync } from './index';
-import { standardMetrics } from '../metrics';
-import type { TelemetrySample } from '../intent/aggregator';
-
-export 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;
-}
-
-export function createTracingMiddleware(
-  options: TracingMiddlewareOptions = {}
-) {
-  return async (req: Request, next: () => Promise<Response>) => {
-    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;
-      }
-    });
-  };
-}
-
-interface EmitTelemetryArgs {
-  req: Request;
-  res?: Response;
-  span: Span;
-  success: boolean;
-  durationMs: number;
-  error?: unknown;
-  options: TracingMiddlewareOptions;
-}
-
-function emitTelemetrySample({
-  req,
-  res,
-  span,
-  success,
-  durationMs,
-  error,
-  options,
-}: EmitTelemetryArgs) {
-  if (!options.onSample || !options.resolveOperation) return;
-  const operation = options.resolveOperation({ req, res });
-  if (!operation) return;
-  const sample: TelemetrySample = {
-    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);
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "@lssm/tool.typescript/react-library.json",
-  "include": ["src"],
-  "exclude": ["node_modules"],
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist"
-  }
-}
-
-
-
-
-
-
-