autotel 2.1.0

package/dist/chunk-ABPEQ6RK.cjs

@@ -0,0 +1,596 @@
+'use strict';
+
+var chunkGVLK7YUU_cjs = require('./chunk-GVLK7YUU.cjs');
+var chunkG7VZBCD6_cjs = require('./chunk-G7VZBCD6.cjs');
+var api = require('@opentelemetry/api');
+var sdkNode = require('@opentelemetry/sdk-node');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var sdkMetrics = require('@opentelemetry/sdk-metrics');
+var exporterMetricsOtlpHttp = require('@opentelemetry/exporter-metrics-otlp-http');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var nodeEnvResolver = require('node-env-resolver');
+var validators = require('node-env-resolver/validators');
+var instrumentationPino = require('@opentelemetry/instrumentation-pino');
+var instrumentationWinston = require('@opentelemetry/instrumentation-winston');
+var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
+
+var BaggageSpanProcessor = class {
+  prefix;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "baggage.";
+  }
+  onStart(span, parentContext) {
+    let baggage = api.propagation.getBaggage(parentContext);
+    if (!baggage) {
+      baggage = api.propagation.getBaggage(api.context.active());
+    }
+    if (!baggage) {
+      try {
+        const { getActiveContextWithBaggage } = chunkG7VZBCD6_cjs.__require("../trace-context");
+        const storedContext = getActiveContextWithBaggage();
+        baggage = api.propagation.getBaggage(storedContext);
+      } catch {
+      }
+    }
+    if (!baggage) return;
+    for (const [key, entry] of baggage.getAllEntries()) {
+      span.setAttribute(`${this.prefix}${key}`, entry.value);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onEnd(_span) {
+  }
+  async shutdown() {
+  }
+  async forceFlush() {
+  }
+};
+function resolveOtelEnv() {
+  return nodeEnvResolver.resolve({
+    OTEL_SERVICE_NAME: validators.string({ optional: true }),
+    OTEL_EXPORTER_OTLP_ENDPOINT: validators.url({ optional: true }),
+    OTEL_EXPORTER_OTLP_HEADERS: validators.string({ optional: true }),
+    OTEL_RESOURCE_ATTRIBUTES: validators.string({ optional: true }),
+    OTEL_EXPORTER_OTLP_PROTOCOL: validators.optional(["http", "grpc"])
+  });
+}
+function parseResourceAttributes(input) {
+  if (!input || input.trim() === "") {
+    return {};
+  }
+  const attributes = {};
+  const pairs = input.split(",");
+  for (const pair of pairs) {
+    const trimmedPair = pair.trim();
+    if (!trimmedPair) continue;
+    const equalIndex = trimmedPair.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const key = trimmedPair.slice(0, equalIndex).trim();
+    const value = trimmedPair.slice(equalIndex + 1).trim();
+    if (key && value) {
+      attributes[key] = value;
+    }
+  }
+  return attributes;
+}
+function parseOtlpHeaders(input) {
+  if (!input || input.trim() === "") {
+    return {};
+  }
+  const headers = {};
+  const pairs = input.split(",");
+  for (const pair of pairs) {
+    const trimmedPair = pair.trim();
+    if (!trimmedPair) continue;
+    const equalIndex = trimmedPair.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+    const key = trimmedPair.slice(0, equalIndex).trim();
+    const value = trimmedPair.slice(equalIndex + 1).trim();
+    if (key && value) {
+      headers[key] = value;
+    }
+  }
+  return headers;
+}
+function envToConfig(env) {
+  const config2 = {};
+  if (env.OTEL_SERVICE_NAME) {
+    config2.service = env.OTEL_SERVICE_NAME;
+  }
+  if (env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+    config2.endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  }
+  if (env.OTEL_EXPORTER_OTLP_PROTOCOL) {
+    config2.protocol = env.OTEL_EXPORTER_OTLP_PROTOCOL;
+  }
+  if (env.OTEL_EXPORTER_OTLP_HEADERS) {
+    config2.otlpHeaders = parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+  }
+  const resourceAttrs = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+  if (Object.keys(resourceAttrs).length > 0) {
+    config2.resourceAttributes = resourceAttrs;
+  }
+  return config2;
+}
+function resolveConfigFromEnv() {
+  const env = resolveOtelEnv();
+  return envToConfig(env);
+}
+var OTLPTraceExporterGRPC;
+var OTLPMetricExporterGRPC;
+function loadGRPCTraceExporter() {
+  if (OTLPTraceExporterGRPC) return OTLPTraceExporterGRPC;
+  try {
+    const grpcModule = chunkG7VZBCD6_cjs.__require("@opentelemetry/exporter-trace-otlp-grpc");
+    OTLPTraceExporterGRPC = grpcModule.OTLPTraceExporter;
+    return OTLPTraceExporterGRPC;
+  } catch {
+    throw new Error(
+      "gRPC trace exporter not found. Install with: pnpm add @opentelemetry/exporter-trace-otlp-grpc"
+    );
+  }
+}
+function loadGRPCMetricExporter() {
+  if (OTLPMetricExporterGRPC) return OTLPMetricExporterGRPC;
+  try {
+    const grpcModule = chunkG7VZBCD6_cjs.__require("@opentelemetry/exporter-metrics-otlp-grpc");
+    OTLPMetricExporterGRPC = grpcModule.OTLPMetricExporter;
+    return OTLPMetricExporterGRPC;
+  } catch {
+    throw new Error(
+      "gRPC metric exporter not found. Install with: pnpm add @opentelemetry/exporter-metrics-otlp-grpc"
+    );
+  }
+}
+function createTraceExporter(protocol, config2) {
+  if (protocol === "grpc") {
+    const Exporter = loadGRPCTraceExporter();
+    return new Exporter(config2);
+  }
+  return new exporterTraceOtlpHttp.OTLPTraceExporter(config2);
+}
+function createMetricExporter(protocol, config2) {
+  if (protocol === "grpc") {
+    const Exporter = loadGRPCMetricExporter();
+    return new Exporter(config2);
+  }
+  return new exporterMetricsOtlpHttp.OTLPMetricExporter(config2);
+}
+function resolveProtocol(configProtocol) {
+  if (configProtocol === "grpc" || configProtocol === "http") {
+    return configProtocol;
+  }
+  const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
+  if (envProtocol === "grpc") return "grpc";
+  if (envProtocol === "http/protobuf" || envProtocol === "http") return "http";
+  return "http";
+}
+function formatEndpointUrl(endpoint, signal, protocol) {
+  if (protocol === "grpc") {
+    return endpoint.replace(/\/(v1\/)?(traces|metrics|logs)$/, "");
+  }
+  if (!endpoint.endsWith(`/v1/${signal}`)) {
+    return `${endpoint}/v1/${signal}`;
+  }
+  return endpoint;
+}
+var silentLogger = {
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  debug: () => {
+  }
+};
+var initialized = false;
+var config = null;
+var sdk = null;
+var warnedOnce = false;
+var logger = silentLogger;
+var validationConfig = null;
+function resolveMetricsFlag(configFlag = "auto") {
+  const envFlag = process.env.AUTOTELEMETRY_METRICS;
+  if (envFlag === "on" || envFlag === "true") return true;
+  if (envFlag === "off" || envFlag === "false") return false;
+  if (configFlag === true) return true;
+  if (configFlag === false) return false;
+  return true;
+}
+function resolveDebugFlag(configFlag) {
+  const envFlag = process.env.AUTOLEMETRY_DEBUG;
+  if (envFlag === "true" || envFlag === "1") return true;
+  if (envFlag === "false" || envFlag === "0") return false;
+  return configFlag ?? false;
+}
+function normalizeOtlpHeaders(headers) {
+  if (!headers) return void 0;
+  if (typeof headers !== "string") return headers;
+  const parsed = {};
+  for (const pair of headers.split(",")) {
+    const [key, ...valueParts] = pair.split("=");
+    if (!key || valueParts.length === 0) continue;
+    parsed[key.trim()] = valueParts.join("=").trim();
+  }
+  return parsed;
+}
+function createLoggerInstrumentation(logger2) {
+  if ("child" in logger2 && "bindings" in logger2 && typeof logger2.child === "function") {
+    return new instrumentationPino.PinoInstrumentation();
+  }
+  if ("transports" in logger2 || "defaultMeta" in logger2) {
+    return new instrumentationWinston.WinstonInstrumentation();
+  }
+  return null;
+}
+function init(cfg) {
+  const envConfig = resolveConfigFromEnv();
+  const mergedConfig = {
+    ...envConfig,
+    ...cfg,
+    // Deep merge for resourceAttributes
+    resourceAttributes: {
+      ...envConfig.resourceAttributes,
+      ...cfg.resourceAttributes
+    },
+    // Handle otlpHeaders merge (can be string or object)
+    otlpHeaders: cfg.otlpHeaders === void 0 ? envConfig.otlpHeaders === void 0 ? void 0 : envConfig.otlpHeaders : cfg.otlpHeaders
+  };
+  logger = mergedConfig.logger || silentLogger;
+  if (initialized) {
+    logger.warn(
+      "[autotel] init() called again - last config wins. This may cause unexpected behavior."
+    );
+  }
+  config = mergedConfig;
+  validationConfig = mergedConfig.validation || null;
+  const endpoint = mergedConfig.endpoint;
+  const otlpHeaders = normalizeOtlpHeaders(mergedConfig.otlpHeaders);
+  const version = mergedConfig.version || detectVersion();
+  const environment = mergedConfig.environment || process.env.NODE_ENV || "development";
+  const metricsEnabled = resolveMetricsFlag(mergedConfig.metrics);
+  const hostname = detectHostname();
+  let resource = resources.resourceFromAttributes({
+    [semanticConventions.ATTR_SERVICE_NAME]: cfg.service,
+    [semanticConventions.ATTR_SERVICE_VERSION]: version,
+    // Support both old and new OpenTelemetry semantic conventions for environment
+    "deployment.environment": environment,
+    // Deprecated but widely supported
+    "deployment.environment.name": environment
+    // OTel v1.27.0+ standard
+  });
+  if (hostname) {
+    resource = resource.merge(
+      resources.resourceFromAttributes({
+        "host.name": hostname,
+        // OpenTelemetry standard
+        "datadog.host.name": hostname
+        // Datadog-specific, highest priority for Datadog
+      })
+    );
+  }
+  if (cfg.resource) {
+    resource = resource.merge(cfg.resource);
+  }
+  if (cfg.resourceAttributes) {
+    resource = resource.merge(resources.resourceFromAttributes(cfg.resourceAttributes));
+  }
+  const protocol = resolveProtocol(cfg.protocol);
+  const spanProcessors = [];
+  if (cfg.spanProcessors && cfg.spanProcessors.length > 0) {
+    spanProcessors.push(...cfg.spanProcessors);
+  } else if (cfg.spanExporters && cfg.spanExporters.length > 0) {
+    for (const exporter of cfg.spanExporters) {
+      spanProcessors.push(
+        new chunkGVLK7YUU_cjs.TailSamplingSpanProcessor(new sdkTraceBase.BatchSpanProcessor(exporter))
+      );
+    }
+  } else if (endpoint) {
+    const traceExporter = createTraceExporter(protocol, {
+      url: formatEndpointUrl(endpoint, "traces", protocol),
+      headers: otlpHeaders
+    });
+    spanProcessors.push(
+      new chunkGVLK7YUU_cjs.TailSamplingSpanProcessor(new sdkTraceBase.BatchSpanProcessor(traceExporter))
+    );
+  }
+  if (cfg.baggage) {
+    const prefix = typeof cfg.baggage === "string" ? cfg.baggage ? `${cfg.baggage}.` : "" : "baggage.";
+    spanProcessors.push(new BaggageSpanProcessor({ prefix }));
+  }
+  const debugMode = resolveDebugFlag(cfg.debug);
+  if (debugMode) {
+    spanProcessors.push(new sdkTraceBase.SimpleSpanProcessor(new sdkTraceBase.ConsoleSpanExporter()));
+  }
+  const metricReaders = [];
+  if (cfg.metricReaders && cfg.metricReaders.length > 0) {
+    metricReaders.push(...cfg.metricReaders);
+  } else if (metricsEnabled && endpoint) {
+    const metricExporter = createMetricExporter(protocol, {
+      url: formatEndpointUrl(endpoint, "metrics", protocol),
+      headers: otlpHeaders
+    });
+    metricReaders.push(
+      new sdkMetrics.PeriodicExportingMetricReader({
+        exporter: metricExporter
+      })
+    );
+  }
+  let logRecordProcessors;
+  if (cfg.logRecordProcessors && cfg.logRecordProcessors.length > 0) {
+    logRecordProcessors = [...cfg.logRecordProcessors];
+  }
+  let finalInstrumentations = cfg.instrumentations ? [...cfg.instrumentations] : [];
+  if (cfg.logger) {
+    const loggerInstrumentation = createLoggerInstrumentation(cfg.logger);
+    if (loggerInstrumentation) {
+      finalInstrumentations = [...finalInstrumentations, loggerInstrumentation];
+      logger.debug(
+        `[autotel] Auto-enabled ${loggerInstrumentation.constructor.name} for logger`
+      );
+    }
+  }
+  if (cfg.integrations !== void 0) {
+    try {
+      const manualInstrumentationNames = getInstrumentationNames(
+        cfg.instrumentations ?? []
+      );
+      if (manualInstrumentationNames.size > 0 && cfg.integrations !== false && cfg.integrations !== void 0) {
+        const manualNames = [...manualInstrumentationNames].join(", ");
+        logger.info(
+          `[autotel] Detected manual instrumentations (${manualNames}). These will take precedence over auto-instrumentations. Tip: Set integrations:false if you want full manual control, or remove manual configs to use auto-instrumentations.`
+        );
+      }
+      const autoInstrumentations = getAutoInstrumentations(
+        cfg.integrations,
+        manualInstrumentationNames
+      );
+      if (autoInstrumentations && autoInstrumentations.length > 0) {
+        finalInstrumentations = [
+          ...finalInstrumentations,
+          ...autoInstrumentations
+        ];
+      }
+    } catch (error) {
+      logger.warn(
+        `[autotel] Failed to configure auto-instrumentations: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const sdkOptions = {
+    resource,
+    instrumentations: finalInstrumentations
+  };
+  if (spanProcessors.length > 0) {
+    sdkOptions.spanProcessors = spanProcessors;
+  }
+  if (metricReaders.length > 0) {
+    sdkOptions.metricReaders = metricReaders;
+  }
+  if (logRecordProcessors && logRecordProcessors.length > 0) {
+    sdkOptions.logRecordProcessors = logRecordProcessors;
+  }
+  sdk = cfg.sdkFactory ? cfg.sdkFactory(sdkOptions) : new sdkNode.NodeSDK(sdkOptions);
+  if (!sdk) {
+    throw new Error("[autotel] sdkFactory must return a NodeSDK instance");
+  }
+  sdk.start();
+  if (cfg.openllmetry?.enabled) {
+    let initializedSync = false;
+    try {
+      const traceloop = chunkG7VZBCD6_cjs.__require("@traceloop/node-server-sdk");
+      const initOptions = {
+        ...cfg.openllmetry.options
+      };
+      try {
+        const tracerProvider = sdk.getTracerProvider();
+        initOptions.tracerProvider = tracerProvider;
+      } catch {
+      }
+      if (typeof traceloop.initialize === "function") {
+        traceloop.initialize(initOptions);
+        logger.info("[autotel] OpenLLMetry initialized successfully");
+        initializedSync = true;
+      }
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("Cannot find module") || error.message.includes("Module not found") || error.message.includes("Cannot resolve module") || error.message.includes("Dynamic require"))) {
+        initializeOpenLLMetry(
+          cfg.openllmetry.options,
+          sdk,
+          cfg.spanExporters?.[0]
+          // Pass first exporter if available
+        ).catch((error_) => {
+          logger.warn(
+            `[autotel] OpenLLMetry initialization error: ${error_ instanceof Error ? error_.message : String(error_)}`
+          );
+        });
+      } else if (!initializedSync) {
+        logger.warn(
+          `[autotel] Failed to initialize OpenLLMetry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  initialized = true;
+}
+async function initializeOpenLLMetry(options, sdkInstance, spanExporter) {
+  try {
+    let traceloop;
+    try {
+      traceloop = chunkG7VZBCD6_cjs.__require("@traceloop/node-server-sdk");
+    } catch {
+      traceloop = await import('@traceloop/node-server-sdk');
+    }
+    const initOptions = {
+      ...options
+    };
+    if (spanExporter) {
+      initOptions.exporter = spanExporter;
+    }
+    if (sdkInstance) {
+      try {
+        const tracerProvider = sdkInstance.getTracerProvider();
+        initOptions.tracerProvider = tracerProvider;
+      } catch (error) {
+        logger.debug(
+          `[autotel] Could not get tracer provider for OpenLLMetry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (typeof traceloop.initialize === "function") {
+      traceloop.initialize(initOptions);
+      logger.info("[autotel] OpenLLMetry initialized successfully");
+    } else {
+      logger.warn(
+        "[autotel] OpenLLMetry initialize function not found. Check @traceloop/node-server-sdk version."
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("Cannot find module") || error.message.includes("Module not found") || error.message.includes("Cannot resolve module"))) {
+      logger.warn(
+        "[autotel] OpenLLMetry enabled but @traceloop/node-server-sdk is not installed. Install it as a peer dependency to use OpenLLMetry integration."
+      );
+    } else {
+      logger.warn(
+        `[autotel] Failed to initialize OpenLLMetry: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+function getInstrumentationNames(instrumentations) {
+  const names = /* @__PURE__ */ new Set();
+  if (!instrumentations) return names;
+  for (const instrumentation of instrumentations) {
+    if (instrumentation && typeof instrumentation === "object") {
+      names.add(instrumentation.constructor.name);
+    }
+  }
+  return names;
+}
+var INSTRUMENTATION_CLASS_TO_PACKAGE = {
+  HttpInstrumentation: "@opentelemetry/instrumentation-http",
+  HttpsInstrumentation: "@opentelemetry/instrumentation-http",
+  ExpressInstrumentation: "@opentelemetry/instrumentation-express",
+  FastifyInstrumentation: "@opentelemetry/instrumentation-fastify",
+  MongoDBInstrumentation: "@opentelemetry/instrumentation-mongodb",
+  MongooseInstrumentation: "@opentelemetry/instrumentation-mongoose",
+  PrismaInstrumentation: "@opentelemetry/instrumentation-prisma",
+  PinoInstrumentation: "@opentelemetry/instrumentation-pino",
+  WinstonInstrumentation: "@opentelemetry/instrumentation-winston",
+  RedisInstrumentation: "@opentelemetry/instrumentation-redis",
+  GraphQLInstrumentation: "@opentelemetry/instrumentation-graphql",
+  GrpcInstrumentation: "@opentelemetry/instrumentation-grpc",
+  IORedisInstrumentation: "@opentelemetry/instrumentation-ioredis",
+  KnexInstrumentation: "@opentelemetry/instrumentation-knex",
+  NestJsInstrumentation: "@opentelemetry/instrumentation-nestjs-core",
+  PgInstrumentation: "@opentelemetry/instrumentation-pg",
+  MySQLInstrumentation: "@opentelemetry/instrumentation-mysql",
+  MySQL2Instrumentation: "@opentelemetry/instrumentation-mysql2"
+};
+function getAutoInstrumentations(integrations, manualInstrumentationNames = /* @__PURE__ */ new Set()) {
+  if (integrations === false) {
+    return [];
+  }
+  const exclusionConfig = {};
+  for (const className of manualInstrumentationNames) {
+    const packageName = INSTRUMENTATION_CLASS_TO_PACKAGE[className];
+    if (packageName) {
+      exclusionConfig[packageName] = { enabled: false };
+    }
+  }
+  if (integrations === true) {
+    if (Object.keys(exclusionConfig).length > 0) {
+      return autoInstrumentationsNode.getNodeAutoInstrumentations(exclusionConfig);
+    }
+    return autoInstrumentationsNode.getNodeAutoInstrumentations();
+  }
+  if (Array.isArray(integrations)) {
+    const config3 = { ...exclusionConfig };
+    for (const name of integrations) {
+      const packageName = `@opentelemetry/instrumentation-${name}`;
+      if (!exclusionConfig[packageName]) {
+        config3[packageName] = { enabled: true };
+      }
+    }
+    return autoInstrumentationsNode.getNodeAutoInstrumentations(config3);
+  }
+  const config2 = {
+    ...exclusionConfig,
+    ...integrations
+  };
+  for (const packageName of Object.keys(exclusionConfig)) {
+    const integrationsKey = Object.keys(integrations).find(
+      (key) => packageName.includes(key)
+    );
+    if (integrationsKey) {
+      config2[packageName] = { enabled: false };
+    }
+  }
+  return autoInstrumentationsNode.getNodeAutoInstrumentations(config2);
+}
+function isInitialized() {
+  return initialized;
+}
+function getConfig() {
+  return config;
+}
+function getLogger() {
+  return logger;
+}
+function getValidationConfig() {
+  return validationConfig;
+}
+function warnIfNotInitialized(context) {
+  if (!initialized && !warnedOnce) {
+    logger.warn(
+      `[autotel] ${context} used before init() called. Call init({ service: "..." }) first. See: https://docs.autotel.dev/quickstart`
+    );
+    warnedOnce = true;
+  }
+}
+function detectVersion() {
+  try {
+    const fs = chunkG7VZBCD6_cjs.__require("fs");
+    const pkg = JSON.parse(
+      fs.readFileSync(`${process.cwd()}/package.json`, "utf8")
+    );
+    return pkg.version || "1.0.0";
+  } catch {
+    return "1.0.0";
+  }
+}
+function detectHostname() {
+  if (process.env.DD_HOSTNAME) {
+    return process.env.DD_HOSTNAME;
+  }
+  if (process.env.HOSTNAME) {
+    return process.env.HOSTNAME;
+  }
+  try {
+    const os = chunkG7VZBCD6_cjs.__require("os");
+    return os.hostname();
+  } catch {
+    return void 0;
+  }
+}
+function getSdk() {
+  return sdk;
+}
+
+exports.BaggageSpanProcessor = BaggageSpanProcessor;
+exports.getConfig = getConfig;
+exports.getLogger = getLogger;
+exports.getSdk = getSdk;
+exports.getValidationConfig = getValidationConfig;
+exports.init = init;
+exports.isInitialized = isInitialized;
+exports.warnIfNotInitialized = warnIfNotInitialized;
+//# sourceMappingURL=chunk-ABPEQ6RK.cjs.map
+//# sourceMappingURL=chunk-ABPEQ6RK.cjs.map