@sebspark/otel 1.1.4 → 2.0.0

package/dist/index.js

@@ -1,57 +1,19 @@
-"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 __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, {
-  SpanStatusCode: () => import_api7.SpanStatusCode,
-  context: () => import_api7.context,
-  getLogger: () => getLogger,
-  getMeter: () => getMeter,
-  getTracer: () => getTracer,
-  initialize: () => initialize,
-  instrumentations: () => instrumentations,
-  isInitialized: () => isInitialized
-});
-module.exports = __toCommonJS(index_exports);
-var import_api7 = require("@opentelemetry/api");
+import {
+  context as context4,
+  SpanStatusCode as SpanStatusCode4
+} from "@opentelemetry/api";
 
 // src/instrumentations.ts
-var import_instrumentation_dns = require("@opentelemetry/instrumentation-dns");
-var import_instrumentation_express = require("@opentelemetry/instrumentation-express");
-var import_instrumentation_fs = require("@opentelemetry/instrumentation-fs");
-var import_instrumentation_grpc = require("@opentelemetry/instrumentation-grpc");
-var import_instrumentation_http = require("@opentelemetry/instrumentation-http");
-var import_instrumentation_net = require("@opentelemetry/instrumentation-net");
-var import_instrumentation_redis = require("@opentelemetry/instrumentation-redis");
-var import_instrumentation_socket = require("@opentelemetry/instrumentation-socket.io");
-var import_instrumentation_undici = require("@opentelemetry/instrumentation-undici");
+import { DnsInstrumentation } from "@opentelemetry/instrumentation-dns";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { FsInstrumentation } from "@opentelemetry/instrumentation-fs";
+import { GrpcInstrumentation } from "@opentelemetry/instrumentation-grpc";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { NetInstrumentation } from "@opentelemetry/instrumentation-net";
+import { RedisInstrumentation } from "@opentelemetry/instrumentation-redis";
+import { SocketIoInstrumentation } from "@opentelemetry/instrumentation-socket.io";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
 var _http;
 var _express;
 var _grpc;
@@ -64,63 +26,63 @@ var _socketIo;
 var instrumentations = {
   get http() {
     if (!_http) {
-      _http = new import_instrumentation_http.HttpInstrumentation();
+      _http = new HttpInstrumentation();
     }
     return _http;
   },
   get express() {
     if (!_express) {
-      _express = new import_instrumentation_express.ExpressInstrumentation();
+      _express = new ExpressInstrumentation();
     }
     return _express;
   },
   get grpc() {
     if (!_grpc) {
-      _grpc = new import_instrumentation_grpc.GrpcInstrumentation();
+      _grpc = new GrpcInstrumentation();
     }
     return _grpc;
   },
   get redis() {
     if (!_redis) {
-      _redis = new import_instrumentation_redis.RedisInstrumentation();
+      _redis = new RedisInstrumentation();
     }
     return _redis;
   },
   get dns() {
     if (!_dns) {
-      _dns = new import_instrumentation_dns.DnsInstrumentation();
+      _dns = new DnsInstrumentation();
     }
     return _dns;
   },
   get net() {
     if (!_net) {
-      _net = new import_instrumentation_net.NetInstrumentation();
+      _net = new NetInstrumentation();
     }
     return _net;
   },
   get fs() {
     if (!_fs) {
-      _fs = new import_instrumentation_fs.FsInstrumentation();
+      _fs = new FsInstrumentation();
     }
     return _fs;
   },
   get undici() {
     if (!_undici) {
-      _undici = new import_instrumentation_undici.UndiciInstrumentation();
+      _undici = new UndiciInstrumentation();
     }
     return _undici;
   },
   get socketIo() {
     if (!_socketIo) {
-      _socketIo = new import_instrumentation_socket.SocketIoInstrumentation();
+      _socketIo = new SocketIoInstrumentation();
     }
     return _socketIo;
   }
 };
 
 // src/logger.ts
