autotel 2.1.0

package/dist/index.js

@@ -0,0 +1,143 @@
+import { resetMetrics } from './chunk-2LNRY4QK.js';
+export { Metric, getMetrics, resetMetrics } from './chunk-2LNRY4QK.js';
+import './chunk-5ZN622AO.js';
+export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from './chunk-W7LHZVQF.js';
+export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-BWYGJKRB.js';
+import { resetEventQueue, getEventQueue } from './chunk-RJYY7BWX.js';
+export { ctx, instrument, span, trace, track, withBaggage, withNewContext, withTracing } from './chunk-RJYY7BWX.js';
+export { createDeterministicTraceId, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTracer, runWithSpan } from './chunk-M4ANN7RL.js';
+import { init_trace_context } from './chunk-HCCXC7XG.js';
+export { defineBaggageSchema } from './chunk-HCCXC7XG.js';
+import { resetEvents } from './chunk-WFJ7L2RV.js';
+export { Event, getEvents, resetEvents } from './chunk-WFJ7L2RV.js';
+import './chunk-LITNXTTT.js';
+import './chunk-BZHG5IZ4.js';
+export { getOperationContext, runInOperationContext } from './chunk-UL33I6IS.js';
+import { getLogger, getSdk } from './chunk-3HENGDW2.js';
+export { BaggageSpanProcessor, init } from './chunk-3HENGDW2.js';
+import './chunk-X4RMFFMR.js';
+export { AdaptiveSampler, AlwaysSampler, NeverSampler, RandomSampler, UserIdSampler } from './chunk-5R2M36QB.js';
+import './chunk-5GWX5LFW.js';
+import './chunk-KVGNW3FC.js';
+export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from './chunk-P6JUDYNO.js';
+import './chunk-Z6ZWNWWR.js';
+export { SpanKind, SpanStatusCode, context, trace as otelTrace, propagation } from '@opentelemetry/api';
+
+// src/shutdown.ts
+async function flush(options) {
+  const timeout = options?.timeout ?? 2e3;
+  const doFlush = async () => {
+    const eventsQueue = getEventQueue();
+    if (eventsQueue) {
+      await eventsQueue.flush();
+    }
+    const sdk = getSdk();
+    if (sdk) {
+      try {
+        const sdkAny = sdk;
+        if (typeof sdkAny.getTracerProvider === "function") {
+          const tracerProvider = sdkAny.getTracerProvider();
+          if (tracerProvider && typeof tracerProvider.forceFlush === "function") {
+            await tracerProvider.forceFlush();
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  let timeoutHandle;
+  try {
+    await Promise.race([
+      doFlush().finally(() => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+      }),
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error("Flush timeout")),
+          timeout
+        );
+        timeoutHandle.unref();
+      })
+    ]);
+  } catch (error) {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle);
+    }
+    const logger = getLogger();
+    logger.error(
+      "[autotel] Flush error:",
+      error instanceof Error ? error : new Error(String(error))
+    );
+    throw error;
+  }
+}
+async function shutdown() {
+  const logger = getLogger();
+  let shutdownError = null;
+  try {
+    await flush();
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    shutdownError = err;
+    logger.error(
+      "[autotel] Flush failed during shutdown, continuing cleanup",
+      err
+    );
+  }
+  try {
+    const sdk = getSdk();
+    if (sdk) {
+      await sdk.shutdown();
+    }
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const isConnectionRefused = typeof error === "object" && error !== null && "code" in error && error.code === "ECONNREFUSED";
+    if (!isConnectionRefused) {
+      if (!shutdownError) {
+        shutdownError = err;
+      }
+      logger.error("[autotel] SDK shutdown failed", err);
+    }
+  } finally {
+    resetEvents();
+    resetMetrics();
+    resetEventQueue();
+  }
+  if (shutdownError) {
+    throw shutdownError;
+  }
+}
+function registerShutdownHooks() {
+  if (typeof process === "undefined") return;
+  const signals = ["SIGTERM", "SIGINT"];
+  let shuttingDown = false;
+  for (const signal of signals) {
+    process.on(signal, async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      if (process.env.NODE_ENV !== "test") {
+        getLogger().info(`[autotel] Received ${signal}, flushing telemetry...`);
+      }
+      try {
+        await shutdown();
+      } catch (error) {
+        getLogger().error(
+          "[autotel] Error during shutdown",
+          error instanceof Error ? error : void 0
+        );
+      } finally {
+        process.exit(0);
+      }
+    });
+  }
+}
+registerShutdownHooks();
+
+// src/index.ts
+init_trace_context();
+
+export { flush, shutdown };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shutdown.ts","../src/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Graceful shutdown with flush and cleanup\n */\n\nimport { getSdk, getLogger } from './init';\nimport { getEventQueue, resetEventQueue } from './track';\nimport { resetEvents } from './event';\nimport { resetMetrics } from './metric';\n\n/**\n * Flush all pending telemetry\n *\n * Flushes both events events and OpenTelemetry spans to their destinations.\n * Includes timeout protection to prevent hanging in serverless environments.\n *\n * Safe to call multiple times.\n *\n * @param options - Optional configuration\n * @param options.timeout - Timeout in milliseconds (default: 2000ms)\n *\n * @example Manual flush in serverless\n * ```typescript\n * import { flush } from 'autotel';\n *\n * export const handler = async (event) => {\n *   // ... process event\n *   await flush(); // Flush before function returns\n *   return result;\n * };\n * ```\n *\n * @example With custom timeout\n * ```typescript\n * await flush({ timeout: 5000 }); // 5 second timeout\n * ```\n */\nexport async function flush(options?: { timeout?: number }): Promise<void> {\n  const timeout = options?.timeout ?? 2000;\n\n  const doFlush = async () => {\n    // Flush events queue\n    const eventsQueue = getEventQueue();\n    if (eventsQueue) {\n      await eventsQueue.flush();\n    }\n\n    // Flush OpenTelemetry spans\n    // This ensures spans are exported immediately, critical for serverless\n    const sdk = getSdk();\n    if (sdk) {\n      try {\n        // Type assertion needed as getTracerProvider is not in the public NodeSDK interface\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const sdkAny = sdk as any;\n        if (typeof sdkAny.getTracerProvider === 'function') {\n          const tracerProvider = sdkAny.getTracerProvider();\n          if (\n            tracerProvider &&\n            typeof tracerProvider.forceFlush === 'function'\n          ) {\n            await tracerProvider.forceFlush();\n          }\n        }\n      } catch {\n        // Ignore errors when accessing tracer provider (may not be available in test mocks)\n      }\n    }\n  };\n\n  // Add timeout protection to prevent hanging\n  let timeoutHandle: NodeJS.Timeout | undefined;\n  try {\n    await Promise.race([\n      doFlush().finally(() => {\n        // Clear timeout as soon as flush completes\n        if (timeoutHandle) {\n          clearTimeout(timeoutHandle);\n        }\n      }),\n      new Promise<void>((_, reject) => {\n        timeoutHandle = setTimeout(\n          () => reject(new Error('Flush timeout')),\n          timeout,\n        );\n        // Use unref() to allow Node to exit if flush completes first\n        // This prevents the 2s delay in serverless when flush succeeds immediately\n        timeoutHandle.unref();\n      }),\n    ]);\n  } catch (error) {\n    // Clear timeout on error too\n    if (timeoutHandle) {\n      clearTimeout(timeoutHandle);\n    }\n    const logger = getLogger();\n    logger.error(\n      '[autotel] Flush error:',\n      error instanceof Error ? error : new Error(String(error)),\n    );\n    throw error;\n  }\n}\n\n/**\n * Shutdown telemetry and cleanup resources\n *\n * - Flushes all pending data\n * - Shuts down OpenTelemetry SDK\n * - Cleans up resources\n *\n * Call this before process exit.\n *\n * Always performs cleanup even if flush fails, preventing resource leaks\n * in serverless handlers or tests.\n *\n * @example Express server\n * ```typescript\n * const server = app.listen(3000)\n *\n * process.on('SIGTERM', async () => {\n *   await server.close()\n *   await shutdown()\n *   process.exit(0)\n * })\n * ```\n */\nexport async function shutdown(): Promise<void> {\n  const logger = getLogger();\n  let shutdownError: Error | null = null;\n\n  // Attempt to flush, but continue with cleanup even if it fails\n  try {\n    await flush();\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error(String(error));\n    shutdownError = err;\n    logger.error(\n      '[autotel] Flush failed during shutdown, continuing cleanup',\n      err,\n    );\n  }\n\n  // Always shutdown SDK and clean up resources\n  try {\n    // Shutdown OpenTelemetry SDK\n    const sdk = getSdk();\n    if (sdk) {\n      await sdk.shutdown();\n    }\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error(String(error));\n\n    // Ignore ECONNREFUSED errors - this happens when no OTLP endpoint was configured\n    // The SDK tries to flush exporters that don't exist, which is harmless\n    const isConnectionRefused =\n      typeof error === 'object' &&\n      error !== null &&\n      'code' in error &&\n      error.code === 'ECONNREFUSED';\n\n    if (!isConnectionRefused) {\n      // Only store/log non-connection errors\n      if (!shutdownError) {\n        shutdownError = err;\n      }\n      logger.error('[autotel] SDK shutdown failed', err);\n    }\n  } finally {\n    // Clean up singleton Maps and queues to prevent memory leaks\n    // This runs even if SDK shutdown fails\n    resetEvents();\n    resetMetrics();\n    resetEventQueue();\n  }\n\n  // Rethrow first error after cleanup completes\n  // This allows tests and CI to detect failures while still ensuring cleanup\n  if (shutdownError) {\n    throw shutdownError;\n  }\n}\n\n/**\n * Register automatic shutdown hooks for common signals\n *\n * Handles:\n * - SIGTERM (Docker/K8s graceful shutdown)\n * - SIGINT (Ctrl+C)\n *\n * @internal Called automatically on module load\n */\nfunction registerShutdownHooks(): void {\n  if (typeof process === 'undefined') return; // Not in Node.js\n\n  const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];\n  let shuttingDown = false;\n\n  for (const signal of signals) {\n    process.on(signal, async () => {\n      if (shuttingDown) return; // Prevent double shutdown\n      shuttingDown = true;\n\n      if (process.env.NODE_ENV !== 'test') {\n        getLogger().info(`[autotel] Received ${signal}, flushing telemetry...`);\n      }\n\n      try {\n        await shutdown();\n      } catch (error) {\n        getLogger().error(\n          '[autotel] Error during shutdown',\n          error instanceof Error ? error : undefined,\n        );\n      } finally {\n        process.exit(0);\n      }\n    });\n  }\n}\n\n// Auto-register shutdown hooks\nregisterShutdownHooks();\n","/**\n * autotel - Simplified OpenTelemetry instrumentation\n *\n * @example Minimal setup\n * ```typescript\n * import { init, trace, track } from 'autotel'\n *\n * init({ service: 'my-app' })\n *\n * export const createUser = trace(ctx => async (data: CreateUserData) => {\n *   track('user.signup', { userId: data.id, plan: data.plan })\n * })\n * ```\n *\n * @example With events\n * ```typescript\n * import { init, trace, track } from 'autotel'\n * import { PostHogSubscriber } from 'autotel-subscribers'\n *\n * init({\n *   service: 'my-app',\n *   subscribers: [new PostHogSubscriber({ apiKey: '...' })]\n * })\n *\n * export const createUser = trace(ctx => async (data: CreateUserData) => {\n *   track('user.signup', { userId: data.id })\n * })\n * ```\n */\n\n// Core initialization\nexport { init, type AutotelConfig } from './init';\n\n// Baggage span processor\nexport {\n  BaggageSpanProcessor,\n  type BaggageSpanProcessorOptions,\n} from './baggage-span-processor';\n\n// Functional API (re-export for convenience)\nexport type {\n  TraceContext,\n  SpanOptions,\n  WithNewContextOptions,\n  WithBaggageOptions,\n  InstrumentOptions,\n} from './functional';\nexport {\n  trace,\n  instrument,\n  withTracing,\n  span,\n  withNewContext,\n  withBaggage,\n  ctx,\n} from './functional';\n\n// Operation context (for advanced usage)\nexport type { OperationContext } from './operation-context';\nexport {\n  getOperationContext,\n  runInOperationContext,\n} from './operation-context';\n\n// Global track function\nexport { track } from './track';\n\n// Graceful shutdown\nexport { flush, shutdown } from './shutdown';\n\n// Re-export sampling strategies\nexport {\n  type Sampler,\n  type SamplingContext,\n  AlwaysSampler,\n  NeverSampler,\n  RandomSampler,\n  AdaptiveSampler,\n  UserIdSampler,\n} from './sampling';\n\n// Events API\nexport { Event, getEvents, resetEvents, type EventsOptions } from './event';\n\n// Metrics API\nexport {\n  Metric,\n  getMetrics,\n  resetMetrics,\n  type MetricsOptions,\n} from './metric';\n\n// Meter helpers for custom metrics\nexport {\n  getMeter,\n  createCounter,\n  createHistogram,\n  createUpDownCounter,\n  createObservableGauge,\n} from './metric-helpers';\n\n// Tracer helpers for custom spans\nexport {\n  getTracer,\n  getActiveSpan,\n  getActiveContext,\n  runWithSpan,\n  finalizeSpan,\n  createDeterministicTraceId,\n  flattenMetadata,\n} from './trace-helpers';\n\n// Isolated tracer provider support (advanced - for library authors)\nexport {\n  setAutotelTracerProvider,\n  getAutotelTracerProvider,\n  getAutotelTracer,\n} from './tracer-provider';\n\n// Semantic convention helpers\nexport {\n  traceLLM,\n  traceDB,\n  traceHTTP,\n  traceMessaging,\n  type LLMConfig,\n  type DBConfig,\n  type HTTPConfig,\n  type MessagingConfig,\n} from './semantic-helpers';\n\n// Re-export events types\nexport type {\n  EventSubscriber,\n  EventAttributes,\n  FunnelStatus,\n  OutcomeStatus,\n} from './event-subscriber';\n\n// Re-export OpenTelemetry APIs for convenience\n// (Users shouldn't need to import @opentelemetry/api directly)\n// Note: OTel's trace is exported as 'otelTrace' to avoid naming conflict with autotel's trace()\n// Plugin developers can also access it directly: import { otelTrace } from 'autotel'\nexport {\n  context,\n  propagation,\n  SpanStatusCode,\n  trace as otelTrace,\n} from '@opentelemetry/api';\n\n// Re-export common OpenTelemetry types and utilities\n// This allows plugins and apps to use OTel without needing separate @opentelemetry/api installation\nexport type { Span, SpanContext, Tracer, Context } from '@opentelemetry/api';\nexport { SpanKind } from '@opentelemetry/api';\n// Note: trace exported from functional.ts, context/propagation/SpanStatusCode already exported above\n\n// Export typed baggage helper\nexport { defineBaggageSchema } from './trace-context';\n"]}

package/dist/instrumentation.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var chunkABPEQ6RK_cjs = require('./chunk-ABPEQ6RK.cjs');
+var chunkGVLK7YUU_cjs = require('./chunk-GVLK7YUU.cjs');
+require('./chunk-HE6T6FIX.cjs');
+require('./chunk-4OAT42CA.cjs');
+require('./chunk-Y4Y2S7BM.cjs');
+require('./chunk-URRW6M2C.cjs');
+require('./chunk-G7VZBCD6.cjs');
+var sdkNode = require('@opentelemetry/sdk-node');
+var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
+var sdkLogs = require('@opentelemetry/sdk-logs');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var resources = require('@opentelemetry/resources');
+var incubating = require('@opentelemetry/semantic-conventions/incubating');
+var exporterMetricsOtlpHttp = require('@opentelemetry/exporter-metrics-otlp-http');
+var sdkMetrics = require('@opentelemetry/sdk-metrics');
+
+function parseOtlpHeaders(headersString) {
+  if (!headersString) return {};
+  const headers = {};
+  const pairs = headersString.split(",");
+  for (const pair of pairs) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      headers[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return headers;
+}
+function parseResourceAttributes(attributesString) {
+  if (!attributesString) return {};
+  const attributes = {};
+  const pairs = attributesString.split(",");
+  for (const pair of pairs) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      attributes[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return attributes;
+}
+var currentSDK = null;
+var shutdownHandlerRegistered = false;
+async function shutdownInstrumentation(sdk) {
+  const sdkToShutdown = sdk || currentSDK;
+  if (!sdkToShutdown) {
+    chunkABPEQ6RK_cjs.getLogger().warn("No SDK to shutdown");
+    return;
+  }
+  try {
+    await sdkToShutdown.shutdown();
+    chunkABPEQ6RK_cjs.getLogger().info("OpenTelemetry terminated successfully");
+    if (sdkToShutdown === currentSDK) {
+      currentSDK = null;
+    }
+  } catch (error) {
+    chunkABPEQ6RK_cjs.getLogger().error(
+      "Error terminating OpenTelemetry",
+      error instanceof Error ? error : void 0
+    );
+    throw error;
+  }
+}
+async function initInstrumentation(config) {
+  if (currentSDK) {
+    chunkABPEQ6RK_cjs.getLogger().info(
+      "Shutting down existing OpenTelemetry SDK before reinitializing..."
+    );
+    await shutdownInstrumentation(currentSDK);
+  }
+  const otlpHeaders = parseOtlpHeaders(config.otlpHeaders);
+  const customResourceAttributes = parseResourceAttributes(
+    config.resourceAttributes
+  );
+  let resource;
+  const detectors = [resources.processDetector, resources.hostDetector];
+  try {
+    const awsDetectors = await import('@opentelemetry/resource-detector-aws');
+    detectors.push(
+      awsDetectors.awsEc2Detector,
+      awsDetectors.awsEcsDetector,
+      awsDetectors.awsEksDetector
+    );
+  } catch {
+  }
+  try {
+    const gcpDetectors = await import('@opentelemetry/resource-detector-gcp');
+    detectors.push(gcpDetectors.gcpDetector);
+  } catch {
+  }
+  try {
+    const containerDetectors = await import('@opentelemetry/resource-detector-container');
+    detectors.push(containerDetectors.containerDetector);
+  } catch {
+  }
+  if (config.detectResources) {
+    const detectedResource = await resources.detectResources({
+      detectors
+    });
+    resource = detectedResource.merge(
+      resources.resourceFromAttributes({
+        [incubating.ATTR_SERVICE_NAME]: config.serviceName,
+        [incubating.ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+        "deployment.environment": config.deploymentEnvironment || "development",
+        ...customResourceAttributes
+        // Merge custom resource attributes
+      })
+    );
+  } else {
+    resource = resources.resourceFromAttributes({
+      [incubating.ATTR_SERVICE_NAME]: config.serviceName,
+      [incubating.ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+      "deployment.environment": config.deploymentEnvironment || "development",
+      ...customResourceAttributes
+      // Merge custom resource attributes
+    });
+  }
+  const instrumentations = config.selectiveInstrumentation === false ? [autoInstrumentationsNode.getNodeAutoInstrumentations()] : config.instrumentations || [];
+  const traceExporter = new exporterTraceOtlpHttp.OTLPTraceExporter({
+    url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/traces`,
+    headers: otlpHeaders
+  });
+  const spanProcessor = new chunkGVLK7YUU_cjs.TailSamplingSpanProcessor(
+    new sdkTraceBase.BatchSpanProcessor(traceExporter)
+  );
+  const sdk = new sdkNode.NodeSDK({
+    resource,
+    spanProcessor,
+    // Use our wrapped processor instead of traceExporter directly
+    metricReader: new sdkMetrics.PeriodicExportingMetricReader({
+      exporter: new exporterMetricsOtlpHttp.OTLPMetricExporter({
+        url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/metrics`,
+        headers: otlpHeaders
+      })
+    }),
+    logRecordProcessors: [
+      new sdkLogs.BatchLogRecordProcessor(
+        new exporterLogsOtlpHttp.OTLPLogExporter({
+          url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/logs`,
+          headers: otlpHeaders
+        })
+      )
+    ],
+    instrumentations
+  });
+  try {
+    await sdk.start();
+    chunkABPEQ6RK_cjs.getLogger().info("OpenTelemetry instrumentation started successfully");
+  } catch (error) {
+    chunkABPEQ6RK_cjs.getLogger().error(
+      "Failed to start OpenTelemetry SDK",
+      error instanceof Error ? error : void 0
+    );
+    throw error;
+  }
+  currentSDK = sdk;
+  if (!shutdownHandlerRegistered) {
+    shutdownHandlerRegistered = true;
+    const shutdownHandler = () => {
+      shutdownInstrumentation().then(() => {
+        process.exit(0);
+      }).catch((error) => {
+        chunkABPEQ6RK_cjs.getLogger().error(
+          "Shutdown error",
+          error instanceof Error ? error : void 0
+        );
+        process.exit(1);
+      });
+    };
+    process.on("SIGTERM", shutdownHandler);
+    process.on("SIGINT", shutdownHandler);
+  }
+  return sdk;
+}
+
+exports.initInstrumentation = initInstrumentation;
+exports.shutdownInstrumentation = shutdownInstrumentation;
+//# sourceMappingURL=instrumentation.cjs.map
+//# sourceMappingURL=instrumentation.cjs.map

package/dist/instrumentation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instrumentation.ts"],"names":["getLogger","processDetector","hostDetector","detectResources","resourceFromAttributes","ATTR_SERVICE_NAME","ATTR_SERVICE_VERSION","getNodeAutoInstrumentations","OTLPTraceExporter","TailSamplingSpanProcessor","BatchSpanProcessor","NodeSDK","PeriodicExportingMetricReader","OTLPMetricExporter","BatchLogRecordProcessor","OTLPLogExporter"],"mappings":";;;;;;;;;;;;;;;;;;;;AA4BA,SAAS,iBAAiB,aAAA,EAAgD;AACxE,EAAA,IAAI,CAAC,aAAA,EAAe,OAAO,EAAC;AAE5B,EAAA,MAAM,UAAkC,EAAC;AACzC,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,KAAA,CAAM,GAAG,CAAA;AAErC,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,MAAM,CAAC,GAAA,EAAK,GAAG,UAAU,CAAA,GAAI,IAAA,CAAK,MAAM,GAAG,CAAA;AAC3C,IAAA,IAAI,GAAA,IAAO,UAAA,CAAW,MAAA,GAAS,CAAA,EAAG;AAChC,MAAA,OAAA,CAAQ,GAAA,CAAI,MAAM,CAAA,GAAI,WAAW,IAAA,CAAK,GAAG,EAAE,IAAA,EAAK;AAAA,IAClD;AAAA,EACF;AAEA,EAAA,OAAO,OAAA;AACT;AAOA,SAAS,wBACP,gBAAA,EACwB;AACxB,EAAA,IAAI,CAAC,gBAAA,EAAkB,OAAO,EAAC;AAE/B,EAAA,MAAM,aAAqC,EAAC;AAC5C,EAAA,MAAM,KAAA,GAAQ,gBAAA,CAAiB,KAAA,CAAM,GAAG,CAAA;AAExC,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,MAAM,CAAC,GAAA,EAAK,GAAG,UAAU,CAAA,GAAI,IAAA,CAAK,MAAM,GAAG,CAAA;AAC3C,IAAA,IAAI,GAAA,IAAO,UAAA,CAAW,MAAA,GAAS,CAAA,EAAG;AAChC,MAAA,UAAA,CAAW,GAAA,CAAI,MAAM,CAAA,GAAI,WAAW,IAAA,CAAK,GAAG,EAAE,IAAA,EAAK;AAAA,IACrD;AAAA,EACF;AAEA,EAAA,OAAO,UAAA;AACT;AAuEA,IAAI,UAAA,GAA6B,IAAA;AACjC,IAAI,yBAAA,GAA4B,KAAA;AAMhC,eAAsB,wBAAwB,GAAA,EAA8B;AAC1E,EAAA,MAAM,gBAAgB,GAAA,IAAO,UAAA;AAC7B,EAAA,IAAI,CAAC,aAAA,EAAe;AAClB,IAAAA,2BAAA,EAAU,CAAE,KAAK,oBAAoB,CAAA;AACrC,IAAA;AAAA,EACF;AAEA,EAAA,IAAI;AACF,IAAA,MAAM,cAAc,QAAA,EAAS;AAC7B,IAAAA,2BAAA,EAAU,CAAE,KAAK,uCAAuC,CAAA;AACxD,IAAA,IAAI,kBAAkB,UAAA,EAAY;AAChC,MAAA,UAAA,GAAa,IAAA;AAAA,IACf;AAAA,EACF,SAAS,KAAA,EAAO;AACd,IAAAA,2BAAA,EAAU,CAAE,KAAA;AAAA,MACV,iCAAA;AAAA,MACA,KAAA,YAAiB,QAAQ,KAAA,GAAQ;AAAA,KACnC;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AACF;AAEA,eAAsB,oBACpB,MAAA,EACkB;AAElB,EAAA,IAAI,UAAA,EAAY;AACd,IAAAA,2BAAA,EAAU,CAAE,IAAA;AAAA,MACV;AAAA,KACF;AACA,IAAA,MAAM,wBAAwB,UAAU,CAAA;AAAA,EAC1C;AAGA,EAAA,MAAM,WAAA,GAAc,gBAAA,CAAiB,MAAA,CAAO,WAAW,CAAA;AACvD,EAAA,MAAM,wBAAA,GAA2B,uBAAA;AAAA,IAC/B,MAAA,CAAO;AAAA,GACT;AAEA,EAAA,IAAI,QAAA;AAGJ,EAAA,MAAM,SAAA,GAAgC,CAACC,yBAAA,EAAiBC,sBAAY,CAAA;AACpE,EAAA,IAAI;AACF,IAAA,MAAM,YAAA,GAAe,MAAM,OAAO,sCAAsC,CAAA;AACxE,IAAA,SAAA,CAAU,IAAA;AAAA,MACR,YAAA,CAAa,cAAA;AAAA,MACb,YAAA,CAAa,cAAA;AAAA,MACb,YAAA,CAAa;AAAA,KACf;AAAA,EACF,CAAA,CAAA,MAAQ;AAAA,EAER;AACA,EAAA,IAAI;AACF,IAAA,MAAM,YAAA,GAAe,MAAM,OAAO,sCAAsC,CAAA;AACxE,IAAA,SAAA,CAAU,IAAA,CAAK,aAAa,WAAW,CAAA;AAAA,EACzC,CAAA,CAAA,MAAQ;AAAA,EAER;AACA,EAAA,IAAI;AACF,IAAA,MAAM,kBAAA,GAAqB,MAAM,OAC/B,4CACF,CAAA;AACA,IAAA,SAAA,CAAU,IAAA,CAAK,mBAAmB,iBAAiB,CAAA;AAAA,EACrD,CAAA,CAAA,MAAQ;AAAA,EAER;AAEA,EAAA,IAAI,OAAO,eAAA,EAAiB;AAC1B,IAAA,MAAM,gBAAA,GAAmB,MAAMC,yBAAA,CAAgB;AAAA,MAC7C;AAAA,KACD,CAAA;AAED,IAAA,QAAA,GAAW,gBAAA,CAAiB,KAAA;AAAA,MAC1BC,gCAAA,CAAuB;AAAA,QACrB,CAACC,4BAAiB,GAAG,MAAA,CAAO,WAAA;AAAA,QAC5B,CAACC,+BAAoB,GAAG,MAAA,CAAO,cAAA,IAAkB,OAAA;AAAA,QACjD,wBAAA,EAA0B,OAAO,qBAAA,IAAyB,aAAA;AAAA,QAC1D,GAAG;AAAA;AAAA,OACJ;AAAA,KACH;AAAA,EACF,CAAA,MAAO;AACL,IAAA,QAAA,GAAWF,gCAAA,CAAuB;AAAA,MAChC,CAACC,4BAAiB,GAAG,MAAA,CAAO,WAAA;AAAA,MAC5B,CAACC,+BAAoB,GAAG,MAAA,CAAO,cAAA,IAAkB,OAAA;AAAA,MACjD,wBAAA,EAA0B,OAAO,qBAAA,IAAyB,aAAA;AAAA,MAC1D,GAAG;AAAA;AAAA,KACJ,CAAA;AAAA,EACH;AAGA,EAAA,MAAM,gBAAA,GACJ,MAAA,CAAO,wBAAA,KAA6B,KAAA,GAChC,CAACC,sDAA6B,CAAA,GAC9B,MAAA,CAAO,gBAAA,IAAoB,EAAC;AAElC,EAAA,MAAM,aAAA,GAAgB,IAAIC,uCAAA,CAAkB;AAAA,IAC1C,GAAA,EAAK,CAAA,EAAG,MAAA,CAAO,YAAA,IAAgB,uBAAuB,CAAA,UAAA,CAAA;AAAA,IACtD,OAAA,EAAS;AAAA,GACV,CAAA;AAGD,EAAA,MAAM,gBAAgB,IAAIC,2CAAA;AAAA,IACxB,IAAIC,gCAAmB,aAAa;AAAA,GACtC;AAEA,EAAA,MAAM,GAAA,GAAM,IAAIC,eAAA,CAAQ;AAAA,IACtB,QAAA;AAAA,IACA,aAAA;AAAA;AAAA,IACA,YAAA,EAAc,IAAIC,wCAAA,CAA8B;AAAA,MAC9C,QAAA,EAAU,IAAIC,0CAAA,CAAmB;AAAA,QAC/B,GAAA,EAAK,CAAA,EAAG,MAAA,CAAO,YAAA,IAAgB,uBAAuB,CAAA,WAAA,CAAA;AAAA,QACtD,OAAA,EAAS;AAAA,OACV;AAAA,KACF,CAAA;AAAA,IACD,mBAAA,EAAqB;AAAA,MACnB,IAAIC,+BAAA;AAAA,QACF,IAAIC,oCAAA,CAAgB;AAAA,UAClB,GAAA,EAAK,CAAA,EAAG,MAAA,CAAO,YAAA,IAAgB,uBAAuB,CAAA,QAAA,CAAA;AAAA,UACtD,OAAA,EAAS;AAAA,SACV;AAAA;AACH,KACF;AAAA,IACA;AAAA,GACD,CAAA;AAED,EAAA,IAAI;AACF,IAAA,MAAM,IAAI,KAAA,EAAM;AAChB,IAAAf,2BAAA,EAAU,CAAE,KAAK,oDAAoD,CAAA;AAAA,EACvE,SAAS,KAAA,EAAO;AACd,IAAAA,2BAAA,EAAU,CAAE,KAAA;AAAA,MACV,mCAAA;AAAA,MACA,KAAA,YAAiB,QAAQ,KAAA,GAAQ;AAAA,KACnC;AACA,IAAA,MAAM,KAAA;AAAA,EACR;AAGA,EAAA,UAAA,GAAa,GAAA;AAEb,EAAA,IAAI,CAAC,yBAAA,EAA2B;AAC9B,IAAA,yBAAA,GAA4B,IAAA;AAE5B,IAAA,MAAM,kBAAkB,MAAM;AAC5B,MAAA,uBAAA,EAAwB,CACrB,KAAK,MAAM;AAEV,QAAA,OAAA,CAAQ,KAAK,CAAC,CAAA;AAAA,MAChB,CAAC,CAAA,CACA,KAAA,CAAM,CAAC,KAAA,KAAU;AAChB,QAAAA,2BAAA,EAAU,CAAE,KAAA;AAAA,UACV,gBAAA;AAAA,UACA,KAAA,YAAiB,QAAQ,KAAA,GAAQ;AAAA,SACnC;AAEA,QAAA,OAAA,CAAQ,KAAK,CAAC,CAAA;AAAA,MAChB,CAAC,CAAA;AAAA,IACL,CAAA;AAEA,IAAA,OAAA,CAAQ,EAAA,CAAG,WAAW,eAAe,CAAA;AACrC,IAAA,OAAA,CAAQ,EAAA,CAAG,UAAU,eAAe,CAAA;AAAA,EACtC;AAEA,EAAA,OAAO,GAAA;AACT","file":"instrumentation.cjs","sourcesContent":["import { NodeSDK } from '@opentelemetry/sdk-node';\nimport { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';\nimport { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';\nimport { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\nimport { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';\nimport { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';\nimport { TailSamplingSpanProcessor } from './tail-sampling-processor';\nimport { getLogger } from './init';\nimport {\n  resourceFromAttributes,\n  detectResources,\n  processDetector,\n  hostDetector,\n  type Resource,\n  type ResourceDetector,\n} from '@opentelemetry/resources';\nimport {\n  ATTR_SERVICE_NAME,\n  ATTR_SERVICE_VERSION,\n} from '@opentelemetry/semantic-conventions/incubating';\nimport { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';\nimport { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';\n\n/**\n * Parse OTLP headers string into object format\n * @param headersString - Headers as \"key1=value1,key2=value2\" or \"Authorization=Basic ...\"\n * @returns Headers object for OTLP exporters\n */\nfunction parseOtlpHeaders(headersString?: string): Record<string, string> {\n  if (!headersString) return {};\n\n  const headers: Record<string, string> = {};\n  const pairs = headersString.split(',');\n\n  for (const pair of pairs) {\n    const [key, ...valueParts] = pair.split('=');\n    if (key && valueParts.length > 0) {\n      headers[key.trim()] = valueParts.join('=').trim();\n    }\n  }\n\n  return headers;\n}\n\n/**\n * Parse resource attributes string into object format\n * @param attributesString - Attributes as \"key1=value1,key2=value2\"\n * @returns Resource attributes object\n */\nfunction parseResourceAttributes(\n  attributesString?: string,\n): Record<string, string> {\n  if (!attributesString) return {};\n\n  const attributes: Record<string, string> = {};\n  const pairs = attributesString.split(',');\n\n  for (const pair of pairs) {\n    const [key, ...valueParts] = pair.split('=');\n    if (key && valueParts.length > 0) {\n      attributes[key.trim()] = valueParts.join('=').trim();\n    }\n  }\n\n  return attributes;\n}\n\nexport interface InstrumentationConfig {\n  serviceName: string;\n  serviceVersion?: string;\n  deploymentEnvironment?: string;\n  otlpEndpoint?: string;\n  /** OTLP headers for authentication (e.g., Grafana Cloud) */\n  otlpHeaders?: string;\n  /** Resource attributes as comma-separated key=value pairs */\n  resourceAttributes?: string;\n  /** Enable async resource detection for process/host info (default: false) */\n  detectResources?: boolean;\n  /**\n   * Use selective instrumentation instead of full auto-instrumentation\n   * **Default: true** (performance-first)\n   *\n   * When true, auto-instrumentation is disabled. You can manually add\n   * specific instrumentations via the `instrumentations` field.\n   * This reduces overhead from ~81% to near-zero based on Platformatic benchmarks.\n   *\n   * Set to false to enable full auto-instrumentation (not recommended for production).\n   *\n   * @see https://blogger.platformatic.dev/the-hidden-cost-of-context\n   */\n  selectiveInstrumentation?: boolean;\n\n  /**\n   * Custom instrumentations to use (only when selectiveInstrumentation is true)\n   * @example\n   * ```typescript\n   * import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'\n   *\n   * initInstrumentation({\n   *   serviceName: 'api',\n   *   selectiveInstrumentation: true,\n   *   instrumentations: [new HttpInstrumentation()]\n   * })\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  instrumentations?: any[];\n}\n\n/**\n * Initialize OpenTelemetry instrumentation with OTLP exporters\n *\n * This sets up:\n * - Traces (OTLP HTTP)\n * - Metrics (OTLP HTTP)\n * - Logs (OTLP HTTP)\n * - Auto-instrumentation for common Node.js libraries\n *\n * @example\n * // Call this at the very start of your application\n * import { initInstrumentation } from '@your-org/otel-decorators'\n *\n * initInstrumentation({\n *   serviceName: 'my-service' }\n *   serviceVersion: '1.0.0',\n *   deploymentEnvironment: 'production',\n *   otlpEndpoint: 'http://localhost:4318'\n * })\n *\n * // Or with async resource detection (top-level await required)\n * await initInstrumentation({\n *   serviceName: 'my-service' }\n *   detectResources: true\n * })\n */\n// Enables graceful shutdown and prevents SDK leaks on hot-reload\nlet currentSDK: NodeSDK | null = null;\nlet shutdownHandlerRegistered = false;\n\n/**\n * Shutdown the OpenTelemetry SDK gracefully\n * Call this before process exit or during hot-reloads\n */\nexport async function shutdownInstrumentation(sdk?: NodeSDK): Promise<void> {\n  const sdkToShutdown = sdk || currentSDK;\n  if (!sdkToShutdown) {\n    getLogger().warn('No SDK to shutdown');\n    return;\n  }\n\n  try {\n    await sdkToShutdown.shutdown();\n    getLogger().info('OpenTelemetry terminated successfully');\n    if (sdkToShutdown === currentSDK) {\n      currentSDK = null;\n    }\n  } catch (error) {\n    getLogger().error(\n      'Error terminating OpenTelemetry',\n      error instanceof Error ? error : undefined,\n    );\n    throw error;\n  }\n}\n\nexport async function initInstrumentation(\n  config: InstrumentationConfig,\n): Promise<NodeSDK> {\n  // Prevents resource leaks on hot-reload or multiple init calls\n  if (currentSDK) {\n    getLogger().info(\n      'Shutting down existing OpenTelemetry SDK before reinitializing...',\n    );\n    await shutdownInstrumentation(currentSDK);\n  }\n\n  // Parse OTLP headers and resource attributes\n  const otlpHeaders = parseOtlpHeaders(config.otlpHeaders);\n  const customResourceAttributes = parseResourceAttributes(\n    config.resourceAttributes,\n  );\n\n  let resource: Resource;\n\n  // Dynamically load optional resource detectors\n  const detectors: ResourceDetector[] = [processDetector, hostDetector];\n  try {\n    const awsDetectors = await import('@opentelemetry/resource-detector-aws');\n    detectors.push(\n      awsDetectors.awsEc2Detector,\n      awsDetectors.awsEcsDetector,\n      awsDetectors.awsEksDetector,\n    );\n  } catch {\n    // ignore\n  }\n  try {\n    const gcpDetectors = await import('@opentelemetry/resource-detector-gcp');\n    detectors.push(gcpDetectors.gcpDetector);\n  } catch {\n    // ignore\n  }\n  try {\n    const containerDetectors = await import(\n      '@opentelemetry/resource-detector-container'\n    );\n    detectors.push(containerDetectors.containerDetector);\n  } catch {\n    // ignore\n  }\n\n  if (config.detectResources) {\n    const detectedResource = await detectResources({\n      detectors,\n    });\n\n    resource = detectedResource.merge(\n      resourceFromAttributes({\n        [ATTR_SERVICE_NAME]: config.serviceName,\n        [ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',\n        'deployment.environment': config.deploymentEnvironment || 'development',\n        ...customResourceAttributes, // Merge custom resource attributes\n      }),\n    );\n  } else {\n    resource = resourceFromAttributes({\n      [ATTR_SERVICE_NAME]: config.serviceName,\n      [ATTR_SERVICE_VERSION]: config.serviceVersion || '1.0.0',\n      'deployment.environment': config.deploymentEnvironment || 'development',\n      ...customResourceAttributes, // Merge custom resource attributes\n    });\n  }\n\n  // Default to selective (near-zero overhead) vs full auto (~81% overhead)\n  const instrumentations =\n    config.selectiveInstrumentation === false\n      ? [getNodeAutoInstrumentations()]\n      : config.instrumentations || [];\n\n  const traceExporter = new OTLPTraceExporter({\n    url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/traces`,\n    headers: otlpHeaders,\n  });\n\n  // Enables tail sampling via sampling.tail.keep attribute\n  const spanProcessor = new TailSamplingSpanProcessor(\n    new BatchSpanProcessor(traceExporter),\n  );\n\n  const sdk = new NodeSDK({\n    resource,\n    spanProcessor, // Use our wrapped processor instead of traceExporter directly\n    metricReader: new PeriodicExportingMetricReader({\n      exporter: new OTLPMetricExporter({\n        url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/metrics`,\n        headers: otlpHeaders,\n      }),\n    }),\n    logRecordProcessors: [\n      new BatchLogRecordProcessor(\n        new OTLPLogExporter({\n          url: `${config.otlpEndpoint || 'http://localhost:4318'}/v1/logs`,\n          headers: otlpHeaders,\n        }),\n      ),\n    ],\n    instrumentations,\n  });\n\n  try {\n    await sdk.start();\n    getLogger().info('OpenTelemetry instrumentation started successfully');\n  } catch (error) {\n    getLogger().error(\n      'Failed to start OpenTelemetry SDK',\n      error instanceof Error ? error : undefined,\n    );\n    throw error;\n  }\n\n  // Track current SDK for shutdown handler\n  currentSDK = sdk;\n\n  if (!shutdownHandlerRegistered) {\n    shutdownHandlerRegistered = true;\n\n    const shutdownHandler = () => {\n      shutdownInstrumentation()\n        .then(() => {\n          // eslint-disable-next-line unicorn/no-process-exit\n          process.exit(0);\n        })\n        .catch((error) => {\n          getLogger().error(\n            'Shutdown error',\n            error instanceof Error ? error : undefined,\n          );\n          // eslint-disable-next-line unicorn/no-process-exit\n          process.exit(1);\n        });\n    };\n\n    process.on('SIGTERM', shutdownHandler);\n    process.on('SIGINT', shutdownHandler);\n  }\n\n  return sdk;\n}\n"]}

package/dist/instrumentation.d.cts

@@ -0,0 +1,49 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+interface InstrumentationConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    deploymentEnvironment?: string;
+    otlpEndpoint?: string;
+    /** OTLP headers for authentication (e.g., Grafana Cloud) */
+    otlpHeaders?: string;
+    /** Resource attributes as comma-separated key=value pairs */
+    resourceAttributes?: string;
+    /** Enable async resource detection for process/host info (default: false) */
+    detectResources?: boolean;
+    /**
+     * Use selective instrumentation instead of full auto-instrumentation
+     * **Default: true** (performance-first)
+     *
+     * When true, auto-instrumentation is disabled. You can manually add
+     * specific instrumentations via the `instrumentations` field.
+     * This reduces overhead from ~81% to near-zero based on Platformatic benchmarks.
+     *
+     * Set to false to enable full auto-instrumentation (not recommended for production).
+     *
+     * @see https://blogger.platformatic.dev/the-hidden-cost-of-context
+     */
+    selectiveInstrumentation?: boolean;
+    /**
+     * Custom instrumentations to use (only when selectiveInstrumentation is true)
+     * @example
+     * ```typescript
+     * import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'
+     *
+     * initInstrumentation({
+     *   serviceName: 'api',
+     *   selectiveInstrumentation: true,
+     *   instrumentations: [new HttpInstrumentation()]
+     * })
+     * ```
+     */
+    instrumentations?: any[];
+}
+/**
+ * Shutdown the OpenTelemetry SDK gracefully
+ * Call this before process exit or during hot-reloads
+ */
+declare function shutdownInstrumentation(sdk?: NodeSDK): Promise<void>;
+declare function initInstrumentation(config: InstrumentationConfig): Promise<NodeSDK>;
+
+export { type InstrumentationConfig, initInstrumentation, shutdownInstrumentation };

package/dist/instrumentation.d.ts

@@ -0,0 +1,49 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+interface InstrumentationConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    deploymentEnvironment?: string;
+    otlpEndpoint?: string;
+    /** OTLP headers for authentication (e.g., Grafana Cloud) */
+    otlpHeaders?: string;
+    /** Resource attributes as comma-separated key=value pairs */
+    resourceAttributes?: string;
+    /** Enable async resource detection for process/host info (default: false) */
+    detectResources?: boolean;
+    /**
+     * Use selective instrumentation instead of full auto-instrumentation
+     * **Default: true** (performance-first)
+     *
+     * When true, auto-instrumentation is disabled. You can manually add
+     * specific instrumentations via the `instrumentations` field.
+     * This reduces overhead from ~81% to near-zero based on Platformatic benchmarks.
+     *
+     * Set to false to enable full auto-instrumentation (not recommended for production).
+     *
+     * @see https://blogger.platformatic.dev/the-hidden-cost-of-context
+     */
+    selectiveInstrumentation?: boolean;
+    /**
+     * Custom instrumentations to use (only when selectiveInstrumentation is true)
+     * @example
+     * ```typescript
+     * import { HttpInstrumentation } from '@opentelemetry/instrumentation-http'
+     *
+     * initInstrumentation({
+     *   serviceName: 'api',
+     *   selectiveInstrumentation: true,
+     *   instrumentations: [new HttpInstrumentation()]
+     * })
+     * ```
+     */
+    instrumentations?: any[];
+}
+/**
+ * Shutdown the OpenTelemetry SDK gracefully
+ * Call this before process exit or during hot-reloads
+ */
+declare function shutdownInstrumentation(sdk?: NodeSDK): Promise<void>;
+declare function initInstrumentation(config: InstrumentationConfig): Promise<NodeSDK>;
+
+export { type InstrumentationConfig, initInstrumentation, shutdownInstrumentation };

package/dist/instrumentation.js

@@ -0,0 +1,179 @@
+import { getLogger } from './chunk-3HENGDW2.js';
+import { TailSamplingSpanProcessor } from './chunk-X4RMFFMR.js';
+import './chunk-5R2M36QB.js';
+import './chunk-5GWX5LFW.js';
+import './chunk-KVGNW3FC.js';
+import './chunk-P6JUDYNO.js';
+import './chunk-Z6ZWNWWR.js';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { processDetector, hostDetector, detectResources, resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions/incubating';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+
+function parseOtlpHeaders(headersString) {
+  if (!headersString) return {};
+  const headers = {};
+  const pairs = headersString.split(",");
+  for (const pair of pairs) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      headers[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return headers;
+}
+function parseResourceAttributes(attributesString) {
+  if (!attributesString) return {};
+  const attributes = {};
+  const pairs = attributesString.split(",");
+  for (const pair of pairs) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      attributes[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return attributes;
+}
+var currentSDK = null;
+var shutdownHandlerRegistered = false;
+async function shutdownInstrumentation(sdk) {
+  const sdkToShutdown = sdk || currentSDK;
+  if (!sdkToShutdown) {
+    getLogger().warn("No SDK to shutdown");
+    return;
+  }
+  try {
+    await sdkToShutdown.shutdown();
+    getLogger().info("OpenTelemetry terminated successfully");
+    if (sdkToShutdown === currentSDK) {
+      currentSDK = null;
+    }
+  } catch (error) {
+    getLogger().error(
+      "Error terminating OpenTelemetry",
+      error instanceof Error ? error : void 0
+    );
+    throw error;
+  }
+}
+async function initInstrumentation(config) {
+  if (currentSDK) {
+    getLogger().info(
+      "Shutting down existing OpenTelemetry SDK before reinitializing..."
+    );
+    await shutdownInstrumentation(currentSDK);
+  }
+  const otlpHeaders = parseOtlpHeaders(config.otlpHeaders);
+  const customResourceAttributes = parseResourceAttributes(
+    config.resourceAttributes
+  );
+  let resource;
+  const detectors = [processDetector, hostDetector];
+  try {
+    const awsDetectors = await import('@opentelemetry/resource-detector-aws');
+    detectors.push(
+      awsDetectors.awsEc2Detector,
+      awsDetectors.awsEcsDetector,
+      awsDetectors.awsEksDetector
+    );
+  } catch {
+  }
+  try {
+    const gcpDetectors = await import('@opentelemetry/resource-detector-gcp');
+    detectors.push(gcpDetectors.gcpDetector);
+  } catch {
+  }
+  try {
+    const containerDetectors = await import('@opentelemetry/resource-detector-container');
+    detectors.push(containerDetectors.containerDetector);
+  } catch {
+  }
+  if (config.detectResources) {
+    const detectedResource = await detectResources({
+      detectors
+    });
+    resource = detectedResource.merge(
+      resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: config.serviceName,
+        [ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+        "deployment.environment": config.deploymentEnvironment || "development",
+        ...customResourceAttributes
+        // Merge custom resource attributes
+      })
+    );
+  } else {
+    resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: config.serviceName,
+      [ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+      "deployment.environment": config.deploymentEnvironment || "development",
+      ...customResourceAttributes
+      // Merge custom resource attributes
+    });
+  }
+  const instrumentations = config.selectiveInstrumentation === false ? [getNodeAutoInstrumentations()] : config.instrumentations || [];
+  const traceExporter = new OTLPTraceExporter({
+    url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/traces`,
+    headers: otlpHeaders
+  });
+  const spanProcessor = new TailSamplingSpanProcessor(
+    new BatchSpanProcessor(traceExporter)
+  );
+  const sdk = new NodeSDK({
+    resource,
+    spanProcessor,
+    // Use our wrapped processor instead of traceExporter directly
+    metricReader: new PeriodicExportingMetricReader({
+      exporter: new OTLPMetricExporter({
+        url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/metrics`,
+        headers: otlpHeaders
+      })
+    }),
+    logRecordProcessors: [
+      new BatchLogRecordProcessor(
+        new OTLPLogExporter({
+          url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/logs`,
+          headers: otlpHeaders
+        })
+      )
+    ],
+    instrumentations
+  });
+  try {
+    await sdk.start();
+    getLogger().info("OpenTelemetry instrumentation started successfully");
+  } catch (error) {
+    getLogger().error(
+      "Failed to start OpenTelemetry SDK",
+      error instanceof Error ? error : void 0
+    );
+    throw error;
+  }
+  currentSDK = sdk;
+  if (!shutdownHandlerRegistered) {
+    shutdownHandlerRegistered = true;
+    const shutdownHandler = () => {
+      shutdownInstrumentation().then(() => {
+        process.exit(0);
+      }).catch((error) => {
+        getLogger().error(
+          "Shutdown error",
+          error instanceof Error ? error : void 0
+        );
+        process.exit(1);
+      });
+    };
+    process.on("SIGTERM", shutdownHandler);
+    process.on("SIGINT", shutdownHandler);
+  }
+  return sdk;
+}
+
+export { initInstrumentation, shutdownInstrumentation };
+//# sourceMappingURL=instrumentation.js.map
+//# sourceMappingURL=instrumentation.js.map