@ryanzeng/nest-observe 0.1.0

package/dist/register.js

@@ -0,0 +1,891 @@
+"use strict";
+
+// src/sdk.ts
+var import_api_logs2 = require("@opentelemetry/api-logs");
+var import_api5 = 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/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/exceptions/process-exception-capture.ts
+var import_api = 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());
+}
+
+// src/exceptions/process-exception-capture.ts
+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_api.trace.getActiveSpan();
+      span?.recordException(error);
+      span?.setStatus({ code: import_api.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/instrumentation/nest-compatible-instrumentation.ts
+var import_instrumentation = require("@opentelemetry/instrumentation");
+var import_instrumentation_nestjs_core = require("@opentelemetry/instrumentation-nestjs-core");
+
+// src/decorators/invoke.ts
+var import_api2 = 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_api2.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_api2.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_api2.context.active();
+        const source = result;
+        return new import_rxjs.Observable((subscriber) => import_api2.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/metadata.ts
+var ignoredTargets = /* @__PURE__ */ new WeakSet();
+var tracedTargets = /* @__PURE__ */ new WeakSet();
+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/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/logs/nest-logger-instrumentation.ts
+var import_common = require("@nestjs/common");
+var import_api3 = require("@opentelemetry/api");
+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/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/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_api5.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);
+  }
+}
+
+// src/register.ts
+observe();
+//# sourceMappingURL=register.js.map