-var import_api4 = require("@opentelemetry/api");
-var import_api_logs3 = require("@opentelemetry/api-logs");
+import { context as context2, trace as trace2 } from "@opentelemetry/api";
+import { logs as logs2 } from "@opentelemetry/api-logs";
 
 // src/consts.ts
 var LOG_SEVERITY_MAP = {
@@ -138,44 +100,59 @@ var LOG_SEVERITY_MAP = {
 };
 
 // src/otel.ts
-var import_api3 = require("@opentelemetry/api");
-var import_api_logs2 = require("@opentelemetry/api-logs");
-var import_sdk_node = require("@opentelemetry/sdk-node");
+import {
+  context,
+  DiagConsoleLogger,
+  DiagLogLevel,
+  diag,
+  metrics,
+  trace
+} from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { NodeSDK } from "@opentelemetry/sdk-node";
 
 // src/providers.ts
-var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
-var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
-var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-var import_sdk_logs = require("@opentelemetry/sdk-logs");
-var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider,
+  SimpleLogRecordProcessor
+} from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor
+} from "@opentelemetry/sdk-trace-node";
 
-// src/loggers/console-log-pretty-exporter.ts
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_core = require("@opentelemetry/core");
+// src/loggers/console-metric-pretty-exporter.ts
+import { ExportResultCode } from "@opentelemetry/core";
 
 // src/loggers/formatters/shared.ts
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-var import_fast_safe_stringify = __toESM(require("fast-safe-stringify"));
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import fss from "fast-safe-stringify";
 
 // src/loggers/formatters/style.ts
