@ryanzeng/nest-observe 0.1.0

package/dist/index.js

@@ -0,0 +1,1121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CompatibleNestInstrumentation: () => CompatibleNestInstrumentation,
+  HttpRequestMetrics: () => HttpRequestMetrics,
+  IgnoreTrace: () => IgnoreTrace,
+  NestLoggerInstrumentation: () => NestLoggerInstrumentation,
+  NestMethodInstrumenter: () => NestMethodInstrumenter,
+  OBSERVE_HANDLE: () => OBSERVE_HANDLE,
+  OBSERVE_OPTIONS: () => OBSERVE_OPTIONS,
+  ObserveModule: () => ObserveModule,
+  OpenTelemetryLogEmitter: () => OpenTelemetryLogEmitter,
+  REDACTED: () => REDACTED,
+  RuntimeMetrics: () => RuntimeMetrics,
+  SDK_NAME: () => SDK_NAME,
+  SDK_VERSION: () => SDK_VERSION,
+  SpanRedactionProcessor: () => SpanRedactionProcessor,
+  Trace: () => Trace,
+  createObserveResource: () => createObserveResource,
+  getObserveRuntime: () => getObserveRuntime,
+  isSensitiveKey: () => isSensitiveKey,
+  isTraceDecorated: () => isTraceDecorated,
+  isTraceIgnored: () => isTraceIgnored,
+  markTraceDecorated: () => markTraceDecorated,
+  markTraceIgnored: () => markTraceIgnored,
+  observe: () => observe,
+  parseKeyValueList: () => parseKeyValueList,
+  redact: () => redact,
+  redactText: () => redactText,
+  resolveObserveConfig: () => resolveObserveConfig,
+  sanitizeHeaders: () => sanitizeHeaders
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var import_node_crypto = require("crypto");
+var DEFAULT_ALLOWED_HEADERS = ["accept", "content-type", "user-agent", "x-request-id", "traceparent"];
+function booleanValue(value, fallback) {
+  if (typeof value === "boolean") return value;
+  if (value?.toLowerCase() === "true") return true;
+  if (value?.toLowerCase() === "false") return false;
+  return fallback;
+}
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}
+function samplingValue(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 1;
+  return Math.min(1, Math.max(0, number));
+}
+function environmentSampling(env) {
+  const sampler = env.OTEL_TRACES_SAMPLER?.toLowerCase();
+  if (sampler === "always_off" || sampler === "parentbased_always_off") return 0;
+  if (sampler === "always_on" || sampler === "parentbased_always_on") return 1;
+  return samplingValue(env.OTEL_TRACES_SAMPLER_ARG);
+}
+function decode(value) {
+  try {
+    return decodeURIComponent(value.trim());
+  } catch {
+    return value.trim();
+  }
+}
+function parseKeyValueList(value) {
+  if (!value) return {};
+  return Object.fromEntries(value.split(",").flatMap((entry) => {
+    const separator = entry.indexOf("=");
+    if (separator <= 0) return [];
+    const key = decode(entry.slice(0, separator));
+    const itemValue = decode(entry.slice(separator + 1));
+    return key ? [[key, itemValue]] : [];
+  }));
+}
+function appendSignalPath(endpoint, signal) {
+  if (!endpoint) return void 0;
+  return `${endpoint.replace(/\/+$/, "")}/v1/${signal}`;
+}
+function optionalString(value) {
+  const result = value?.trim();
+  return result ? result : void 0;
+}
+function resolveObserveConfig(options = {}, env = process.env) {
+  const otelResources = parseKeyValueList(env.OTEL_RESOURCE_ATTRIBUTES);
+  const resourceAttributes = { ...otelResources, ...options.resourceAttributes };
+  const genericEndpoint = optionalString(options.endpoint ?? env.OTEL_EXPORTER_OTLP_ENDPOINT);
+  const sampling = options.sampling === void 0 ? environmentSampling(env) : samplingValue(options.sampling);
+  const allowedHeaders = Array.from(new Set([
+    ...DEFAULT_ALLOWED_HEADERS,
+    ...options.allowedHeaders ?? []
+  ].map((header) => header.toLowerCase().trim()).filter(Boolean)));
+  const result = {
+    enabled: booleanValue(options.enabled ?? env.OBSERVE_ENABLED, true),
+    serviceName: options.serviceName ?? env.OTEL_SERVICE_NAME ?? otelResources["service.name"] ?? "nest-application",
+    serviceVersion: options.serviceVersion ?? env.OTEL_SERVICE_VERSION ?? otelResources["service.version"] ?? "unknown",
+    environment: options.environment ?? env.OBSERVE_ENVIRONMENT ?? otelResources["deployment.environment.name"] ?? env.NODE_ENV ?? "development",
+    instanceId: options.instanceId ?? otelResources["service.instance.id"] ?? env.OTEL_SERVICE_INSTANCE_ID ?? env.HOSTNAME ?? (0, import_node_crypto.randomUUID)(),
+    endpoints: {
+      traces: optionalString(env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT) ?? appendSignalPath(genericEndpoint, "traces"),
+      metrics: optionalString(env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) ?? appendSignalPath(genericEndpoint, "metrics"),
+      logs: optionalString(env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) ?? appendSignalPath(genericEndpoint, "logs")
+    },
+    headers: { ...parseKeyValueList(env.OTEL_EXPORTER_OTLP_HEADERS), ...options.headers },
+    traces: booleanValue(options.traces, true),
+    logs: booleanValue(options.logs, true),
+    metrics: booleanValue(options.metrics, true),
+    providerTracing: booleanValue(options.providerTracing, true),
+    controllerTracing: booleanValue(options.controllerTracing, true),
+    sampling,
+    allowedHeaders,
+    exportTimeoutMillis: positiveInteger(options.exportTimeoutMillis ?? env.OTEL_EXPORTER_OTLP_TIMEOUT, 1e4),
+    metricExportIntervalMillis: positiveInteger(options.metricExportIntervalMillis ?? env.OTEL_METRIC_EXPORT_INTERVAL, 6e4),
+    resourceAttributes
+  };
+  if (options.exporters) result.exporters = options.exporters;
+  return result;
+}
+
+// src/decorators/metadata.ts
+var ignoredTargets = /* @__PURE__ */ new WeakSet();
+var tracedTargets = /* @__PURE__ */ new WeakSet();
+function markTraceIgnored(target) {
+  ignoredTargets.add(target);
+}
+function markTraceDecorated(target) {
+  tracedTargets.add(target);
+}
+function isTraceIgnored(method, type) {
+  return Boolean(method && ignoredTargets.has(method) || type && ignoredTargets.has(type));
+}
+function isTraceDecorated(method) {
+  return Boolean(method && tracedTargets.has(method));
+}
+
+// src/decorators/ignore-trace.decorator.ts
+function IgnoreTrace() {
+  return ((target, propertyKey, descriptor) => {
+    if (propertyKey !== void 0 && descriptor?.value && typeof descriptor.value === "function") {
+      markTraceIgnored(descriptor.value);
+      return descriptor;
+    }
+    markTraceIgnored(target);
+    return target;
+  });
+}
+
+// src/decorators/trace.decorator.ts
+var import_api2 = require("@opentelemetry/api");
+
+// src/decorators/invoke.ts
+var import_api = require("@opentelemetry/api");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+function fail(span, error) {
+  span.recordException(error instanceof Error ? error : new Error(String(error)));
+  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: error instanceof Error ? error.message : String(error) });
+}
+function invokeWithSpan(tracer, spanName, attributes, invoke, onFinish) {
+  return tracer.startActiveSpan(spanName, { attributes }, (span) => {
+    const started = process.hrtime.bigint();
+    const finish = (error) => {
+      if (error !== void 0) fail(span, error);
+      else span.setStatus({ code: import_api.SpanStatusCode.OK });
+      onFinish?.(Number(process.hrtime.bigint() - started) / 1e9, error);
+      span.end();
+    };
+    try {
+      const result = invoke();
+      if (result instanceof Promise) {
+        return result.then(
+          (value) => {
+            finish();
+            return value;
+          },
+          (error) => {
+            finish(error);
+            throw error;
+          }
+        );
+      }
+      if ((0, import_rxjs.isObservable)(result)) {
+        const spanContext = import_api.context.active();
+        const source = result;
+        return new import_rxjs.Observable((subscriber) => import_api.context.with(spanContext, () => {
+          let streamError;
+          return source.pipe(
+            (0, import_operators.tap)({ error: (error) => {
+              streamError = error;
+            } }),
+            (0, import_operators.finalize)(() => finish(streamError))
+          ).subscribe(subscriber);
+        }));
+      }
+      finish();
+      return result;
+    } catch (error) {
+      finish(error);
+      throw error;
+    }
+  });
+}
+
+// src/decorators/trace.decorator.ts
+function decorateMethod(target, propertyKey, descriptor, options) {
+  const original = descriptor.value;
+  if (typeof original !== "function" || isTraceIgnored(original, target.constructor)) return;
+  const className = target.constructor?.name || "Anonymous";
+  const methodName = String(propertyKey);
+  const wrapped = function(...args) {
+    const tracer = import_api2.trace.getTracer("@ryanzen9/nest-observe");
+    return invokeWithSpan(tracer, options.name ?? `${className}.${methodName}`, {
+      "code.function.name": methodName,
+      "nestjs.class": className,
+      "nestjs.method": methodName,
+      ...options.attributes
+    }, () => original.apply(this, args));
+  };
+  Object.defineProperty(wrapped, "name", { value: original.name, configurable: true });
+  markTraceDecorated(wrapped);
+  descriptor.value = wrapped;
+}
+function Trace(nameOrOptions = {}) {
+  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+  return ((target, propertyKey, descriptor) => {
+    if (propertyKey !== void 0 && descriptor) {
+      decorateMethod(target, propertyKey, descriptor, options);
+      return descriptor;
+    }
+    const prototype = target.prototype;
+    if (!prototype) return target;
+    for (const key of Object.getOwnPropertyNames(prototype)) {
+      if (key === "constructor") continue;
+      const item = Object.getOwnPropertyDescriptor(prototype, key);
+      if (!item || typeof item.value !== "function") continue;
+      decorateMethod(prototype, key, item, options);
+      Object.defineProperty(prototype, key, item);
+    }
+    return target;
+  });
+}
+
+// src/logs/nest-logger-instrumentation.ts
+var import_common = require("@nestjs/common");
+var import_api3 = require("@opentelemetry/api");
+
+// src/security/redaction.ts
+var REDACTED = "[REDACTED]";
+var SENSITIVE_KEY = /(?:authorization|proxy-authorization|cookie|set-cookie|pass(?:word|wd)?|secret|token|api[-_]?key|phone|mobile)/i;
+function isSensitiveKey(name) {
+  return SENSITIVE_KEY.test(name);
+}
+function redactText(value) {
+  return value.replace(/(?<!\d)1[3-9]\d{9}(?!\d)/g, REDACTED).replace(/\b(authorization|proxy-authorization)\s*[:=]\s*(?:bearer\s+|basic\s+)?[^\s,;]+/gi, `$1=${REDACTED}`).replace(/\b(password|passwd|secret|token|access_token|api[-_]?key|cookie)\s*[:=]\s*[^\s,;]+/gi, `$1=${REDACTED}`).replace(/\bbearer\s+[A-Za-z0-9._~+/=-]+/gi, `Bearer ${REDACTED}`);
+}
+function errorValue(error) {
+  return {
+    name: error.name,
+    message: redactText(error.message),
+    ...error.stack ? { stack: redactText(error.stack) } : {}
+  };
+}
+function visit(value, seen) {
+  if (typeof value === "string") return redactText(value);
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Error) return errorValue(value);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => visit(item, seen));
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    output[key] = SENSITIVE_KEY.test(key) ? REDACTED : visit(item, seen);
+  }
+  return output;
+}
+function redact(value) {
+  return visit(value, /* @__PURE__ */ new WeakSet());
+}
+function sanitizeHeaders(headers, allowedHeaders) {
+  const allowed = new Set(allowedHeaders.map((header) => header.toLowerCase()));
+  const output = {};
+  for (const [originalName, value] of Object.entries(headers)) {
+    const name = originalName.toLowerCase();
+    if (!allowed.has(name) || value === void 0) continue;
+    output[name] = SENSITIVE_KEY.test(name) ? REDACTED : Array.isArray(value) ? value.join(", ") : value;
+  }
+  return output;
+}
+
+// src/logs/nest-logger-instrumentation.ts
+var SEVERITY = {
+  verbose: "TRACE",
+  debug: "DEBUG",
+  log: "INFO",
+  warn: "WARN",
+  error: "ERROR",
+  fatal: "FATAL"
+};
+function bodyValue(message) {
+  if (message instanceof Error) return redactText(message.stack ?? `${message.name}: ${message.message}`);
+  return redact(message);
+}
+var NestLoggerInstrumentation = class {
+  constructor(emitter, resourceAttributes = {}) {
+    this.emitter = emitter;
+    this.resourceAttributes = resourceAttributes;
+  }
+  emitter;
+  resourceAttributes;
+  originals = /* @__PURE__ */ new Map();
+  enabled = false;
+  enable() {
+    if (this.enabled) return;
+    this.enabled = true;
+    const prototype = import_common.ConsoleLogger.prototype;
+    for (const method of Object.keys(SEVERITY)) {
+      const original = prototype[method];
+      if (typeof original !== "function") continue;
+      this.originals.set(method, original);
+      const emitter = this.emitter;
+      const resourceAttributes = this.resourceAttributes;
+      prototype[method] = function(message, ...args) {
+        try {
+          const spanContext = import_api3.trace.getActiveSpan()?.spanContext();
+          const contextName = this.context ?? (typeof args.at(-1) === "string" ? String(args.at(-1)) : void 0);
+          const attributes = { ...resourceAttributes };
+          if (contextName) attributes["nestjs.context"] = contextName;
+          if (spanContext?.traceId) attributes.trace_id = spanContext.traceId;
+          if (spanContext?.spanId) attributes.span_id = spanContext.spanId;
+          emitter.emit({
+            body: bodyValue(message),
+            severityText: SEVERITY[method],
+            attributes,
+            timestamp: Date.now()
+          });
+        } catch {
+        }
+        return original.call(this, message, ...args);
+      };
+    }
+  }
+  disable() {
+    if (!this.enabled) return;
+    const prototype = import_common.ConsoleLogger.prototype;
+    for (const [method, original] of this.originals) prototype[method] = original;
+    this.originals.clear();
+    this.enabled = false;
+  }
+};
+
+// src/logs/otel-log-emitter.ts
+var import_api4 = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var SEVERITY_NUMBER = {
+  TRACE: import_api_logs.SeverityNumber.TRACE,
+  DEBUG: import_api_logs.SeverityNumber.DEBUG,
+  INFO: import_api_logs.SeverityNumber.INFO,
+  WARN: import_api_logs.SeverityNumber.WARN,
+  ERROR: import_api_logs.SeverityNumber.ERROR,
+  FATAL: import_api_logs.SeverityNumber.FATAL
+};
+var OpenTelemetryLogEmitter = class {
+  logger;
+  constructor(name = "@ryanzen9/nest-observe", version, logger) {
+    this.logger = logger ?? import_api_logs.logs.getLogger(name, version);
+  }
+  emit(record) {
+    this.logger.emit({
+      body: record.body,
+      severityText: record.severityText,
+      severityNumber: SEVERITY_NUMBER[record.severityText],
+      attributes: record.attributes,
+      ...record.timestamp === void 0 ? {} : { timestamp: record.timestamp },
+      context: import_api4.context.active()
+    });
+  }
+};
+
+// src/instrumentation/nest-compatible-instrumentation.ts
+var import_instrumentation = require("@opentelemetry/instrumentation");
+var import_instrumentation_nestjs_core = require("@opentelemetry/instrumentation-nestjs-core");
+
+// src/nest/method-instrumenter.ts
+var NestMethodInstrumenter = class {
+  constructor(tracer, meter) {
+    this.tracer = tracer;
+    this.calls = meter.createCounter("nestjs.method.calls", { unit: "{call}" });
+    this.duration = meter.createHistogram("nestjs.method.duration", {
+      unit: "s",
+      advice: { explicitBucketBoundaries: [1e-3, 5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5] }
+    });
+    this.errors = meter.createCounter("nestjs.method.errors", { unit: "{error}" });
+  }
+  tracer;
+  calls;
+  duration;
+  errors;
+  instrumented = /* @__PURE__ */ new WeakMap();
+  instrumentInstance(instance, kind, componentName) {
+    const type = instance.constructor;
+    const prototype = Object.getPrototypeOf(instance);
+    if (!prototype) return;
+    this.instrumentTarget(instance, prototype, type, kind, componentName);
+  }
+  instrumentPrototype(type, kind, componentName) {
+    const prototype = type.prototype;
+    if (!prototype) return;
+    this.instrumentTarget(prototype, prototype, type, kind, componentName);
+  }
+  instrumentTarget(target, prototype, type, kind, componentName) {
+    if (isTraceIgnored(type)) return;
+    const completed = this.instrumented.get(target) ?? /* @__PURE__ */ new Set();
+    this.instrumented.set(target, completed);
+    for (const methodName of Object.getOwnPropertyNames(prototype)) {
+      if (methodName === "constructor" || completed.has(methodName) || methodName.startsWith("onModule")) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+      const original = descriptor?.value;
+      if (!descriptor || typeof original !== "function" || isTraceIgnored(original, type) || isTraceDecorated(original)) continue;
+      const existing = Reflect.get(target, methodName);
+      if (typeof existing === "function" && existing !== original && isTraceDecorated(existing)) continue;
+      const name = componentName || type.name || "Anonymous";
+      const attributes = {
+        [`nestjs.${kind}`]: name,
+        "nestjs.method": methodName
+      };
+      const instrumenter = this;
+      const wrapped = function(...args) {
+        instrumenter.calls.add(1, attributes);
+        return invokeWithSpan(
+          instrumenter.tracer,
+          `${name}.${methodName}`,
+          attributes,
+          () => original.apply(this, args),
+          (seconds, error) => {
+            instrumenter.duration.record(seconds, attributes);
+            if (error !== void 0) instrumenter.errors.add(1, attributes);
+          }
+        );
+      };
+      markTraceDecorated(wrapped);
+      try {
+        Object.defineProperty(target, methodName, { ...descriptor, value: wrapped });
+        completed.add(methodName);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/instrumentation/nest-compatible-instrumentation.ts
+var SUPPORTED_NEST_VERSIONS = [">=4.0.0 <13"];
+var CompatibleNestInstrumentation = class extends import_instrumentation_nestjs_core.NestInstrumentation {
+  constructor(observeConfig = {}) {
+    super(observeConfig);
+    this.observeConfig = observeConfig;
+  }
+  observeConfig;
+  methodInstrumenter;
+  init() {
+    const definition = new import_instrumentation.InstrumentationNodeModuleDefinition("@nestjs/core", SUPPORTED_NEST_VERSIONS);
+    definition.files.push(
+      this.getNestFactoryFileInstrumentation(SUPPORTED_NEST_VERSIONS),
+      this.getRouterExecutionContextFileInstrumentation(SUPPORTED_NEST_VERSIONS),
+      new import_instrumentation.InstrumentationNodeModuleFile(
+        "@nestjs/core/injector/injector.js",
+        SUPPORTED_NEST_VERSIONS,
+        (moduleExports) => {
+          const instrumentation = this;
+          this._wrap(moduleExports.Injector.prototype, "instantiateClass", (original) => {
+            return async function(...args) {
+              const instance = await original.apply(this, args);
+              try {
+                const wrapper = args[1];
+                if (!instance || typeof instance !== "object" || !wrapper?.metatype) return instance;
+                if (["InternalCoreModule", "ObserveModule", "DiscoveryModule"].includes(wrapper.host?.name ?? "")) {
+                  return instance;
+                }
+                const isController = wrapper.host?.controllers?.get(wrapper.token) === wrapper;
+                if (isController && instrumentation.observeConfig.controllerTracing === false || !isController && instrumentation.observeConfig.providerTracing === false) {
+                  return instance;
+                }
+                instrumentation.getMethodInstrumenter().instrumentInstance(
+                  instance,
+                  isController ? "controller" : "provider",
+                  wrapper.name ?? wrapper.metatype.name
+                );
+              } catch {
+              }
+              return instance;
+            };
+          });
+          return moduleExports;
+        },
+        (moduleExports) => {
+          this._unwrap(moduleExports.Injector.prototype, "instantiateClass");
+        }
+      )
+    );
+    return definition;
+  }
+  getMethodInstrumenter() {
+    return this.methodInstrumenter ??= new NestMethodInstrumenter(this.tracer, this.meter);
+  }
+};
+
+// src/metrics/http-request-metrics.ts
+function routeFor(request) {
+  const route = request.route?.path ?? request.routerPath ?? request.routeOptions?.url;
+  if (!route) return "<unmatched>";
+  return `${request.baseUrl ?? ""}${route}` || "<unmatched>";
+}
+var HttpRequestMetrics = class {
+  constructor(meter, serviceName) {
+    this.serviceName = serviceName;
+    this.requestCount = meter.createCounter("http.server.request.count", {
+      description: "Number of completed inbound HTTP requests",
+      unit: "{request}"
+    });
+    this.requestDuration = meter.createHistogram("http.server.request.duration", {
+      description: "Inbound HTTP request duration",
+      unit: "s",
+      advice: { explicitBucketBoundaries: [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10] }
+    });
+    this.errorCount = meter.createCounter("http.server.error.count", {
+      description: "Number of failed inbound HTTP requests",
+      unit: "{error}"
+    });
+  }
+  serviceName;
+  requestCount;
+  requestDuration;
+  errorCount;
+  startedAt = /* @__PURE__ */ new WeakMap();
+  start(request) {
+    this.startedAt.set(request, process.hrtime.bigint());
+  }
+  record(request, response) {
+    const statusCode = Number.isFinite(response.statusCode) ? response.statusCode : 0;
+    const attributes = {
+      "service.name": this.serviceName,
+      "http.route": routeFor(request),
+      "http.request.method": request.method ?? "UNKNOWN",
+      "http.response.status_code": statusCode
+    };
+    this.requestCount.add(1, attributes);
+    const started = this.startedAt.get(request);
+    if (started !== void 0) {
+      this.requestDuration.record(Number(process.hrtime.bigint() - started) / 1e9, attributes);
+      this.startedAt.delete(request);
+    }
+    if (statusCode >= 500) this.errorCount.add(1, attributes);
+  }
+};
+
+// src/metrics/runtime-metrics.ts
+var import_node_os = require("os");
+var import_node_perf_hooks = require("perf_hooks");
+var RuntimeMetrics = class {
+  constructor(meter) {
+    this.meter = meter;
+  }
+  meter;
+  callbacks = [];
+  eventLoopDelay;
+  gcObserver;
+  started = false;
+  previousElu = import_node_perf_hooks.performance.eventLoopUtilization();
+  observe(instrument, callback) {
+    instrument.addCallback(callback);
+    this.callbacks.push({ instrument, callback });
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    const systemCpu = this.meter.createObservableGauge("system.cpu.utilization", { unit: "1" });
+    this.observe(systemCpu, (result) => {
+      const cores = (0, import_node_os.cpus)();
+      let idle = 0;
+      let total = 0;
+      for (const core of cores) {
+        idle += core.times.idle;
+        total += Object.values(core.times).reduce((sum, value) => sum + value, 0);
+      }
+      result.observe(total ? (total - idle) / total : 0);
+    });
+    const processCpu = this.meter.createObservableCounter("process.cpu.time", { unit: "s" });
+    this.observe(processCpu, (result) => {
+      const cpu = process.cpuUsage();
+      result.observe((cpu.user + cpu.system) / 1e6);
+    });
+    const rss = this.meter.createObservableGauge("process.memory.rss", { unit: "By" });
+    const heapUsed = this.meter.createObservableGauge("nodejs.memory.heap.used", { unit: "By" });
+    const heapTotal = this.meter.createObservableGauge("nodejs.memory.heap.total", { unit: "By" });
+    this.observe(rss, (result) => result.observe(process.memoryUsage().rss));
+    this.observe(heapUsed, (result) => result.observe(process.memoryUsage().heapUsed));
+    this.observe(heapTotal, (result) => result.observe(process.memoryUsage().heapTotal));
+    this.eventLoopDelay = (0, import_node_perf_hooks.monitorEventLoopDelay)({ resolution: 20 });
+    this.eventLoopDelay.enable();
+    const delay = this.meter.createObservableGauge("nodejs.eventloop.delay", { unit: "s" });
+    this.observe(delay, (result) => {
+      const mean = this.eventLoopDelay?.mean ?? 0;
+      result.observe(Number.isFinite(mean) ? mean / 1e9 : 0);
+      this.eventLoopDelay?.reset();
+    });
+    const utilization = this.meter.createObservableGauge("nodejs.eventloop.utilization", { unit: "1" });
+    this.observe(utilization, (result) => {
+      const current = import_node_perf_hooks.performance.eventLoopUtilization(this.previousElu);
+      this.previousElu = import_node_perf_hooks.performance.eventLoopUtilization();
+      result.observe(current.utilization);
+    });
+    const gc = this.meter.createHistogram("nodejs.gc.duration", { unit: "s" });
+    this.gcObserver = new import_node_perf_hooks.PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        const detail = entry.detail;
+        gc.record(entry.duration / 1e3, { "nodejs.gc.type": String(detail?.kind ?? "unknown") });
+      }
+    });
+    try {
+      this.gcObserver.observe({ entryTypes: ["gc"] });
+    } catch {
+    }
+    const uptime = this.meter.createObservableGauge("process.uptime", { unit: "s" });
+    this.observe(uptime, (result) => result.observe(process.uptime()));
+  }
+  stop() {
+    for (const { instrument, callback } of this.callbacks) instrument.removeCallback(callback);
+    this.callbacks.length = 0;
+    this.eventLoopDelay?.disable();
+    this.eventLoopDelay = void 0;
+    this.gcObserver?.disconnect();
+    this.gcObserver = void 0;
+    this.started = false;
+  }
+};
+
+// src/nest/observe.module.ts
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_api7 = require("@opentelemetry/api");
+
+// src/sdk.ts
+var import_api_logs2 = require("@opentelemetry/api-logs");
+var import_api6 = require("@opentelemetry/api");
+var import_exporter_logs_otlp_proto = require("@opentelemetry/exporter-logs-otlp-proto");
+var import_exporter_metrics_otlp_proto = require("@opentelemetry/exporter-metrics-otlp-proto");
+var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
+var import_instrumentation2 = require("@opentelemetry/instrumentation");
+var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
+var import_instrumentation3 = require("@prisma/instrumentation");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+
+// src/exceptions/process-exception-capture.ts
+var import_api5 = require("@opentelemetry/api");
+function asError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+var ProcessExceptionCapture = class {
+  constructor(emitter) {
+    this.emitter = emitter;
+  }
+  emitter;
+  listening = false;
+  onUncaughtException = (value) => this.capture(value, "uncaughtException");
+  start() {
+    if (this.listening) return;
+    this.listening = true;
+    process.on("uncaughtExceptionMonitor", this.onUncaughtException);
+  }
+  stop() {
+    if (!this.listening) return;
+    process.off("uncaughtExceptionMonitor", this.onUncaughtException);
+    this.listening = false;
+  }
+  capture(value, source = "nestjs") {
+    try {
+      const error = asError(value);
+      const span = import_api5.trace.getActiveSpan();
+      span?.recordException(error);
+      span?.setStatus({ code: import_api5.SpanStatusCode.ERROR, message: error.message });
+      const spanContext = span?.spanContext();
+      this.emitter?.emit({
+        body: redactText(error.stack ?? error.message),
+        severityText: "ERROR",
+        attributes: {
+          "exception.type": error.name,
+          "exception.message": redactText(error.message),
+          "exception.stacktrace": redactText(error.stack ?? ""),
+          "exception.source": source,
+          ...spanContext ? { trace_id: spanContext.traceId, span_id: spanContext.spanId } : {}
+        },
+        timestamp: Date.now()
+      });
+    } catch {
+    }
+  }
+};
+
+// src/resource.ts
+var import_node_os2 = require("os");
+var import_resources = require("@opentelemetry/resources");
+var SDK_NAME = "@ryanzen9/nest-observe";
+var SDK_VERSION = "0.1.0";
+function createObserveResource(config) {
+  return (0, import_resources.defaultResource)().merge((0, import_resources.resourceFromAttributes)({
+    ...config.resourceAttributes,
+    "service.name": config.serviceName,
+    "service.version": config.serviceVersion,
+    "deployment.environment.name": config.environment,
+    "service.instance.id": config.instanceId,
+    "telemetry.sdk.name": SDK_NAME,
+    "telemetry.sdk.version": SDK_VERSION,
+    "host.name": config.resourceAttributes["host.name"] ?? (0, import_node_os2.hostname)()
+  }));
+}
+
+// src/security/span-redaction-processor.ts
+var DROP_VALUE = /(?:request\.body|db\.(?:query\.)?parameters?|db\.statement\.parameters?|redis\.(?:args|value))/i;
+function cleanValue(value) {
+  if (typeof value === "string") return redactText(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => typeof item === "string" ? redactText(item) : item);
+  }
+  return value;
+}
+function cleanAttributes(attributes) {
+  if (!attributes) return;
+  const mutable = attributes;
+  for (const [key, value] of Object.entries(mutable)) {
+    if (value === void 0) continue;
+    if (DROP_VALUE.test(key) || isSensitiveKey(key)) mutable[key] = REDACTED;
+    else mutable[key] = cleanValue(value);
+  }
+}
+var SpanRedactionProcessor = class {
+  onStart(_span, _parentContext) {
+  }
+  onEnd(span) {
+    const mutable = span;
+    try {
+      mutable.name = redactText(mutable.name);
+      cleanAttributes(mutable.attributes);
+      if (mutable.status.message) mutable.status.message = redactText(mutable.status.message);
+      for (const event of mutable.events) cleanAttributes(event.attributes);
+    } catch {
+    }
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+
+// src/sdk.ts
+var InactiveObserveHandle = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  started = false;
+  tracerProvider = void 0;
+  meterProvider = void 0;
+  loggerProvider = void 0;
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+var ActiveObserveHandle = class {
+  constructor(config, tracerProvider, meterProvider, loggerProvider, runtimeMetrics, loggerInstrumentation, exceptionCapture, instrumentations) {
+    this.config = config;
+    this.tracerProvider = tracerProvider;
+    this.meterProvider = meterProvider;
+    this.loggerProvider = loggerProvider;
+    this.runtimeMetrics = runtimeMetrics;
+    this.loggerInstrumentation = loggerInstrumentation;
+    this.exceptionCapture = exceptionCapture;
+    this.instrumentations = instrumentations;
+  }
+  config;
+  tracerProvider;
+  meterProvider;
+  loggerProvider;
+  runtimeMetrics;
+  loggerInstrumentation;
+  exceptionCapture;
+  instrumentations;
+  started = true;
+  stopped = false;
+  async forceFlush() {
+    await Promise.allSettled([
+      this.tracerProvider?.forceFlush(),
+      this.meterProvider?.forceFlush(),
+      this.loggerProvider?.forceFlush({ timeoutMillis: this.config.exportTimeoutMillis })
+    ].filter((item) => Boolean(item)));
+  }
+  async shutdown() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.loggerInstrumentation?.disable();
+    this.runtimeMetrics?.stop();
+    this.exceptionCapture.stop();
+    for (const instrumentation of this.instrumentations) {
+      try {
+        instrumentation.disable();
+      } catch {
+      }
+    }
+    await this.forceFlush();
+    await Promise.allSettled([
+      this.tracerProvider?.shutdown(),
+      this.meterProvider?.shutdown(),
+      this.loggerProvider?.shutdown()
+    ].filter((item) => Boolean(item)));
+    if (activeRuntime === this) activeRuntime = void 0;
+  }
+};
+var activeRuntime;
+function exporterConfig(url, config) {
+  return {
+    ...url ? { url } : {},
+    headers: config.headers,
+    timeoutMillis: config.exportTimeoutMillis
+  };
+}
+function createTraceProvider(config, resource) {
+  if (!config.traces && !config.metrics) return void 0;
+  const spanProcessors = [new SpanRedactionProcessor()];
+  if (config.traces) {
+    const exporter = config.exporters?.span ?? new import_exporter_trace_otlp_proto.OTLPTraceExporter(exporterConfig(config.endpoints.traces, config));
+    spanProcessors.push(new import_sdk_trace_base.BatchSpanProcessor(exporter, {
+      exportTimeoutMillis: config.exportTimeoutMillis,
+      maxQueueSize: 2048,
+      maxExportBatchSize: 512
+    }));
+  }
+  const provider = new import_sdk_trace_node.NodeTracerProvider({
+    resource,
+    sampler: config.traces ? new import_sdk_trace_base.ParentBasedSampler({ root: new import_sdk_trace_base.TraceIdRatioBasedSampler(config.sampling) }) : new import_sdk_trace_base.AlwaysOffSampler(),
+    spanProcessors,
+    spanLimits: { attributeCountLimit: 64, eventCountLimit: 64, linkCountLimit: 16 }
+  });
+  provider.register();
+  return provider;
+}
+function createMeterProvider(config, resource) {
+  if (!config.metrics) return void 0;
+  let reader;
+  if (config.exporters?.metricReader) {
+    reader = config.exporters.metricReader;
+  } else {
+    reader = new import_sdk_metrics.PeriodicExportingMetricReader({
+      exporter: new import_exporter_metrics_otlp_proto.OTLPMetricExporter(exporterConfig(config.endpoints.metrics, config)),
+      exportIntervalMillis: config.metricExportIntervalMillis,
+      exportTimeoutMillis: Math.min(config.exportTimeoutMillis, config.metricExportIntervalMillis),
+      cardinalityLimits: { default: 2e3, histogram: 2e3 }
+    });
+  }
+  const provider = new import_sdk_metrics.MeterProvider({
+    resource,
+    readers: [reader],
+    views: [{
+      instrumentName: "http.server.request.duration",
+      meterName: "@opentelemetry/instrumentation-http",
+      aggregation: { type: import_sdk_metrics.AggregationType.DROP }
+    }]
+  });
+  import_api6.metrics.setGlobalMeterProvider(provider);
+  return provider;
+}
+function createLoggerProvider(config, resource) {
+  if (!config.logs) return void 0;
+  const exporter = config.exporters?.log ?? new import_exporter_logs_otlp_proto.OTLPLogExporter(exporterConfig(config.endpoints.logs, config));
+  const provider = new import_sdk_logs.LoggerProvider({
+    resource,
+    processors: [new import_sdk_logs.BatchLogRecordProcessor({
+      exporter,
+      exportTimeoutMillis: config.exportTimeoutMillis,
+      maxQueueSize: 2048,
+      maxExportBatchSize: 512
+    })]
+  });
+  import_api_logs2.logs.setGlobalLoggerProvider(provider);
+  return provider;
+}
+function observe(options = {}) {
+  if (activeRuntime?.started) return activeRuntime;
+  const config = resolveObserveConfig(options);
+  if (!config.enabled) return new InactiveObserveHandle(config);
+  let tracerProvider;
+  let meterProvider;
+  let loggerProvider;
+  let runtimeMetrics;
+  let loggerInstrumentation;
+  let exceptionCapture;
+  const instrumentations = [];
+  try {
+    const resource = createObserveResource(config);
+    meterProvider = createMeterProvider(config, resource);
+    const meter = meterProvider?.getMeter(SDK_NAME, SDK_VERSION);
+    tracerProvider = createTraceProvider(config, resource);
+    loggerProvider = createLoggerProvider(config, resource);
+    runtimeMetrics = meter ? new RuntimeMetrics(meter) : void 0;
+    runtimeMetrics?.start();
+    const otelLogger = loggerProvider?.getLogger(SDK_NAME, SDK_VERSION);
+    const logEmitter = config.logs ? new OpenTelemetryLogEmitter(SDK_NAME, SDK_VERSION, otelLogger) : void 0;
+    loggerInstrumentation = logEmitter ? new NestLoggerInstrumentation(logEmitter, {
+      "service.name": config.serviceName,
+      "service.version": config.serviceVersion,
+      "deployment.environment.name": config.environment
+    }) : void 0;
+    loggerInstrumentation?.enable();
+    exceptionCapture = new ProcessExceptionCapture(logEmitter);
+    exceptionCapture.start();
+    if (config.traces || config.metrics) {
+      const safeHeaders = config.allowedHeaders.filter((header) => !isSensitiveKey(header));
+      const httpRequestMetrics = meter ? new HttpRequestMetrics(meter, config.serviceName) : void 0;
+      instrumentations.push(new import_instrumentation_http.HttpInstrumentation({
+        requireParentforOutgoingSpans: false,
+        headersToSpanAttributes: {
+          client: { requestHeaders: safeHeaders, responseHeaders: safeHeaders },
+          server: { requestHeaders: safeHeaders, responseHeaders: safeHeaders }
+        },
+        redactedQueryParams: [
+          "sig",
+          "Signature",
+          "AWSAccessKeyId",
+          "X-Goog-Signature",
+          "password",
+          "passwd",
+          "token",
+          "access_token",
+          "api_key",
+          "secret"
+        ],
+        ...httpRequestMetrics ? {
+          requestHook: (_span, request) => {
+            if (!("getHeader" in request)) httpRequestMetrics.start(request);
+          },
+          applyCustomAttributesOnSpan: (_span, request, response) => {
+            if ("setHeader" in response) httpRequestMetrics.record(request, response);
+          }
+        } : {}
+      }));
+      instrumentations.push(new CompatibleNestInstrumentation({
+        providerTracing: config.providerTracing,
+        controllerTracing: config.controllerTracing
+      }));
+      if (config.traces) instrumentations.push(new import_instrumentation3.PrismaInstrumentation());
+      (0, import_instrumentation2.registerInstrumentations)({
+        instrumentations,
+        ...tracerProvider ? { tracerProvider } : {},
+        ...meterProvider ? { meterProvider } : {}
+      });
+    }
+    const runtime = new ActiveObserveHandle(
+      config,
+      tracerProvider,
+      meterProvider,
+      loggerProvider,
+      runtimeMetrics,
+      loggerInstrumentation,
+      exceptionCapture,
+      instrumentations
+    );
+    activeRuntime = runtime;
+    return runtime;
+  } catch {
+    loggerInstrumentation?.disable();
+    runtimeMetrics?.stop();
+    exceptionCapture?.stop();
+    for (const instrumentation of instrumentations) {
+      try {
+        instrumentation.disable();
+      } catch {
+      }
+    }
+    void Promise.allSettled([
+      tracerProvider?.shutdown(),
+      meterProvider?.shutdown(),
+      loggerProvider?.shutdown()
+    ].filter((item) => Boolean(item)));
+    return new InactiveObserveHandle(config);
+  }
+}
+function getObserveRuntime() {
+  return activeRuntime;
+}
+
+// src/nest/observe.module.ts
+var OBSERVE_OPTIONS = /* @__PURE__ */ Symbol("OBSERVE_OPTIONS");
+var OBSERVE_HANDLE = /* @__PURE__ */ Symbol("OBSERVE_HANDLE");
+var NestObserveExplorer = class {
+  constructor(discovery, options, handle) {
+    this.discovery = discovery;
+    this.options = options;
+    this.handle = handle;
+  }
+  discovery;
+  options;
+  handle;
+  onModuleInit() {
+    if (!this.handle.started) return;
+    const runtime = getObserveRuntime();
+    const tracer = runtime?.tracerProvider?.getTracer(SDK_NAME, SDK_VERSION) ?? import_api7.trace.getTracer(SDK_NAME, SDK_VERSION);
+    const meter = runtime?.meterProvider?.getMeter(SDK_NAME, SDK_VERSION) ?? import_api7.metrics.getMeter(SDK_NAME, SDK_VERSION);
+    const instrumenter = new NestMethodInstrumenter(tracer, meter);
+    if (this.options.providerTracing !== false) {
+      this.instrument(this.discovery.getProviders(), instrumenter, "provider");
+    }
+    if (this.options.controllerTracing !== false) {
+      this.instrument(this.discovery.getControllers(), instrumenter, "controller");
+    }
+  }
+  instrument(wrappers, instrumenter, kind) {
+    for (const wrapper of wrappers) {
+      if (!wrapper.metatype) continue;
+      if (["ObserveModule", "DiscoveryModule", "InternalCoreModule"].includes(wrapper.host?.name ?? "")) continue;
+      if (wrapper.metatype === NestObserveExplorer) continue;
+      if (wrapper.instance) {
+        instrumenter.instrumentInstance(wrapper.instance, kind, wrapper.name ?? wrapper.metatype.name);
+      } else {
+        instrumenter.instrumentPrototype(wrapper.metatype, kind, wrapper.name ?? wrapper.metatype.name);
+      }
+    }
+  }
+  async onApplicationShutdown() {
+    await this.handle.shutdown();
+  }
+};
+NestObserveExplorer = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_common2.Inject)(import_core.DiscoveryService)),
+  __decorateParam(1, (0, import_common2.Inject)(OBSERVE_OPTIONS)),
+  __decorateParam(2, (0, import_common2.Inject)(OBSERVE_HANDLE))
+], NestObserveExplorer);
+var ObserveModule = class {
+  static forRoot(options = {}) {
+    return {
+      module: ObserveModule,
+      global: true,
+      imports: [import_core.DiscoveryModule],
+      providers: [
+        { provide: OBSERVE_OPTIONS, useValue: options },
+        { provide: OBSERVE_HANDLE, useFactory: () => observe(options) },
+        NestObserveExplorer
+      ],
+      exports: [OBSERVE_HANDLE]
+    };
+  }
+};
+ObserveModule = __decorateClass([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({})
+], ObserveModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompatibleNestInstrumentation,
+  HttpRequestMetrics,
+  IgnoreTrace,
+  NestLoggerInstrumentation,
+  NestMethodInstrumenter,
+  OBSERVE_HANDLE,
+  OBSERVE_OPTIONS,
+  ObserveModule,
+  OpenTelemetryLogEmitter,
+  REDACTED,
+  RuntimeMetrics,
+  SDK_NAME,
+  SDK_VERSION,
+  SpanRedactionProcessor,
+  Trace,
+  createObserveResource,
+  getObserveRuntime,
+  isSensitiveKey,
+  isTraceDecorated,
+  isTraceIgnored,
+  markTraceDecorated,
+  markTraceIgnored,
+  observe,
+  parseKeyValueList,
+  redact,
+  redactText,
+  resolveObserveConfig,
+  sanitizeHeaders
+});
+//# sourceMappingURL=index.js.map