@celerity-sdk/telemetry 0.2.0

package/dist/index.cjs

@@ -0,0 +1,594 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CelerityLoggerImpl: () => CelerityLoggerImpl,
+  ContextAwareLogger: () => ContextAwareLogger,
+  LOGGER_TOKEN: () => LOGGER_TOKEN,
+  NOOP_SPAN: () => NOOP_SPAN,
+  NoopTracer: () => NoopTracer,
+  OTelSpan: () => OTelSpan,
+  OTelTracer: () => OTelTracer,
+  TRACER_TOKEN: () => TRACER_TOKEN,
+  TelemetryLayer: () => TelemetryLayer,
+  createLogger: () => createLogger,
+  extractTraceContext: () => extractTraceContext,
+  extractUserId: () => import_common2.extractUserId,
+  getLogger: () => getLogger,
+  getRequestLogger: () => getRequestLogger,
+  getTracer: () => getTracer,
+  readTelemetryEnv: () => readTelemetryEnv
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/telemetry-layer.ts
+var import_debug3 = __toESM(require("debug"), 1);
+var import_api3 = require("@opentelemetry/api");
+var import_common = require("@celerity-sdk/common");
+
+// src/env.ts
+var VALID_LOG_LEVELS = /* @__PURE__ */ new Set([
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+var VALID_LOG_FORMATS = /* @__PURE__ */ new Set([
+  "json",
+  "human",
+  "auto"
+]);
+function readTelemetryEnv() {
+  const rawLevel = process.env.CELERITY_LOG_LEVEL;
+  const rawFormat = process.env.CELERITY_LOG_FORMAT;
+  return {
+    tracingEnabled: process.env.CELERITY_TELEMETRY_ENABLED === "true",
+    otlpEndpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? process.env.CELERITY_TRACE_OTLP_COLLECTOR_ENDPOINT ?? "http://otelcollector:4317",
+    serviceName: process.env.OTEL_SERVICE_NAME ?? "celerity-app",
+    serviceVersion: process.env.OTEL_SERVICE_VERSION ?? "0.0.0",
+    logLevel: rawLevel && VALID_LOG_LEVELS.has(rawLevel) ? rawLevel : "info",
+    logFormat: rawFormat && VALID_LOG_FORMATS.has(rawFormat) ? rawFormat : "auto",
+    logFilePath: process.env.CELERITY_LOG_FILE_PATH ?? null
+  };
+}
+__name(readTelemetryEnv, "readTelemetryEnv");
+
+// src/init.ts
+var import_debug2 = __toESM(require("debug"), 1);
+var import_sdk_node = require("@opentelemetry/sdk-node");
+var import_resources = require("@opentelemetry/resources");
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var import_exporter_trace_otlp_grpc = require("@opentelemetry/exporter-trace-otlp-grpc");
+var import_exporter_logs_otlp_grpc = require("@opentelemetry/exporter-logs-otlp-grpc");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_core = require("@opentelemetry/core");
+var import_propagator_aws_xray = require("@opentelemetry/propagator-aws-xray");
+var import_id_generator_aws_xray = require("@opentelemetry/id-generator-aws-xray");
+
+// src/instrumentations.ts
+var import_debug = __toESM(require("debug"), 1);
+var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
+var import_instrumentation_undici = require("@opentelemetry/instrumentation-undici");
+var debug = (0, import_debug.default)("celerity:telemetry");
+async function buildInstrumentations() {
+  const instrumentations = [
+    new import_instrumentation_http.HttpInstrumentation(),
+    new import_instrumentation_undici.UndiciInstrumentation()
+  ];
+  const optionalPackages = [
+    "@opentelemetry/instrumentation-aws-sdk",
+    "@opentelemetry/instrumentation-ioredis",
+    "@opentelemetry/instrumentation-pg",
+    "@opentelemetry/instrumentation-mysql2"
+  ];
+  for (const name of optionalPackages) {
+    try {
+      const pkg = name;
+      const mod = await import(pkg);
+      const InstrumentationClass = findInstrumentationExport(mod);
+      if (InstrumentationClass) {
+        debug("instrumentation: loaded %s", name);
+        instrumentations.push(new InstrumentationClass());
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ERR_MODULE_NOT_FOUND" && code !== "MODULE_NOT_FOUND") {
+        debug("instrumentation: failed to load %s: %O", name, err);
+      }
+    }
+  }
+  return instrumentations;
+}
+__name(buildInstrumentations, "buildInstrumentations");
+function findInstrumentationExport(mod) {
+  for (const value of Object.values(mod)) {
+    if (typeof value === "function" && value.prototype && "enable" in value.prototype) {
+      return value;
+    }
+  }
+  return null;
+}
+__name(findInstrumentationExport, "findInstrumentationExport");
+
+// src/init.ts
+var debug2 = (0, import_debug2.default)("celerity:telemetry");
+var initialized = false;
+var sdk = null;
+async function initTelemetry() {
+  if (initialized) {
+    debug2("initTelemetry: already initialized, skipping");
+    return;
+  }
+  const config = readTelemetryEnv();
+  if (!config.tracingEnabled) {
+    debug2("initTelemetry: tracing disabled, skipping");
+    return;
+  }
+  const platform = process.env.CELERITY_RUNTIME_PLATFORM ?? "local";
+  const isAws = platform === "aws";
+  debug2("initTelemetry: platform=%s endpoint=%s service=%s", platform, config.otlpEndpoint, config.serviceName);
+  const instrumentations = await buildInstrumentations();
+  sdk = new import_sdk_node.NodeSDK({
+    resource: (0, import_resources.resourceFromAttributes)({
+      [import_semantic_conventions.ATTR_SERVICE_NAME]: config.serviceName,
+      [import_semantic_conventions.ATTR_SERVICE_VERSION]: config.serviceVersion
+    }),
+    traceExporter: new import_exporter_trace_otlp_grpc.OTLPTraceExporter({
+      url: config.otlpEndpoint
+    }),
+    logRecordProcessors: [
+      new import_sdk_logs.BatchLogRecordProcessor(new import_exporter_logs_otlp_grpc.OTLPLogExporter({
+        url: config.otlpEndpoint
+      }))
+    ],
+    textMapPropagator: new import_core.CompositePropagator({
+      propagators: [
+        new import_core.W3CTraceContextPropagator(),
+        new import_propagator_aws_xray.AWSXRayPropagator()
+      ]
+    }),
+    ...isAws ? {
+      idGenerator: new import_id_generator_aws_xray.AWSXRayIdGenerator()
+    } : {},
+    instrumentations
+  });
+  sdk.start();
+  initialized = true;
+  debug2("initTelemetry: SDK started");
+}
+__name(initTelemetry, "initTelemetry");
+async function shutdownTelemetry() {
+  if (sdk) {
+    debug2("shutdownTelemetry: shutting down SDK");
+    await sdk.shutdown();
+    sdk = null;
+    initialized = false;
+  }
+}
+__name(shutdownTelemetry, "shutdownTelemetry");
+
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+
+// src/otel-transport.ts
+var import_node_stream = require("stream");
+var import_api_logs = require("@opentelemetry/api-logs");
+var LEVEL_MAP = {
+  10: import_api_logs.SeverityNumber.TRACE,
+  20: import_api_logs.SeverityNumber.DEBUG,
+  30: import_api_logs.SeverityNumber.INFO,
+  40: import_api_logs.SeverityNumber.WARN,
+  50: import_api_logs.SeverityNumber.ERROR,
+  60: import_api_logs.SeverityNumber.FATAL
+};
+function createOTelStream() {
+  const otelLogger = import_api_logs.logs.getLogger("celerity");
+  return new import_node_stream.Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const obj = JSON.parse(typeof chunk === "string" ? chunk : chunk.toString());
+        const { level, msg, name, ...rest } = obj;
+        delete rest.time;
+        const attributes = {};
+        if (typeof name === "string") attributes["logger.name"] = name;
+        for (const [key, val] of Object.entries(rest)) {
+          if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+            attributes[key] = val;
+          }
+        }
+        otelLogger.emit({
+          severityNumber: LEVEL_MAP[level] ?? import_api_logs.SeverityNumber.INFO,
+          body: msg,
+          attributes
+        });
+      } catch {
+      }
+      callback();
+    }
+  });
+}
+__name(createOTelStream, "createOTelStream");
+
+// src/logger.ts
+var CelerityLoggerImpl = class _CelerityLoggerImpl {
+  static {
+    __name(this, "CelerityLoggerImpl");
+  }
+  pinoLogger;
+  constructor(pinoLogger) {
+    this.pinoLogger = pinoLogger;
+  }
+  debug(message, attributes) {
+    this.log("debug", message, attributes);
+  }
+  info(message, attributes) {
+    this.log("info", message, attributes);
+  }
+  warn(message, attributes) {
+    this.log("warn", message, attributes);
+  }
+  error(message, attributes) {
+    this.log("error", message, attributes);
+  }
+  log(level, message, attributes) {
+    const fn = this.pinoLogger[level].bind(this.pinoLogger);
+    if (attributes) fn(attributes, message);
+    else fn(message);
+  }
+  child(name, attributes) {
+    return new _CelerityLoggerImpl(this.pinoLogger.child({
+      name,
+      ...attributes
+    }));
+  }
+  withContext(attributes) {
+    return new _CelerityLoggerImpl(this.pinoLogger.child(attributes));
+  }
+  /** Update the log level at runtime. Internal — used by TelemetryLayer for dynamic config. */
+  setLevel(level) {
+    this.pinoLogger.level = level;
+  }
+};
+function createLogger(config) {
+  const streams = [];
+  const isLocal = !process.env.CELERITY_RUNTIME_PLATFORM || process.env.CELERITY_RUNTIME_PLATFORM === "local";
+  const useHumanFormat = config.logFormat === "human" || config.logFormat === "auto" && isLocal;
+  if (useHumanFormat) {
+    streams.push({
+      level: config.logLevel,
+      stream: import_pino.default.transport({
+        target: "pino-pretty",
+        options: {
+          destination: 1
+        }
+      })
+    });
+  } else {
+    streams.push({
+      level: config.logLevel,
+      stream: import_pino.default.destination(1)
+    });
+  }
+  if (config.logFilePath) {
+    streams.push({
+      level: config.logLevel,
+      stream: import_pino.default.destination(config.logFilePath)
+    });
+  }
+  if (config.tracingEnabled) {
+    streams.push({
+      level: config.logLevel,
+      stream: createOTelStream()
+    });
+  }
+  const redactPaths = resolveRedactPaths();
+  const logger = (0, import_pino.default)({
+    level: config.logLevel,
+    redact: redactPaths.length > 0 ? {
+      paths: redactPaths,
+      censor: "[REDACTED]"
+    } : void 0,
+    timestamp: import_pino.default.stdTimeFunctions.isoTime
+  }, import_pino.default.multistream(streams));
+  return new CelerityLoggerImpl(logger);
+}
+__name(createLogger, "createLogger");
+function resolveRedactPaths() {
+  const keys = process.env.CELERITY_LOG_REDACT_KEYS;
+  if (!keys) return [];
+  return keys.split(",").map((k) => k.trim());
+}
+__name(resolveRedactPaths, "resolveRedactPaths");
+
+// src/request-context.ts
+var import_node_async_hooks = require("async_hooks");
+var requestStore = new import_node_async_hooks.AsyncLocalStorage();
+function getRequestLogger() {
+  return requestStore.getStore()?.logger;
+}
+__name(getRequestLogger, "getRequestLogger");
+var ContextAwareLogger = class {
+  static {
+    __name(this, "ContextAwareLogger");
+  }
+  rootLogger;
+  constructor(rootLogger) {
+    this.rootLogger = rootLogger;
+  }
+  get current() {
+    return getRequestLogger() ?? this.rootLogger;
+  }
+  debug(message, attributes) {
+    this.current.debug(message, attributes);
+  }
+  info(message, attributes) {
+    this.current.info(message, attributes);
+  }
+  warn(message, attributes) {
+    this.current.warn(message, attributes);
+  }
+  error(message, attributes) {
+    this.current.error(message, attributes);
+  }
+  child(name, attributes) {
+    return this.current.child(name, attributes);
+  }
+  withContext(attributes) {
+    return this.current.withContext(attributes);
+  }
+};
+
+// src/context.ts
+var import_api = require("@opentelemetry/api");
+function extractTraceContext(request) {
+  if (!request.traceContext) return import_api.ROOT_CONTEXT;
+  return import_api.propagation.extract(import_api.ROOT_CONTEXT, request.traceContext);
+}
+__name(extractTraceContext, "extractTraceContext");
+
+// src/tracer.ts
+var import_api2 = require("@opentelemetry/api");
+var OTelTracer = class {
+  static {
+    __name(this, "OTelTracer");
+  }
+  tracer = import_api2.trace.getTracer("celerity");
+  startSpan(name, attributes) {
+    const span = this.tracer.startSpan(name, {
+      attributes
+    });
+    return new OTelSpan(span);
+  }
+  async withSpan(name, fn, attributes) {
+    const span = this.tracer.startSpan(name, {
+      attributes
+    });
+    const ctx = import_api2.trace.setSpan(import_api2.context.active(), span);
+    return import_api2.context.with(ctx, async () => {
+      const wrapped = new OTelSpan(span);
+      try {
+        const result = await fn(wrapped);
+        span.setStatus({
+          code: import_api2.SpanStatusCode.OK
+        });
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: import_api2.SpanStatusCode.ERROR
+        });
+        if (error instanceof Error) span.recordException(error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+};
+var OTelSpan = class {
+  static {
+    __name(this, "OTelSpan");
+  }
+  span;
+  constructor(span) {
+    this.span = span;
+  }
+  setAttribute(key, value) {
+    this.span.setAttribute(key, value);
+  }
+  setAttributes(attributes) {
+    this.span.setAttributes(attributes);
+  }
+  recordError(error) {
+    this.span.recordException(error);
+    this.span.setStatus({
+      code: import_api2.SpanStatusCode.ERROR,
+      message: error.message
+    });
+  }
+  setOk() {
+    this.span.setStatus({
+      code: import_api2.SpanStatusCode.OK
+    });
+  }
+  end() {
+    this.span.end();
+  }
+};
+
+// src/noop.ts
+var NoopTracer = class {
+  static {
+    __name(this, "NoopTracer");
+  }
+  startSpan() {
+    return NOOP_SPAN;
+  }
+  async withSpan(_name, fn) {
+    return fn(NOOP_SPAN);
+  }
+};
+var NOOP_SPAN = {
+  setAttribute() {
+  },
+  setAttributes() {
+  },
+  recordError() {
+  },
+  setOk() {
+  },
+  end() {
+  }
+};
+
+// src/tokens.ts
+var LOGGER_TOKEN = "CelerityLogger";
+var TRACER_TOKEN = "CelerityTracer";
+
+// src/telemetry-layer.ts
+var debugLog = (0, import_debug3.default)("celerity:telemetry");
+var LOG_LEVEL_CONFIG_KEYS = [
+  "CELERITY_LOG_LEVEL",
+  "celerityLogLevel",
+  "celerity_log_level",
+  "CelerityLogLevel"
+];
+var VALID_LOG_LEVELS2 = /* @__PURE__ */ new Set([
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+var TelemetryLayer = class {
+  static {
+    __name(this, "TelemetryLayer");
+  }
+  config;
+  rootLogger = null;
+  currentLevel;
+  initPromise = null;
+  constructor() {
+    this.config = readTelemetryEnv();
+    this.currentLevel = this.config.logLevel;
+    if (this.config.tracingEnabled) {
+      this.initPromise = initTelemetry();
+    }
+  }
+  async handle(context, next) {
+    if (this.initPromise) {
+      await this.initPromise;
+      this.initPromise = null;
+    }
+    if (!this.rootLogger) {
+      debugLog("creating root logger (format=%s, level=%s)", this.config.logFormat, this.config.logLevel);
+      this.rootLogger = createLogger(this.config);
+      context.container.register(LOGGER_TOKEN, {
+        useValue: new ContextAwareLogger(this.rootLogger)
+      });
+      context.container.register(TRACER_TOKEN, {
+        useValue: this.config.tracingEnabled ? new OTelTracer() : new NoopTracer()
+      });
+      debugLog("registered logger and tracer (tracing=%s)", this.config.tracingEnabled);
+    }
+    await this.refreshLogLevelFromConfig(context.container);
+    const userId = (0, import_common.extractUserId)(context.request.auth);
+    const requestLogger = this.rootLogger.child("request", {
+      requestId: context.request.requestId,
+      method: context.request.method,
+      path: context.request.path,
+      matchedRoute: context.request.matchedRoute,
+      clientIp: context.request.clientIp,
+      userAgent: context.request.userAgent,
+      ...userId ? {
+        userId
+      } : {}
+    });
+    context.logger = requestLogger;
+    const runWithLogger = /* @__PURE__ */ __name(() => requestStore.run({
+      logger: requestLogger
+    }, () => next()), "runWithLogger");
+    if (!this.config.tracingEnabled) return runWithLogger();
+    const parentContext = extractTraceContext(context.request);
+    return import_api3.context.with(parentContext, runWithLogger);
+  }
+  async dispose() {
+    if (this.config.tracingEnabled) await shutdownTelemetry();
+  }
+  async refreshLogLevelFromConfig(container) {
+    if (!container.has("ConfigService")) return;
+    try {
+      const configService = await container.resolve("ConfigService");
+      for (const key of LOG_LEVEL_CONFIG_KEYS) {
+        const value = await configService.get(key);
+        if (value && VALID_LOG_LEVELS2.has(value) && value !== this.currentLevel) {
+          debugLog("log level changed %s \u2192 %s", this.currentLevel, value);
+          this.rootLogger?.setLevel(value);
+          this.currentLevel = value;
+          return;
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/index.ts
+var import_common2 = require("@celerity-sdk/common");
+
+// src/helpers.ts
+async function getLogger(container) {
+  return container.resolve(LOGGER_TOKEN);
+}
+__name(getLogger, "getLogger");
+async function getTracer(container) {
+  return container.resolve(TRACER_TOKEN);
+}
+__name(getTracer, "getTracer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CelerityLoggerImpl,
+  ContextAwareLogger,
+  LOGGER_TOKEN,
+  NOOP_SPAN,
+  NoopTracer,
+  OTelSpan,
+  OTelTracer,
+  TRACER_TOKEN,
+  TelemetryLayer,
+  createLogger,
+  extractTraceContext,
+  extractUserId,
+  getLogger,
+  getRequestLogger,
+  getTracer,
+  readTelemetryEnv
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/telemetry-layer.ts","../src/env.ts","../src/init.ts","../src/instrumentations.ts","../src/logger.ts","../src/otel-transport.ts","../src/request-context.ts","../src/context.ts","../src/tracer.ts","../src/noop.ts","../src/tokens.ts","../src/helpers.ts"],"sourcesContent":["export { TelemetryLayer } from \"./telemetry-layer\";\nexport { extractUserId } from \"@celerity-sdk/common\";\nexport { CelerityLoggerImpl, createLogger } from \"./logger\";\nexport { ContextAwareLogger, getRequestLogger } from \"./request-context\";\nexport { OTelTracer, OTelSpan } from \"./tracer\";\nexport { NoopTracer, NOOP_SPAN } from \"./noop\";\nexport { LOGGER_TOKEN, TRACER_TOKEN } from \"./tokens\";\nexport { extractTraceContext } from \"./context\";\nexport { getLogger, getTracer } from \"./helpers\";\nexport { readTelemetryEnv } from \"./env\";\nexport type { TelemetryConfig } from \"./env\";\n","import createDebug from \"debug\";\nimport { context as otelContext } from \"@opentelemetry/api\";\nimport type {\n  CelerityLayer,\n  HandlerContext,\n  HandlerResponse,\n  LogLevel,\n  ServiceContainer,\n} from \"@celerity-sdk/types\";\nimport { extractUserId } from \"@celerity-sdk/common\";\nimport { readTelemetryEnv, type TelemetryConfig } from \"./env\";\nimport { initTelemetry, shutdownTelemetry } from \"./init\";\nimport { CelerityLoggerImpl, createLogger } from \"./logger\";\nimport { ContextAwareLogger, requestStore } from \"./request-context\";\nimport { extractTraceContext } from \"./context\";\nimport { OTelTracer } from \"./tracer\";\nimport { NoopTracer } from \"./noop\";\nimport { LOGGER_TOKEN, TRACER_TOKEN } from \"./tokens\";\n\nconst debugLog = createDebug(\"celerity:telemetry\");\n\nconst LOG_LEVEL_CONFIG_KEYS = [\n  \"CELERITY_LOG_LEVEL\",\n  \"celerityLogLevel\",\n  \"celerity_log_level\",\n  \"CelerityLogLevel\",\n];\n\nconst VALID_LOG_LEVELS = new Set<string>([\"debug\", \"info\", \"warn\", \"error\"]);\n\ntype ConfigService = {\n  get(key: string): Promise<string | undefined>;\n};\n\nexport class TelemetryLayer implements CelerityLayer {\n  private config: TelemetryConfig;\n  private rootLogger: CelerityLoggerImpl | null = null;\n  private currentLevel: LogLevel;\n  private initPromise: Promise<void> | null = null;\n\n  constructor() {\n    this.config = readTelemetryEnv();\n    this.currentLevel = this.config.logLevel;\n\n    if (this.config.tracingEnabled) {\n      this.initPromise = initTelemetry();\n    }\n  }\n\n  async handle(\n    context: HandlerContext,\n    next: () => Promise<HandlerResponse>,\n  ): Promise<HandlerResponse> {\n    if (this.initPromise) {\n      await this.initPromise;\n      this.initPromise = null;\n    }\n\n    if (!this.rootLogger) {\n      debugLog(\n        \"creating root logger (format=%s, level=%s)\",\n        this.config.logFormat,\n        this.config.logLevel,\n      );\n      this.rootLogger = createLogger(this.config);\n      context.container.register(LOGGER_TOKEN, {\n        useValue: new ContextAwareLogger(this.rootLogger),\n      });\n      context.container.register(TRACER_TOKEN, {\n        useValue: this.config.tracingEnabled ? new OTelTracer() : new NoopTracer(),\n      });\n      debugLog(\"registered logger and tracer (tracing=%s)\", this.config.tracingEnabled);\n    }\n\n    await this.refreshLogLevelFromConfig(context.container);\n\n    const userId = extractUserId(context.request.auth);\n    const requestLogger = this.rootLogger.child(\"request\", {\n      requestId: context.request.requestId,\n      method: context.request.method,\n      path: context.request.path,\n      matchedRoute: context.request.matchedRoute,\n      clientIp: context.request.clientIp,\n      userAgent: context.request.userAgent,\n      ...(userId ? { userId } : {}),\n    });\n    context.logger = requestLogger;\n\n    const runWithLogger = () => requestStore.run({ logger: requestLogger }, () => next());\n\n    if (!this.config.tracingEnabled) return runWithLogger();\n\n    const parentContext = extractTraceContext(context.request);\n    return otelContext.with(parentContext, runWithLogger);\n  }\n\n  async dispose(): Promise<void> {\n    if (this.config.tracingEnabled) await shutdownTelemetry();\n  }\n\n  private async refreshLogLevelFromConfig(container: ServiceContainer): Promise<void> {\n    if (!container.has(\"ConfigService\")) return;\n\n    try {\n      const configService = await container.resolve<ConfigService>(\"ConfigService\");\n      for (const key of LOG_LEVEL_CONFIG_KEYS) {\n        const value = await configService.get(key);\n        if (value && VALID_LOG_LEVELS.has(value) && value !== this.currentLevel) {\n          debugLog(\"log level changed %s → %s\", this.currentLevel, value);\n          this.rootLogger?.setLevel(value as LogLevel);\n          this.currentLevel = value as LogLevel;\n          return;\n        }\n      }\n    } catch {\n      // Config resolution failed — keep current level\n    }\n  }\n}\n","import type { LogLevel } from \"@celerity-sdk/types\";\n\nexport type TelemetryConfig = {\n  tracingEnabled: boolean;\n  otlpEndpoint: string;\n  serviceName: string;\n  serviceVersion: string;\n  logLevel: LogLevel;\n  logFormat: \"json\" | \"human\" | \"auto\";\n  logFilePath: string | null;\n};\n\nconst VALID_LOG_LEVELS = new Set<string>([\"debug\", \"info\", \"warn\", \"error\"]);\nconst VALID_LOG_FORMATS = new Set<string>([\"json\", \"human\", \"auto\"]);\n\nexport function readTelemetryEnv(): TelemetryConfig {\n  const rawLevel = process.env.CELERITY_LOG_LEVEL;\n  const rawFormat = process.env.CELERITY_LOG_FORMAT;\n\n  return {\n    tracingEnabled: process.env.CELERITY_TELEMETRY_ENABLED === \"true\",\n    otlpEndpoint:\n      process.env.OTEL_EXPORTER_OTLP_ENDPOINT ??\n      process.env.CELERITY_TRACE_OTLP_COLLECTOR_ENDPOINT ??\n      \"http://otelcollector:4317\",\n    serviceName: process.env.OTEL_SERVICE_NAME ?? \"celerity-app\",\n    serviceVersion: process.env.OTEL_SERVICE_VERSION ?? \"0.0.0\",\n    logLevel: rawLevel && VALID_LOG_LEVELS.has(rawLevel) ? (rawLevel as LogLevel) : \"info\",\n    logFormat:\n      rawFormat && VALID_LOG_FORMATS.has(rawFormat)\n        ? (rawFormat as \"json\" | \"human\" | \"auto\")\n        : \"auto\",\n    logFilePath: process.env.CELERITY_LOG_FILE_PATH ?? null,\n  };\n}\n","import createDebug from \"debug\";\nimport { NodeSDK } from \"@opentelemetry/sdk-node\";\nimport { resourceFromAttributes } from \"@opentelemetry/resources\";\nimport { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from \"@opentelemetry/semantic-conventions\";\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-grpc\";\nimport { OTLPLogExporter } from \"@opentelemetry/exporter-logs-otlp-grpc\";\nimport { BatchLogRecordProcessor } from \"@opentelemetry/sdk-logs\";\nimport { CompositePropagator, W3CTraceContextPropagator } from \"@opentelemetry/core\";\nimport { AWSXRayPropagator } from \"@opentelemetry/propagator-aws-xray\";\nimport { AWSXRayIdGenerator } from \"@opentelemetry/id-generator-aws-xray\";\nimport { readTelemetryEnv } from \"./env\";\nimport { buildInstrumentations } from \"./instrumentations\";\n\nconst debug = createDebug(\"celerity:telemetry\");\n\nlet initialized = false;\nlet sdk: NodeSDK | null = null;\n\nexport function isInitialized(): boolean {\n  return initialized;\n}\n\nexport async function initTelemetry(): Promise<void> {\n  if (initialized) {\n    debug(\"initTelemetry: already initialized, skipping\");\n    return;\n  }\n\n  const config = readTelemetryEnv();\n  if (!config.tracingEnabled) {\n    debug(\"initTelemetry: tracing disabled, skipping\");\n    return;\n  }\n\n  const platform = process.env.CELERITY_RUNTIME_PLATFORM ?? \"local\";\n  const isAws = platform === \"aws\";\n  debug(\n    \"initTelemetry: platform=%s endpoint=%s service=%s\",\n    platform,\n    config.otlpEndpoint,\n    config.serviceName,\n  );\n\n  const instrumentations = await buildInstrumentations();\n\n  sdk = new NodeSDK({\n    resource: resourceFromAttributes({\n      [ATTR_SERVICE_NAME]: config.serviceName,\n      [ATTR_SERVICE_VERSION]: config.serviceVersion,\n    }),\n    traceExporter: new OTLPTraceExporter({ url: config.otlpEndpoint }),\n    logRecordProcessors: [\n      new BatchLogRecordProcessor(new OTLPLogExporter({ url: config.otlpEndpoint })),\n    ],\n    textMapPropagator: new CompositePropagator({\n      propagators: [new W3CTraceContextPropagator(), new AWSXRayPropagator()],\n    }),\n    ...(isAws ? { idGenerator: new AWSXRayIdGenerator() } : {}),\n    instrumentations,\n  });\n\n  sdk.start();\n  initialized = true;\n  debug(\"initTelemetry: SDK started\");\n}\n\nexport async function shutdownTelemetry(): Promise<void> {\n  if (sdk) {\n    debug(\"shutdownTelemetry: shutting down SDK\");\n    await sdk.shutdown();\n    sdk = null;\n    initialized = false;\n  }\n}\n","import createDebug from \"debug\";\nimport { HttpInstrumentation } from \"@opentelemetry/instrumentation-http\";\nimport { UndiciInstrumentation } from \"@opentelemetry/instrumentation-undici\";\nimport type { Instrumentation } from \"@opentelemetry/instrumentation\";\n\nconst debug = createDebug(\"celerity:telemetry\");\n\nexport async function buildInstrumentations(): Promise<Instrumentation[]> {\n  // Core instrumentation: always active — covers all HTTP/HTTPS and fetch() calls\n  const instrumentations: Instrumentation[] = [\n    new HttpInstrumentation() as Instrumentation,\n    new UndiciInstrumentation() as Instrumentation,\n  ];\n\n  // Dynamically load optional instrumentation packages.\n  // Each targets a specific library and silently no-ops if the library isn't installed.\n  const optionalPackages = [\n    \"@opentelemetry/instrumentation-aws-sdk\",\n    \"@opentelemetry/instrumentation-ioredis\",\n    \"@opentelemetry/instrumentation-pg\",\n    \"@opentelemetry/instrumentation-mysql2\",\n  ];\n\n  for (const name of optionalPackages) {\n    try {\n      const pkg = name;\n      const mod = (await import(pkg)) as Record<string, unknown>;\n      const InstrumentationClass = findInstrumentationExport(mod);\n      if (InstrumentationClass) {\n        debug(\"instrumentation: loaded %s\", name);\n        instrumentations.push(new InstrumentationClass() as Instrumentation);\n      }\n    } catch (err) {\n      const code = (err as { code?: string }).code;\n      if (code !== \"ERR_MODULE_NOT_FOUND\" && code !== \"MODULE_NOT_FOUND\") {\n        debug(\"instrumentation: failed to load %s: %O\", name, err);\n      }\n    }\n  }\n\n  return instrumentations;\n}\n\nfunction findInstrumentationExport(mod: Record<string, unknown>): (new () => unknown) | null {\n  for (const value of Object.values(mod)) {\n    if (typeof value === \"function\" && value.prototype && \"enable\" in value.prototype) {\n      return value as new () => unknown;\n    }\n  }\n  return null;\n}\n","import pino from \"pino\";\nimport type { CelerityLogger, LogLevel } from \"@celerity-sdk/types\";\nimport type { TelemetryConfig } from \"./env\";\nimport { createOTelStream } from \"./otel-transport\";\n\n/**\n * Thin pino wrapper implementing CelerityLogger.\n * Every method delegates directly to the underlying pino instance.\n */\nexport class CelerityLoggerImpl implements CelerityLogger {\n  constructor(private pinoLogger: pino.Logger) {}\n\n  debug(message: string, attributes?: Record<string, unknown>): void {\n    this.log(\"debug\", message, attributes);\n  }\n\n  info(message: string, attributes?: Record<string, unknown>): void {\n    this.log(\"info\", message, attributes);\n  }\n\n  warn(message: string, attributes?: Record<string, unknown>): void {\n    this.log(\"warn\", message, attributes);\n  }\n\n  error(message: string, attributes?: Record<string, unknown>): void {\n    this.log(\"error\", message, attributes);\n  }\n\n  private log(level: LogLevel, message: string, attributes?: Record<string, unknown>): void {\n    const fn = this.pinoLogger[level].bind(this.pinoLogger);\n    if (attributes) fn(attributes, message);\n    else fn(message);\n  }\n\n  child(name: string, attributes?: Record<string, unknown>): CelerityLogger {\n    return new CelerityLoggerImpl(this.pinoLogger.child({ name, ...attributes }));\n  }\n\n  withContext(attributes: Record<string, unknown>): CelerityLogger {\n    return new CelerityLoggerImpl(this.pinoLogger.child(attributes));\n  }\n\n  /** Update the log level at runtime. Internal — used by TelemetryLayer for dynamic config. */\n  setLevel(level: LogLevel): void {\n    this.pinoLogger.level = level;\n  }\n}\n\nexport function createLogger(config: TelemetryConfig): CelerityLoggerImpl {\n  const streams: pino.StreamEntry[] = [];\n\n  const isLocal =\n    !process.env.CELERITY_RUNTIME_PLATFORM || process.env.CELERITY_RUNTIME_PLATFORM === \"local\";\n  const useHumanFormat = config.logFormat === \"human\" || (config.logFormat === \"auto\" && isLocal);\n\n  if (useHumanFormat) {\n    // pino-pretty via worker thread — fine for local dev only\n    streams.push({\n      level: config.logLevel,\n      stream: pino.transport({ target: \"pino-pretty\", options: { destination: 1 } }),\n    });\n  } else {\n    // Raw JSON to stdout — synchronous, Lambda-safe\n    streams.push({ level: config.logLevel, stream: pino.destination(1) });\n  }\n\n  // File stream — if configured (synchronous SonicBoom destination)\n  if (config.logFilePath) {\n    streams.push({\n      level: config.logLevel,\n      stream: pino.destination(config.logFilePath),\n    });\n  }\n\n  // OTel log stream — main-thread writable (NOT worker-thread transport).\n  // Runs in main thread so it can read active OTel context (traceId/spanId)\n  // and is safe for Lambda (no worker thread flush issues).\n  if (config.tracingEnabled) {\n    streams.push({\n      level: config.logLevel,\n      stream: createOTelStream(),\n    });\n  }\n\n  const redactPaths = resolveRedactPaths();\n\n  const logger = pino(\n    {\n      level: config.logLevel,\n      redact: redactPaths.length > 0 ? { paths: redactPaths, censor: \"[REDACTED]\" } : undefined,\n      timestamp: pino.stdTimeFunctions.isoTime,\n    },\n    pino.multistream(streams),\n  );\n\n  return new CelerityLoggerImpl(logger);\n}\n\nfunction resolveRedactPaths(): string[] {\n  const keys = process.env.CELERITY_LOG_REDACT_KEYS;\n  if (!keys) return [];\n  return keys.split(\",\").map((k) => k.trim());\n}\n","import { Writable } from \"node:stream\";\nimport { logs, SeverityNumber } from \"@opentelemetry/api-logs\";\n\nconst LEVEL_MAP: Record<number, SeverityNumber> = {\n  10: SeverityNumber.TRACE,\n  20: SeverityNumber.DEBUG,\n  30: SeverityNumber.INFO,\n  40: SeverityNumber.WARN,\n  50: SeverityNumber.ERROR,\n  60: SeverityNumber.FATAL,\n};\n\n/**\n * Creates a main-thread writable stream that bridges pino log records\n * to the OTel Logs API.\n *\n * Runs in the main thread (NOT a pino worker-thread transport) so it can:\n * 1. Read traceId/spanId from the active OTel context (trace correlation)\n * 2. Flush reliably in Lambda (no worker thread lifecycle issues)\n */\nexport function createOTelStream(): Writable {\n  const otelLogger = logs.getLogger(\"celerity\");\n\n  return new Writable({\n    write(chunk: Buffer | string, _encoding, callback) {\n      try {\n        const obj = JSON.parse(typeof chunk === \"string\" ? chunk : chunk.toString()) as Record<\n          string,\n          unknown\n        >;\n        const { level, msg, name, ...rest } = obj;\n        delete rest.time;\n        const attributes: Record<string, string | number | boolean> = {};\n        if (typeof name === \"string\") attributes[\"logger.name\"] = name;\n        for (const [key, val] of Object.entries(rest)) {\n          if (typeof val === \"string\" || typeof val === \"number\" || typeof val === \"boolean\") {\n            attributes[key] = val;\n          }\n        }\n        otelLogger.emit({\n          severityNumber: LEVEL_MAP[level as number] ?? SeverityNumber.INFO,\n          body: msg as string,\n          attributes,\n        });\n      } catch {\n        // Malformed JSON — skip\n      }\n      callback();\n    },\n  });\n}\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { CelerityLogger } from \"@celerity-sdk/types\";\n\ntype RequestStore = {\n  logger: CelerityLogger;\n};\n\nexport const requestStore = new AsyncLocalStorage<RequestStore>();\n\n/**\n * Get the request-scoped logger from the current async context.\n *\n * Works anywhere in the async call chain during request handling —\n * handlers, services, repositories, API clients.\n *\n * Returns `undefined` outside a request context (e.g., startup code, background tasks).\n */\nexport function getRequestLogger(): CelerityLogger | undefined {\n  return requestStore.getStore()?.logger;\n}\n\n/**\n * Context-aware logger proxy registered under LOGGER_TOKEN.\n *\n * Delegates to the request-scoped logger (via AsyncLocalStorage) when inside\n * a request context, falls back to the root logger otherwise.\n *\n * This means `@Inject(LOGGER_TOKEN)` automatically resolves to the most\n * appropriate logger for the current context — no manual wiring needed.\n */\nexport class ContextAwareLogger implements CelerityLogger {\n  constructor(private rootLogger: CelerityLogger) {}\n\n  private get current(): CelerityLogger {\n    return getRequestLogger() ?? this.rootLogger;\n  }\n\n  debug(message: string, attributes?: Record<string, unknown>): void {\n    this.current.debug(message, attributes);\n  }\n\n  info(message: string, attributes?: Record<string, unknown>): void {\n    this.current.info(message, attributes);\n  }\n\n  warn(message: string, attributes?: Record<string, unknown>): void {\n    this.current.warn(message, attributes);\n  }\n\n  error(message: string, attributes?: Record<string, unknown>): void {\n    this.current.error(message, attributes);\n  }\n\n  child(name: string, attributes?: Record<string, unknown>): CelerityLogger {\n    return this.current.child(name, attributes);\n  }\n\n  withContext(attributes: Record<string, unknown>): CelerityLogger {\n    return this.current.withContext(attributes);\n  }\n}\n","import { propagation, ROOT_CONTEXT, type Context } from \"@opentelemetry/api\";\nimport type { HttpRequest } from \"@celerity-sdk/types\";\n\nexport function extractTraceContext(request: HttpRequest): Context {\n  if (!request.traceContext) return ROOT_CONTEXT;\n\n  // The traceContext map is used directly as a carrier.\n  // The composite propagator (W3C + X-Ray) extracts the appropriate context.\n  return propagation.extract(ROOT_CONTEXT, request.traceContext);\n}\n","import {\n  trace,\n  context as otelContext,\n  SpanStatusCode,\n  type Span,\n  type Attributes,\n} from \"@opentelemetry/api\";\nimport type { CelerityTracer, CeleritySpan } from \"@celerity-sdk/types\";\n\nexport class OTelTracer implements CelerityTracer {\n  private tracer = trace.getTracer(\"celerity\");\n\n  startSpan(name: string, attributes?: Record<string, unknown>): CeleritySpan {\n    const span = this.tracer.startSpan(name, {\n      attributes: attributes as Attributes,\n    });\n    return new OTelSpan(span);\n  }\n\n  async withSpan<T>(\n    name: string,\n    fn: (span: CeleritySpan) => T | Promise<T>,\n    attributes?: Record<string, unknown>,\n  ): Promise<T> {\n    const span = this.tracer.startSpan(name, {\n      attributes: attributes as Attributes,\n    });\n    const ctx = trace.setSpan(otelContext.active(), span);\n\n    return otelContext.with(ctx, async () => {\n      const wrapped = new OTelSpan(span);\n      try {\n        const result = await fn(wrapped);\n        span.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      } catch (error) {\n        span.setStatus({ code: SpanStatusCode.ERROR });\n        if (error instanceof Error) span.recordException(error);\n        throw error;\n      } finally {\n        span.end();\n      }\n    });\n  }\n}\n\nexport class OTelSpan implements CeleritySpan {\n  constructor(private span: Span) {}\n\n  setAttribute(key: string, value: string | number | boolean): void {\n    this.span.setAttribute(key, value);\n  }\n\n  setAttributes(attributes: Record<string, string | number | boolean>): void {\n    this.span.setAttributes(attributes);\n  }\n\n  recordError(error: Error): void {\n    this.span.recordException(error);\n    this.span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });\n  }\n\n  setOk(): void {\n    this.span.setStatus({ code: SpanStatusCode.OK });\n  }\n\n  end(): void {\n    this.span.end();\n  }\n}\n","import type { CelerityTracer, CeleritySpan } from \"@celerity-sdk/types\";\n\nexport class NoopTracer implements CelerityTracer {\n  startSpan(): CeleritySpan {\n    return NOOP_SPAN;\n  }\n\n  async withSpan<T>(_name: string, fn: (span: CeleritySpan) => T | Promise<T>): Promise<T> {\n    return fn(NOOP_SPAN);\n  }\n}\n\nexport const NOOP_SPAN: CeleritySpan = {\n  setAttribute() {},\n  setAttributes() {},\n  recordError() {},\n  setOk() {},\n  end() {},\n};\n","export const LOGGER_TOKEN = \"CelerityLogger\";\nexport const TRACER_TOKEN = \"CelerityTracer\";\n","import type { CelerityLogger, CelerityTracer, ServiceContainer } from \"@celerity-sdk/types\";\nimport { LOGGER_TOKEN, TRACER_TOKEN } from \"./tokens\";\n\nexport async function getLogger(container: ServiceContainer): Promise<CelerityLogger> {\n  return container.resolve<CelerityLogger>(LOGGER_TOKEN);\n}\n\nexport async function getTracer(container: ServiceContainer): Promise<CelerityTracer> {\n  return container.resolve<CelerityTracer>(TRACER_TOKEN);\n}\n"],"mappings":"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","names":["import_debug","import_api","VALID_LOG_LEVELS","Set","VALID_LOG_FORMATS","readTelemetryEnv","rawLevel","process","env","CELERITY_LOG_LEVEL","rawFormat","CELERITY_LOG_FORMAT","tracingEnabled","CELERITY_TELEMETRY_ENABLED","otlpEndpoint","OTEL_EXPORTER_OTLP_ENDPOINT","CELERITY_TRACE_OTLP_COLLECTOR_ENDPOINT","serviceName","OTEL_SERVICE_NAME","serviceVersion","OTEL_SERVICE_VERSION","logLevel","has","logFormat","logFilePath","CELERITY_LOG_FILE_PATH","import_debug","debug","createDebug","buildInstrumentations","instrumentations","HttpInstrumentation","UndiciInstrumentation","optionalPackages","name","pkg","mod","InstrumentationClass","findInstrumentationExport","push","err","code","value","Object","values","prototype","debug","createDebug","initialized","sdk","initTelemetry","initialized","debug","config","readTelemetryEnv","tracingEnabled","platform","process","env","CELERITY_RUNTIME_PLATFORM","isAws","otlpEndpoint","serviceName","instrumentations","buildInstrumentations","sdk","NodeSDK","resource","resourceFromAttributes","ATTR_SERVICE_NAME","ATTR_SERVICE_VERSION","serviceVersion","traceExporter","OTLPTraceExporter","url","logRecordProcessors","BatchLogRecordProcessor","OTLPLogExporter","textMapPropagator","CompositePropagator","propagators","W3CTraceContextPropagator","AWSXRayPropagator","idGenerator","AWSXRayIdGenerator","start","shutdownTelemetry","shutdown","LEVEL_MAP","SeverityNumber","TRACE","DEBUG","INFO","WARN","ERROR","FATAL","createOTelStream","otelLogger","logs","getLogger","Writable","write","chunk","_encoding","callback","obj","JSON","parse","toString","level","msg","name","rest","time","attributes","key","val","Object","entries","emit","severityNumber","body","CelerityLoggerImpl","pinoLogger","debug","message","attributes","log","info","warn","error","level","fn","bind","child","name","withContext","setLevel","createLogger","config","streams","isLocal","process","env","CELERITY_RUNTIME_PLATFORM","useHumanFormat","logFormat","push","logLevel","stream","pino","transport","target","options","destination","logFilePath","tracingEnabled","createOTelStream","redactPaths","resolveRedactPaths","logger","redact","length","paths","censor","undefined","timestamp","stdTimeFunctions","isoTime","multistream","keys","CELERITY_LOG_REDACT_KEYS","split","map","k","trim","requestStore","AsyncLocalStorage","getRequestLogger","getStore","logger","ContextAwareLogger","rootLogger","current","debug","message","attributes","info","warn","error","child","name","withContext","extractTraceContext","request","traceContext","ROOT_CONTEXT","propagation","extract","import_api","OTelTracer","tracer","trace","getTracer","startSpan","name","attributes","span","OTelSpan","withSpan","fn","ctx","setSpan","otelContext","active","with","wrapped","result","setStatus","code","SpanStatusCode","OK","error","ERROR","Error","recordException","end","setAttribute","key","value","setAttributes","recordError","message","setOk","NoopTracer","startSpan","NOOP_SPAN","withSpan","_name","fn","setAttribute","setAttributes","recordError","setOk","end","LOGGER_TOKEN","TRACER_TOKEN","debugLog","createDebug","LOG_LEVEL_CONFIG_KEYS","VALID_LOG_LEVELS","Set","TelemetryLayer","config","rootLogger","currentLevel","initPromise","readTelemetryEnv","logLevel","tracingEnabled","initTelemetry","handle","context","next","logFormat","createLogger","container","register","LOGGER_TOKEN","useValue","ContextAwareLogger","TRACER_TOKEN","OTelTracer","NoopTracer","refreshLogLevelFromConfig","userId","extractUserId","request","auth","requestLogger","child","requestId","method","path","matchedRoute","clientIp","userAgent","logger","runWithLogger","requestStore","run","parentContext","extractTraceContext","otelContext","with","dispose","shutdownTelemetry","has","configService","resolve","key","value","get","setLevel","import_common","getLogger","container","resolve","LOGGER_TOKEN","getTracer","TRACER_TOKEN"]}