-var import_kleur = __toESM(require("kleur"));
+import kleur from "kleur";
 var colors = {
-  gray: import_kleur.default.gray,
-  dim: import_kleur.default.dim,
-  cyan: import_kleur.default.cyan,
-  white: import_kleur.default.white,
-  green: import_kleur.default.green,
-  yellow: import_kleur.default.yellow,
-  red: import_kleur.default.red,
-  magenta: import_kleur.default.magenta
+  gray: kleur.gray,
+  dim: kleur.dim,
+  cyan: kleur.cyan,
+  white: kleur.white,
+  green: kleur.green,
+  yellow: kleur.yellow,
+  red: kleur.red,
+  magenta: kleur.magenta
 };
 var levelColorMap = {
-  DEBUG: import_kleur.default.magenta,
-  INFO: import_kleur.default.green,
-  WARN: import_kleur.default.yellow,
-  ERROR: import_kleur.default.red,
-  FATAL: import_kleur.default.red
+  DEBUG: kleur.magenta,
+  INFO: kleur.green,
+  WARN: kleur.yellow,
+  ERROR: kleur.red,
+  FATAL: kleur.red
 };
 var levelIconMap = {
   DEBUG: "\u{1F41B}",
@@ -211,13 +188,14 @@ var kindColorMap = {
 };
 
 // src/loggers/formatters/shared.ts
+var stringify = fss.default.stableStringify;
 function formatTimestamp(time) {
   const date = new Date(hrTimeToMillis(time));
   return colors.dim(date.toISOString().slice(11, 23));
 }
 function formatService(resource) {
-  const name = resource.attributes[import_semantic_conventions.ATTR_SERVICE_NAME] ?? "unknown-service";
-  const version = resource.attributes[import_semantic_conventions.ATTR_SERVICE_VERSION] ?? "1.0.0";
+  const name = resource.attributes[ATTR_SERVICE_NAME] ?? "unknown-service";
+  const version = resource.attributes[ATTR_SERVICE_VERSION] ?? "1.0.0";
   return colors.gray(`[${name}@${version}]`);
 }
 function formatLevel(record) {
@@ -235,7 +213,7 @@ function formatScope(resource, instrumentationScope) {
   return colors.cyan(`${scopeLabel}${versionLabel} `);
 }
 function formatMessage(record) {
-  return typeof record.body === "string" ? record.body : (0, import_fast_safe_stringify.default)(record.body);
+  return typeof record.body === "string" ? record.body : stringify(record.body);
 }
 function formatAttributes(attrs) {
   const keys = Object.keys(attrs).filter(
@@ -244,7 +222,7 @@ function formatAttributes(attrs) {
   if (keys.length === 0) return "";
   const formatted = keys.map((k) => {
     const val = attrs[k];
-    return `${k}=${typeof val === "object" ? (0, import_fast_safe_stringify.default)(val) : val}`;
+    return `${k}=${typeof val === "object" ? stringify(val) : val}`;
   });
   return `  ${colors.gray(formatted.join(" "))}`;
 }
@@ -307,7 +285,7 @@ function isHistogramLike(val) {
 }
 
 // src/loggers/formatters/span.ts
-var import_api = require("@opentelemetry/api");
+import { SpanStatusCode } from "@opentelemetry/api";
 var LABEL_WIDTH = 20;
 var DESCRIPTION_MAX_WIDTH = 16;
 var BAR_MIN_WIDTH = 1;
@@ -337,7 +315,7 @@ function formatSpans(spans) {
 function formatSpan(span, opts) {
   const label = formatLabel(span, opts.depth);
   const bar = buildBar(span, opts?.offsetMs, opts?.totalDurationMs);
-  const barColor = span.status.code === import_api.SpanStatusCode.OK ? colors.green : span.status.code === import_api.SpanStatusCode.ERROR ? colors.red : colors.gray;
+  const barColor = span.status.code === SpanStatusCode.OK ? colors.green : span.status.code === SpanStatusCode.ERROR ? colors.red : colors.gray;
   const desc = formatDescription(span);
   const status = formatStatus(span);
   const duration = formatDuration(span, opts?.offsetMs);
@@ -464,7 +442,55 @@ function computeDepth(span, allSpans) {
   return depth;
 }
 
+// src/loggers/console-metric-pretty-exporter.ts
+var ConsoleMetricPrettyExporter = class {
+  patterns;
+  constructor() {
+    const raw = process.env.METRIC_FILTER ?? "";
+    const entries = raw.split(",").map((e) => e.trim()).filter(Boolean);
+    this.patterns = entries.map(globToRegex);
+  }
+  filterMetrics(resourceMetrics) {
+    if (this.patterns.length === 0) return void 0;
+    const filteredScopes = resourceMetrics.scopeMetrics.map((scopeMetric) => {
+      const filteredMetrics = scopeMetric.metrics.filter(
+        (metric) => this.patterns.some((pattern) => pattern.test(metric.descriptor.name))
+      );
+      if (filteredMetrics.length === 0) return void 0;
+      return {
+        ...scopeMetric,
+        metrics: filteredMetrics
+      };
+    }).filter((s) => s !== void 0);
+    if (filteredScopes.length === 0) return void 0;
+    return {
+      ...resourceMetrics,
+      scopeMetrics: filteredScopes
+    };
+  }
+  export(metrics3, resultCallback) {
+    const filtered = this.filterMetrics(metrics3);
+    if (filtered) {
+      console.log(formatMetrics(filtered));
+    }
+    resultCallback({ code: ExportResultCode.SUCCESS });
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+};
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regex = `^${escaped.replace(/\*/g, ".*")}$`;
+  return new RegExp(regex);
+}
+
 // src/loggers/console-log-pretty-exporter.ts
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ExportResultCode as ExportResultCode2 } from "@opentelemetry/core";
 var ConsoleLogPrettyExporter = class {
   logThreshold;
   constructor() {
@@ -485,42 +511,42 @@ var ConsoleLogPrettyExporter = class {
     for (const record of logRecords) {
       if ((record.severityNumber ?? 0) >= this.logThreshold) {
         const formatted = formatLogRecord(record);
-        const severity = record.severityNumber || import_api_logs.SeverityNumber.UNSPECIFIED;
-        if (severity >= import_api_logs.SeverityNumber.ERROR) {
+        const severity = record.severityNumber || SeverityNumber.UNSPECIFIED;
+        if (severity >= SeverityNumber.ERROR) {
           console.error(formatted);
-        } else if (severity >= import_api_logs.SeverityNumber.WARN) {
+        } else if (severity >= SeverityNumber.WARN) {
           console.warn(formatted);
-        } else if (severity >= import_api_logs.SeverityNumber.INFO) {
+        } else if (severity >= SeverityNumber.INFO) {
           console.info(formatted);
-        } else if (severity >= import_api_logs.SeverityNumber.DEBUG) {
+        } else if (severity >= SeverityNumber.DEBUG) {
           console.debug(formatted);
         } else {
           console.trace(formatted);
         }
       }
     }
-    done?.({ code: import_core.ExportResultCode.SUCCESS });
+    done?.({ code: ExportResultCode2.SUCCESS });
   }
 };
 
 // src/loggers/console-span-pretty-exporter.ts
-var import_api2 = require("@opentelemetry/api");
-var import_core2 = require("@opentelemetry/core");
+import { SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+import { ExportResultCode as ExportResultCode3 } from "@opentelemetry/core";
 var ConsoleSpanPrettyExporter = class {
   allowedStatuses;
   constructor() {
     const env = process.env.SPAN_LEVEL?.toUpperCase();
     if (!env) {
       this.allowedStatuses = /* @__PURE__ */ new Set([
-        import_api2.SpanStatusCode.UNSET,
-        import_api2.SpanStatusCode.OK,
-        import_api2.SpanStatusCode.ERROR
+        SpanStatusCode2.UNSET,
+        SpanStatusCode2.OK,
+        SpanStatusCode2.ERROR
       ]);
     } else {
       const map = {
-        UNSET: import_api2.SpanStatusCode.UNSET,
-        OK: import_api2.SpanStatusCode.OK,
-        ERROR: import_api2.SpanStatusCode.ERROR
+        UNSET: SpanStatusCode2.UNSET,
+        OK: SpanStatusCode2.OK,
+        ERROR: SpanStatusCode2.ERROR
       };
       this.allowedStatuses = new Set(
         env.split(",").map((s) => s.trim()).map((s) => map[s]).filter((v) => typeof v === "number")
@@ -537,60 +563,13 @@ var ConsoleSpanPrettyExporter = class {
     if (this.shouldExport(spans)) {
       console.log(formatSpans(spans));
     }
-    resultCallback({ code: import_core2.ExportResultCode.SUCCESS });
+    resultCallback({ code: ExportResultCode3.SUCCESS });
   }
   shutdown() {
     return Promise.resolve();
   }
 };
 
-// src/loggers/console-metric-pretty-exporter.ts
-var import_core3 = require("@opentelemetry/core");
-var ConsoleMetricPrettyExporter = class {
-  patterns;
-  constructor() {
-    const raw = process.env.METRIC_FILTER ?? "";
-    const entries = raw.split(",").map((e) => e.trim()).filter(Boolean);
-    this.patterns = entries.map(globToRegex);
-  }
-  filterMetrics(resourceMetrics) {
-    if (this.patterns.length === 0) return void 0;
-    const filteredScopes = resourceMetrics.scopeMetrics.map((scopeMetric) => {
-      const filteredMetrics = scopeMetric.metrics.filter(
-        (metric) => this.patterns.some((pattern) => pattern.test(metric.descriptor.name))
-      );
-      if (filteredMetrics.length === 0) return void 0;
-      return {
-        ...scopeMetric,
-        metrics: filteredMetrics
-      };
-    }).filter((s) => s !== void 0);
-    if (filteredScopes.length === 0) return void 0;
-    return {
-      ...resourceMetrics,
-      scopeMetrics: filteredScopes
-    };
-  }
-  export(metrics3, resultCallback) {
-    const filtered = this.filterMetrics(metrics3);
-    if (filtered) {
-      console.log(formatMetrics(filtered));
-    }
-    resultCallback({ code: import_core3.ExportResultCode.SUCCESS });
-  }
-  shutdown() {
-    return Promise.resolve();
-  }
-  forceFlush() {
-    return Promise.resolve();
-  }
-};
-function globToRegex(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const regex = `^${escaped.replace(/\*/g, ".*")}$`;
-  return new RegExp(regex);
-}
-
 // src/loggers/tree-span-processor.ts
 var TreeSpanProcessor = class {
   exporter;
@@ -638,51 +617,61 @@ var TreeSpanProcessor = class {
 // src/providers.ts
 var getLogProvider = (resource, otlpEndpoint) => {
   if (otlpEndpoint) {
-    const exporter2 = new import_exporter_logs_otlp_http.OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` });
+    const exporter2 = new OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` });
     const processors = [
-      new import_sdk_logs.BatchLogRecordProcessor(exporter2)
+      new BatchLogRecordProcessor(exporter2)
     ];
     if (process.env.LOG_LEVEL) {
       processors.push(
-        new import_sdk_logs.SimpleLogRecordProcessor(new ConsoleLogPrettyExporter())
+        new SimpleLogRecordProcessor(new ConsoleLogPrettyExporter())
       );
     }
-    return new import_sdk_logs.LoggerProvider({
+    return new LoggerProvider({
       resource,
       processors
     });
   }
   const exporter = new ConsoleLogPrettyExporter();
-  const processor = new import_sdk_logs.SimpleLogRecordProcessor(exporter);
-  return new import_sdk_logs.LoggerProvider({
+  const processor = new SimpleLogRecordProcessor(exporter);
+  return new LoggerProvider({
     resource,
     processors: [processor]
   });
 };
 var getSpanProcessor = (otlpEndpoint) => {
-  const exporter = otlpEndpoint ? new import_exporter_trace_otlp_http.OTLPTraceExporter({
+  const exporter = otlpEndpoint ? new OTLPTraceExporter({
     url: `${otlpEndpoint}/v1/traces`
   }) : new ConsoleSpanPrettyExporter();
-  const processor = otlpEndpoint ? new import_sdk_trace_node.BatchSpanProcessor(exporter) : new TreeSpanProcessor(exporter);
+  const processor = otlpEndpoint ? new BatchSpanProcessor(exporter) : new TreeSpanProcessor(exporter);
   return processor;
 };
 var getMetricReader = (otlpEndpoint) => {
-  const metricExporter = otlpEndpoint ? new import_exporter_metrics_otlp_http.OTLPMetricExporter({
+  const metricExporter = otlpEndpoint ? new OTLPMetricExporter({
     url: `${otlpEndpoint}/v1/metrics`
   }) : new ConsoleMetricPrettyExporter();
-  const metricReader = new import_sdk_metrics.PeriodicExportingMetricReader({
+  const metricReader = new PeriodicExportingMetricReader({
     exporter: metricExporter
   });
   return metricReader;
 };
 
 // src/resource.ts
-var import_resource_detector_container = require("@opentelemetry/resource-detector-container");
-var import_resource_detector_gcp = require("@opentelemetry/resource-detector-gcp");
-var import_resources = require("@opentelemetry/resources");
+import { containerDetector } from "@opentelemetry/resource-detector-container";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import {
+  detectResources,
+  envDetector,
+  osDetector,
+  processDetector,
+  resourceFromAttributes,
+  serviceInstanceIdDetector
+} from "@opentelemetry/resources";
 
 // src/otel-context.ts
-var import_semantic_conventions2 = require("@opentelemetry/semantic-conventions");
+import {
+  ATTR_SERVICE_NAME as ATTR_SERVICE_NAME2,
+  ATTR_SERVICE_VERSION as ATTR_SERVICE_VERSION2
+} from "@opentelemetry/semantic-conventions";
 function detectTelemetryContext(componentNameOverride) {
   const {
     OTEL_SERVICE_NAME,
@@ -702,8 +691,8 @@ function detectTelemetryContext(componentNameOverride) {
   const systemVersion = OTEL_SERVICE_VERSION || "1.0.0";
   const componentName = componentNameOverride || void 0;
   const resourceAttributes = {
-    [import_semantic_conventions2.ATTR_SERVICE_NAME]: systemName,
-    [import_semantic_conventions2.ATTR_SERVICE_VERSION]: systemVersion,
+    [ATTR_SERVICE_NAME2]: systemName,
+    [ATTR_SERVICE_VERSION2]: systemVersion,
     "serviceContext.service": systemName,
     "serviceContext.version": systemVersion,
     ...K_SERVICE && { "cloud.run.service": K_SERVICE },
@@ -726,21 +715,21 @@ function detectTelemetryContext(componentNameOverride) {
 
 // src/resource.ts
 var getResource = async () => {
-  const baseRes = await (0, import_resources.detectResources)({
+  const baseRes = await detectResources({
     detectors: [
-      import_resource_detector_container.containerDetector,
-      import_resources.envDetector,
-      import_resource_detector_gcp.gcpDetector,
-      import_resources.osDetector,
-      import_resources.processDetector,
-      import_resources.serviceInstanceIdDetector
+      containerDetector,
+      envDetector,
+      gcpDetector,
+      osDetector,
+      processDetector,
+      serviceInstanceIdDetector
     ]
   });
   if (baseRes.waitForAsyncAttributes) {
     await baseRes.waitForAsyncAttributes();
   }
   const { resourceAttributes } = detectTelemetryContext();
-  const customRes = (0, import_resources.resourceFromAttributes)(resourceAttributes);
+  const customRes = resourceFromAttributes(resourceAttributes);
   const resource = baseRes.merge(customRes);
   if (resource.waitForAsyncAttributes) {
     await resource.waitForAsyncAttributes();
@@ -749,8 +738,8 @@ var getResource = async () => {
 };
 
 // src/otel.ts
-import_api3.diag.disable();
-import_api3.diag.setLogger(new import_api3.DiagConsoleLogger(), import_api3.DiagLogLevel.ERROR);
+diag.disable();
+diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR);
 var initialization;
 var _isInitialized = false;
 async function initialize(...instrumentations2) {
@@ -770,15 +759,15 @@ async function _initialize(instrumentations2) {
     const serviceName = process.env.OTEL_SERVICE_NAME ?? "unknown-service";
     const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
     const resource = await getResource();
-    import_api3.context.disable();
-    import_api_logs2.logs.disable();
-    import_api3.trace.disable();
-    import_api3.metrics.disable();
+    context.disable();
+    logs.disable();
+    trace.disable();
+    metrics.disable();
     const logProvider = getLogProvider(resource, otlpEndpoint);
-    import_api_logs2.logs.setGlobalLoggerProvider(logProvider);
+    logs.setGlobalLoggerProvider(logProvider);
     const spanProcessor = getSpanProcessor(otlpEndpoint);
     const metricReader = getMetricReader(otlpEndpoint);
-    const sdk = new import_sdk_node.NodeSDK({
+    const sdk = new NodeSDK({
       spanProcessor,
       metricReader,
       instrumentations: instrumentations2,
@@ -810,8 +799,8 @@ function getLogger(serviceOverride, extraAttrs = {}) {
       console.log(`[${severityText}] ${body}`);
       return;
     }
-    const logger = import_api_logs3.logs.getLogger(systemName, systemVersion);
-    const span = import_api4.trace.getSpan(import_api4.context.active());
+    const logger = logs2.getLogger(systemName, systemVersion);
+    const span = trace2.getSpan(context2.active());
     const spanContext = span?.spanContext();
     logger.emit({
       severityText,
@@ -851,7 +840,7 @@ function getLogger(serviceOverride, extraAttrs = {}) {
 }
 
 // src/metrics.ts
-var import_api5 = require("@opentelemetry/api");
+import { metrics as metrics2 } from "@opentelemetry/api";
 function getMeter(componentNameOverride) {
   if (!isInitialized() && process.env.NODE_ENV !== "test") {
     console.warn("OTEL must be initialized before using getMeter()");
@@ -859,11 +848,15 @@ function getMeter(componentNameOverride) {
   const { componentName, systemName, systemVersion } = detectTelemetryContext(
     componentNameOverride
   );
-  return import_api5.metrics.getMeter(componentName ?? systemName, systemVersion);
+  return metrics2.getMeter(componentName ?? systemName, systemVersion);
 }
 
 // src/tracer.ts
-var import_api6 = require("@opentelemetry/api");
+import {
+  context as context3,
+  SpanStatusCode as SpanStatusCode3,
+  trace as trace3
+} from "@opentelemetry/api";
 function getTracer(componentNameOverride) {
   if (!isInitialized() && process.env.NODE_ENV !== "test") {
     console.warn("OTEL must be initialized before calling getTracer()");
@@ -871,7 +864,7 @@ function getTracer(componentNameOverride) {
   const { componentName, systemName, systemVersion } = detectTelemetryContext(
     componentNameOverride
   );
-  const tracer = import_api6.trace.getTracer(
+  const tracer = trace3.getTracer(
     componentName ?? systemName,
     systemVersion
   );
@@ -881,16 +874,16 @@ function getTracer(componentNameOverride) {
       spanOrFunc,
       func
     );
-    const parentContext = parent ? import_api6.trace.setSpan(import_api6.context.active(), parent) : import_api6.context.active();
+    const parentContext = parent ? trace3.setSpan(context3.active(), parent) : context3.active();
     const span = tracer.startSpan(name, options, parentContext);
-    return await import_api6.context.with(import_api6.trace.setSpan(parentContext, span), async () => {
+    return await context3.with(trace3.setSpan(parentContext, span), async () => {
       try {
         const result = await fn(span);
-        span.setStatus({ code: import_api6.SpanStatusCode.OK });
+        span.setStatus({ code: SpanStatusCode3.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: SpanStatusCode3.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -904,16 +897,16 @@ function getTracer(componentNameOverride) {
       spanOrFunc,
       func
     );
-    const parentContext = parent ? import_api6.trace.setSpan(import_api6.context.active(), parent) : import_api6.context.active();
+    const parentContext = parent ? trace3.setSpan(context3.active(), parent) : context3.active();
     const span = tracer.startSpan(name, options, parentContext);
-    return import_api6.context.with(import_api6.trace.setSpan(parentContext, span), () => {
+    return context3.with(trace3.setSpan(parentContext, span), () => {
       try {
         const result = fn(span);
-        span.setStatus({ code: import_api6.SpanStatusCode.OK });
+        span.setStatus({ code: SpanStatusCode3.OK });
         return result;
       } catch (err) {
         const error = err;
-        span.setStatus({ code: import_api6.SpanStatusCode.ERROR, message: error.message });
+        span.setStatus({ code: SpanStatusCode3.ERROR, message: error.message });
         span.recordException?.(error);
         throw err;
       } finally {
@@ -949,14 +942,13 @@ function extractArgs(spanOptionsSpanOrFunc, spanOrFunc, func) {
 var isFunction = (value) => typeof value === "function";
 var isSpan = (value) => value !== null && value !== void 0 && isFunction(value.spanContext) && isFunction(value.end);
 var isSpanOptions = (value) => value !== null && value !== void 0 && (!!value.startTime || !!value.attributes || !!value.kind) && !isSpan(value);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SpanStatusCode,
-  context,
+export {
+  SpanStatusCode4 as SpanStatusCode,
+  context4 as context,
   getLogger,
   getMeter,
   getTracer,
   initialize,
   instrumentations,
   isInitialized
-});
+};