langwatch 1.19.0 → 2.0.0

package/dist/chunk-DLZCOUXC.js

@@ -0,0 +1,852 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _chunkMAO3SIBBjs = require('./chunk-MAO3SIBB.js');
+
+
+
+
+var _chunk5VYEG3RSjs = require('./chunk-5VYEG3RS.js');
+
+
+
+
+
+var _chunkN76BG37Wjs = require('./chunk-N76BG37W.js');
+
+// src/observability-sdk/setup/node/setup.ts
+var _api = require('@opentelemetry/api');
+
+
+
+
+
+var _sdklogs = require('@opentelemetry/sdk-logs');
+
+
+
+
+var _sdktracebase = require('@opentelemetry/sdk-trace-base');
+
+// src/internal/endpoint.ts
+var isSet = (value) => typeof value === "string" && value.trim() !== "";
+var normalizeEndpoint = (endpoint) => {
+  const trimmed = endpoint.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed[end - 1] === "/") end--;
+  return trimmed.slice(0, end);
+};
+var resolveEndpoint = (endpoint) => {
+  for (const candidate of [endpoint, process.env.LANGWATCH_ENDPOINT]) {
+    if (!isSet(candidate)) continue;
+    const normalized = normalizeEndpoint(candidate);
+    if (normalized !== "") return normalized;
+  }
+  return normalizeEndpoint(_chunkMAO3SIBBjs.DEFAULT_ENDPOINT);
+};
+
+// src/observability-sdk/setup/utils.ts
+var _resources = require('@opentelemetry/resources');
+function createMergedResource(attributes, serviceName, givenResource) {
+  const langwatchResource = _resources.resourceFromAttributes.call(void 0, {
+    [_chunkN76BG37Wjs.ATTR_LANGWATCH_SDK_NAME]: _chunkMAO3SIBBjs.LANGWATCH_SDK_NAME_OBSERVABILITY,
+    [_chunkN76BG37Wjs.ATTR_LANGWATCH_SDK_LANGUAGE]: _chunkMAO3SIBBjs.LANGWATCH_SDK_LANGUAGE,
+    [_chunkN76BG37Wjs.ATTR_LANGWATCH_SDK_VERSION]: _chunkMAO3SIBBjs.LANGWATCH_SDK_VERSION
+  });
+  const userResource = _resources.resourceFromAttributes.call(void 0, _chunkN76BG37Wjs.__spreadValues.call(void 0, {
+    [_chunk5VYEG3RSjs.ATTR_SERVICE_NAME]: serviceName != null ? serviceName : _chunkMAO3SIBBjs.DEFAULT_SERVICE_NAME
+  }, attributes));
+  return (givenResource != null ? givenResource : _resources.defaultResource.call(void 0, )).merge(langwatchResource).merge(userResource);
+}
+function readMember(value, key) {
+  if (value === null || value === void 0) return void 0;
+  return Reflect.get(Object(value), key);
+}
+function callMember(target, key, args) {
+  const member = readMember(target, key);
+  if (typeof member !== "function") throw new TypeError(`${key} is not a function`);
+  return Reflect.apply(member, target, args);
+}
+function listProcessorRegistryCandidates(provider) {
+  return [
+    readMember(readMember(provider, "_activeSpanProcessor"), "_spanProcessors"),
+    readMember(readMember(provider, "activeSpanProcessor"), "_spanProcessors"),
+    readMember(provider, "_registeredSpanProcessors")
+  ];
+}
+function hasAttachableProcessorRegistry(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  return listProcessorRegistryCandidates(obj).some(Array.isArray);
+}
+function isConcreteProviderName(name) {
+  return typeof name === "string" && ["NodeTracerProvider", "BasicTracerProvider"].includes(name);
+}
+function getConcreteProvider(provider) {
+  if (!provider || typeof provider !== "object") return void 0;
+  const constructorName = readMember(provider.constructor, "name");
+  if (isConcreteProviderName(constructorName)) {
+    return provider;
+  }
+  if (typeof readMember(provider, "addSpanProcessor") === "function") {
+    return provider;
+  }
+  if (hasAttachableProcessorRegistry(provider)) {
+    return provider;
+  }
+  let delegate;
+  if (typeof readMember(provider, "getDelegate") === "function") {
+    delegate = callMember(provider, "getDelegate", []);
+  } else if (readMember(provider, "delegate")) {
+    delegate = readMember(provider, "delegate");
+  } else if (readMember(provider, "_delegate")) {
+    delegate = readMember(provider, "_delegate");
+  }
+  if (!delegate || typeof delegate !== "object") return void 0;
+  const delegateConstructorName = readMember(delegate.constructor, "name");
+  if (isConcreteProviderName(delegateConstructorName)) {
+    return delegate;
+  }
+  if (typeof readMember(delegate, "addSpanProcessor") === "function") {
+    return delegate;
+  }
+  if (hasAttachableProcessorRegistry(delegate)) {
+    return delegate;
+  }
+  return void 0;
+}
+function isConcreteProvider(provider) {
+  return !!getConcreteProvider(provider);
+}
+
+// src/observability-sdk/setup/node/node-sdk.ts
+
+
+
+
+
+
+
+
+var _apilogs = require('@opentelemetry/api-logs');
+var _contextasynchooks = require('@opentelemetry/context-async-hooks');
+
+
+
+
+
+
+
+
+
+var _core = require('@opentelemetry/core');
+
+
+
+
+
+
+
+
+
+
+
+var _sdktracenode = require('@opentelemetry/sdk-trace-node');
+
+// src/observability-sdk/setup/node/optional-peers.ts
+var _module = require('module');
+function requireOptionalPeer({
+  packageName,
+  neededFor
+}) {
+  try {
+    const base = typeof __filename === "string" ? __filename : void 0;
+    return _module.createRequire.call(void 0, base)(packageName);
+  } catch (cause) {
+    throw new Error(
+      `${neededFor} needs ${packageName}, which is not installed. Install it next to langwatch: npm install ${packageName}`,
+      { cause }
+    );
+  }
+}
+function loadInstrumentation() {
+  return requireOptionalPeer({
+    packageName: "@opentelemetry/instrumentation",
+    neededFor: "Passing instrumentations"
+  });
+}
+function loadSdkMetrics() {
+  return requireOptionalPeer({
+    packageName: "@opentelemetry/sdk-metrics",
+    neededFor: "Passing a metricReader"
+  });
+}
+
+// src/observability-sdk/setup/node/node-sdk.ts
+var BUILT_IN_PROPAGATORS = {
+  tracecontext: () => new (0, _core.W3CTraceContextPropagator)(),
+  baggage: () => new (0, _core.W3CBaggagePropagator)()
+};
+var SEPARATELY_PACKAGED_PROPAGATORS = {
+  b3: "@opentelemetry/propagator-b3",
+  b3multi: "@opentelemetry/propagator-b3",
+  jaeger: "@opentelemetry/propagator-jaeger"
+};
+var RESOURCE_DETECTORS_BY_ENV_NAME = {
+  host: _resources.hostDetector,
+  os: _resources.osDetector,
+  serviceinstance: _resources.serviceInstanceIdDetector,
+  process: _resources.processDetector,
+  env: _resources.envDetector
+};
+function setupContextManager(contextManager) {
+  if (contextManager === null) return;
+  if (contextManager === void 0) {
+    const defaultContextManager = new (0, _contextasynchooks.AsyncLocalStorageContextManager)();
+    defaultContextManager.enable();
+    _api.context.setGlobalContextManager(defaultContextManager);
+    return;
+  }
+  contextManager.enable();
+  _api.context.setGlobalContextManager(contextManager);
+}
+function setupPropagator(propagator) {
+  if (propagator === null) return;
+  if (propagator === void 0) {
+    _api.propagation.setGlobalPropagator(
+      new (0, _core.CompositePropagator)({
+        propagators: [new (0, _core.W3CTraceContextPropagator)(), new (0, _core.W3CBaggagePropagator)()]
+      })
+    );
+    return;
+  }
+  _api.propagation.setGlobalPropagator(propagator);
+}
+function getPropagatorFromEnv(logger) {
+  var _a;
+  const requested = _core.getStringListFromEnv.call(void 0, "OTEL_PROPAGATORS");
+  if (requested == null) return void 0;
+  if (requested.includes("none")) return null;
+  const built = [];
+  const uniqueNames = Array.from(new Set(requested));
+  for (const name of uniqueNames) {
+    const propagator = (_a = BUILT_IN_PROPAGATORS[name]) == null ? void 0 : _a.call(BUILT_IN_PROPAGATORS);
+    if (propagator) {
+      built.push(propagator);
+      continue;
+    }
+    const separatePackage = SEPARATELY_PACKAGED_PROPAGATORS[name];
+    logger.warn(
+      separatePackage ? `OTEL_PROPAGATORS asks for "${name}", which lives in ${separatePackage}. LangWatch does not build it; construct it yourself and pass it as textMapPropagator, or trace context will not travel as "${name}".` : `Propagator "${name}" requested through the environment variable OTEL_PROPAGATORS is unavailable.`
+    );
+  }
+  if (built.length === 0) return null;
+  if (built.length === 1) return built[0];
+  return new (0, _core.CompositePropagator)({ propagators: built });
+}
+function getResourceDetectorsFromEnv(logger) {
+  var _a;
+  const requested = (_a = _core.getStringListFromEnv.call(void 0, "OTEL_NODE_RESOURCE_DETECTORS")) != null ? _a : ["all"];
+  if (requested.includes("all")) return Object.values(RESOURCE_DETECTORS_BY_ENV_NAME);
+  if (requested.includes("none")) return [];
+  return requested.flatMap((name) => {
+    const detector = RESOURCE_DETECTORS_BY_ENV_NAME[name];
+    if (!detector) {
+      logger.warn(
+        `Invalid resource detector "${name}" specified in the environment variable OTEL_NODE_RESOURCE_DETECTORS`
+      );
+      return [];
+    }
+    return [detector];
+  });
+}
+function getLogRecordLimitsFromEnv() {
+  var _a, _b;
+  return {
+    attributeCountLimit: (_a = _core.getNumberFromEnv.call(void 0, "OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT")) != null ? _a : _core.getNumberFromEnv.call(void 0, "OTEL_ATTRIBUTE_COUNT_LIMIT"),
+    attributeValueLengthLimit: (_b = _core.getNumberFromEnv.call(void 0, "OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT")) != null ? _b : _core.getNumberFromEnv.call(void 0, "OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT")
+  };
+}
+var NodeSdk = class {
+  constructor(configuration) {
+    var _a, _b;
+    this.disabled = _core.getBooleanFromEnv.call(void 0, "OTEL_SDK_DISABLED");
+    const logLevel = _core.getStringFromEnv.call(void 0, "OTEL_LOG_LEVEL");
+    if (logLevel != null) {
+      _api.diag.setLogger(new (0, _api.DiagConsoleLogger)(), { logLevel: _core.diagLogLevelFromString.call(void 0, logLevel) });
+    }
+    this.configuration = configuration;
+    this.instrumentations = (_b = (_a = configuration.instrumentations) == null ? void 0 : _a.flat()) != null ? _b : [];
+  }
+  /** Registers instrumentations, context manager, propagator and providers, in that order. */
+  start() {
+    var _a;
+    if (this.disabled) return;
+    if (this.instrumentations.length > 0) {
+      loadInstrumentation().registerInstrumentations({ instrumentations: this.instrumentations });
+    }
+    setupContextManager(this.configuration.contextManager);
+    setupPropagator(
+      (_a = this.configuration.textMapPropagator) != null ? _a : getPropagatorFromEnv(this.configuration.logger)
+    );
+    const resource = this.resolveResource();
+    this.startMeterProvider(resource);
+    this.startTracerProvider(resource);
+    this.startLoggerProvider(resource);
+  }
+  /** Flushes and closes every provider this instance registered. */
+  async shutdown() {
+    const shutdowns = [];
+    if (this.tracerProvider) shutdowns.push(this.tracerProvider.shutdown());
+    if (this.loggerProvider) shutdowns.push(this.loggerProvider.shutdown());
+    if (this.meterProvider) shutdowns.push(this.meterProvider.shutdown());
+    await Promise.all(shutdowns);
+  }
+  startMeterProvider(resource) {
+    var _a;
+    const reader = this.configuration.metricReader;
+    if (!reader) return;
+    const { MeterProvider: MeterProviderClass } = loadSdkMetrics();
+    this.meterProvider = new MeterProviderClass({
+      resource,
+      views: (_a = this.configuration.views) != null ? _a : [],
+      readers: [reader]
+    });
+    _api.metrics.setGlobalMeterProvider(this.meterProvider);
+    for (const instrumentation of this.instrumentations) {
+      instrumentation.setMeterProvider(_api.metrics.getMeterProvider());
+    }
+  }
+  startTracerProvider(resource) {
+    var _a;
+    const spanProcessors = (_a = this.configuration.spanProcessors) != null ? _a : [];
+    if (spanProcessors.length === 0) return;
+    this.tracerProvider = new (0, _sdktracenode.NodeTracerProvider)({
+      sampler: this.configuration.sampler,
+      spanLimits: this.configuration.spanLimits,
+      resource,
+      idGenerator: this.configuration.idGenerator,
+      spanProcessors
+    });
+    _api.trace.setGlobalTracerProvider(this.tracerProvider);
+  }
+  startLoggerProvider(resource) {
+    const processors = this.configuration.logRecordProcessors;
+    if (!processors) return;
+    this.loggerProvider = new (0, _sdklogs.LoggerProvider)({
+      logRecordLimits: getLogRecordLimitsFromEnv(),
+      resource,
+      processors
+    });
+    _apilogs.logs.setGlobalLoggerProvider(this.loggerProvider);
+  }
+  resolveResource() {
+    var _a, _b;
+    let resource = (_a = this.configuration.resource) != null ? _a : _resources.defaultResource.call(void 0, );
+    if ((_b = this.configuration.autoDetectResources) != null ? _b : true) {
+      resource = resource.merge(_resources.detectResources.call(void 0, { detectors: this.resolveResourceDetectors() }));
+    }
+    return this.configuration.serviceName === void 0 ? resource : resource.merge(
+      _resources.resourceFromAttributes.call(void 0, { [_chunk5VYEG3RSjs.ATTR_SERVICE_NAME]: this.configuration.serviceName })
+    );
+  }
+  resolveResourceDetectors() {
+    if (this.configuration.resourceDetectors != null) return this.configuration.resourceDetectors;
+    if (_core.getStringFromEnv.call(void 0, "OTEL_NODE_RESOURCE_DETECTORS")) {
+      return getResourceDetectorsFromEnv(this.configuration.logger);
+    }
+    return [_resources.envDetector, _resources.processDetector, _resources.hostDetector];
+  }
+};
+
+// src/observability-sdk/setup/node/setup.ts
+var createNoOpHandle = (logger) => ({
+  shutdown: async () => {
+    logger.debug("Shutdown called for LangWatch no-op. Nothing will be shutdown");
+  }
+});
+var getLangWatchConfig = (options) => {
+  var _a, _b;
+  const isDisabled = options.langwatch === "disabled";
+  const config = typeof options.langwatch === "object" ? options.langwatch : {};
+  return {
+    disabled: isDisabled,
+    apiKey: isDisabled ? void 0 : (_a = config.apiKey) != null ? _a : process.env.LANGWATCH_API_KEY,
+    endpoint: isDisabled ? void 0 : resolveEndpoint(config.endpoint),
+    processorType: (_b = config.processorType) != null ? _b : "batch"
+  };
+};
+var checkForEarlyExit = (options, logger) => {
+  var _a, _b;
+  const globalProvider = _api.trace.getTracerProvider();
+  const alreadySetup = isConcreteProvider(globalProvider);
+  if (alreadySetup && !((_a = options.advanced) == null ? void 0 : _a.UNSAFE_forceOpenTelemetryReinitialization)) {
+    if ((_b = options.advanced) == null ? void 0 : _b.attachToExistingProvider) {
+      return null;
+    }
+    logger.error(
+      `OpenTelemetry is already set up in this process.
+Spans will NOT be sent to LangWatch unless you add the LangWatch span processor or exporter to your existing OpenTelemetry setup.
+You must either:
+  1. Remove your existing OpenTelemetry setup and only use LangWatch,
+  2. Add the LangWatch span processor to your existing setup, or replace the existing exporter with the LangWatch exporter.
+  3. Use advanced.attachToExistingProvider to let LangWatch attach its processors to the existing provider.
+
+For step-by-step instructions, see the LangWatch docs and check out the integration guide for your framework:
+  https://docs.langwatch.ai/integration/typescript/guide
+
+See also: https://github.com/open-telemetry/opentelemetry-js/issues/5299`
+    );
+    return createNoOpHandle(logger);
+  }
+  if (alreadySetup) {
+    logger.warn(
+      "OpenTelemetry is already set up, but UNSAFE_forceOpenTelemetryReinitialization=true. Proceeding with reinitialization. This may cause conflicts."
+    );
+  }
+  return null;
+};
+var warnIfMisconfigured = (options, langwatch, logger) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (langwatch.disabled) {
+    const hasAlternativeExport = (_h = (_g = (_e = (_c = (_a = options.spanProcessors) == null ? void 0 : _a.length) != null ? _c : (_b = options.logRecordProcessors) == null ? void 0 : _b.length) != null ? _e : (_d = options.debug) == null ? void 0 : _d.consoleTracing) != null ? _g : (_f = options.debug) == null ? void 0 : _f.consoleLogging) != null ? _h : options.traceExporter;
+    if (!hasAlternativeExport) {
+      const errorMessage = "LangWatch integration is disabled but no custom span processors, trace exporters, or console tracing is configured. OpenTelemetry will be set up but traces will not be exported anywhere. Either:\n  1. Enable LangWatch integration (remove langwatch: 'disabled')\n  2. Provide custom spanProcessors, logRecordProcessors, or traceExporter\n  3. Enable debug.consoleTracing or debug.consoleLogging for development\n  4. Use advanced.disabled to completely disable observability\n  5. Use advanced.skipOpenTelemetrySetup to handle OpenTelemetry setup yourself";
+      if ((_i = options.advanced) == null ? void 0 : _i.throwOnSetupError) {
+        throw new Error(errorMessage);
+      } else {
+        logger.error(errorMessage);
+      }
+    }
+  }
+};
+var GRPC_TRACE_EXPORTER_PACKAGE = "@opentelemetry/exporter-trace-otlp-grpc";
+var refuseUnservedGrpc = (options) => {
+  var _a, _b;
+  if (options.otlpProtocol !== "grpc") return;
+  if ((_b = options.traceExporter) != null ? _b : (_a = options.spanProcessors) == null ? void 0 : _a.length) return;
+  throw new Error(
+    `otlpProtocol is set to "grpc" but nothing was given to export over gRPC with. Install ${GRPC_TRACE_EXPORTER_PACKAGE} and pass its OTLPTraceExporter as traceExporter (or wrap it in a span processor and pass it in spanProcessors). LangWatch's own exporter speaks HTTP and is never used for gRPC export.`
+  );
+};
+var settleAfterSignalFlush = ({
+  signal,
+  logger,
+  exitProcessAfterShutdown
+}) => {
+  if (exitProcessAfterShutdown) {
+    logger.debug(
+      `${signal}: flush complete, exiting because UNSAFE_exitProcessAfterAutoShutdown is set`
+    );
+    process.exit(0);
+    return;
+  }
+  const otherListenerCount = process.listenerCount(signal);
+  if (otherListenerCount > 0) {
+    logger.debug(
+      `${signal}: flush complete, leaving the process to the ${otherListenerCount} other listener(s)`
+    );
+    return;
+  }
+  logger.debug(`${signal}: flush complete and nothing else is listening, re-raising`);
+  process.kill(process.pid, signal);
+};
+var registerAutoShutdownHandlers = ({
+  sdk,
+  logger,
+  exitProcessAfterShutdown
+}) => {
+  let isShuttingDown = false;
+  const registrations = [];
+  const register = (event, handler) => {
+    registrations.push({ event, handler });
+    process.on(event, handler);
+  };
+  const unregisterAll = () => {
+    for (const { event, handler } of registrations) {
+      process.removeListener(event, handler);
+    }
+    registrations.length = 0;
+  };
+  const flush = async (reason) => {
+    logger.debug(`${reason}: shutting down OpenTelemetry...`);
+    try {
+      await sdk.shutdown();
+      logger.debug("OpenTelemetry shutdown complete");
+    } catch (err) {
+      logger.error("Error shutting down OpenTelemetry", err);
+    }
+  };
+  const beginShutdown = () => {
+    if (isShuttingDown) return false;
+    isShuttingDown = true;
+    unregisterAll();
+    return true;
+  };
+  register("beforeExit", () => {
+    if (!beginShutdown()) return;
+    void flush("beforeExit");
+  });
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    register(signal, () => {
+      if (!beginShutdown()) return;
+      void flush(signal).then(
+        () => settleAfterSignalFlush({ signal, logger, exitProcessAfterShutdown })
+      );
+    });
+  }
+};
+function setupObservability(options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const logger = (_d = (_a = options.debug) == null ? void 0 : _a.logger) != null ? _d : new (0, _chunk5VYEG3RSjs.ConsoleLogger)({
+    level: (_c = (_b = options.debug) == null ? void 0 : _b.logLevel) != null ? _c : "warn",
+    prefix: "LangWatch Observability SDK"
+  });
+  _chunk5VYEG3RSjs.initializeObservabilitySdkConfig.call(void 0, {
+    logger,
+    dataCapture: options.dataCapture
+  });
+  if ((_e = options.advanced) == null ? void 0 : _e.disabled) {
+    logger.debug("Observability disabled via advanced.disabled");
+    return createNoOpHandle(logger);
+  }
+  if ((_f = options.advanced) == null ? void 0 : _f.skipOpenTelemetrySetup) {
+    logger.debug("Skipping OpenTelemetry setup");
+    return createNoOpHandle(logger);
+  }
+  if (options.tracerProvider) {
+    return setupDedicatedProviderOrNoOp(options.tracerProvider, options, logger);
+  }
+  const earlyExit = checkForEarlyExit(options, logger);
+  if (earlyExit) return earlyExit;
+  try {
+    const globalProvider = _api.trace.getTracerProvider();
+    const existingProvider = getConcreteProvider(globalProvider);
+    if (((_g = options.advanced) == null ? void 0 : _g.attachToExistingProvider) && existingProvider) {
+      return attachToExistingProviderOrNoOp(existingProvider, options, logger);
+    }
+    const sdk = createAndStartNodeSdk(
+      options,
+      logger,
+      createMergedResource(options.attributes, options.serviceName, options.resource)
+    );
+    logger.info("LangWatch Observability SDK setup completed successfully");
+    return {
+      shutdown: async () => {
+        logger.debug("Shutting down NodeSDK");
+        await (sdk == null ? void 0 : sdk.shutdown());
+        logger.info("NodeSDK shutdown complete");
+      }
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to initialize NodeSDK: ${errorMessage}`);
+    if (err instanceof Error && err.stack) {
+      logger.debug(`Stack trace: ${err.stack}`);
+    }
+    if ((_h = options.advanced) == null ? void 0 : _h.throwOnSetupError) throw err;
+    return createNoOpHandle(logger);
+  }
+}
+function setupDedicatedProviderOrNoOp(provider, options, logger) {
+  var _a;
+  try {
+    return setupDedicatedProvider(provider, options, logger);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to set up dedicated provider: ${errorMessage}`);
+    if ((_a = options.advanced) == null ? void 0 : _a.throwOnSetupError) throw err;
+    return createNoOpHandle(logger);
+  }
+}
+function attachToExistingProviderOrNoOp(provider, options, logger) {
+  var _a;
+  const handle = attachToExistingProvider(provider, options, logger);
+  if (handle) return handle;
+  const errorMsg = "attachToExistingProvider is enabled but the existing provider does not support adding span processors. This may be due to an incompatible OpenTelemetry version. No spans will be exported to LangWatch.";
+  if ((_a = options.advanced) == null ? void 0 : _a.throwOnSetupError) throw new Error(errorMsg);
+  logger.error(errorMsg);
+  return createNoOpHandle(logger);
+}
+function detachProcessors(provider, addedProcessors) {
+  for (const arr of listProcessorRegistryCandidates(provider)) {
+    if (!Array.isArray(arr)) continue;
+    for (const p of addedProcessors) {
+      const idx = arr.indexOf(p);
+      if (idx !== -1) arr.splice(idx, 1);
+    }
+  }
+}
+function setupDedicatedProvider(provider, options, logger) {
+  var _a, _b, _c;
+  const langwatch = getLangWatchConfig(options);
+  const addedProcessors = [];
+  const internalArray = readMember(readMember(provider, "_activeSpanProcessor"), "_spanProcessors");
+  const hasPublicApi = typeof readMember(provider, "addSpanProcessor") === "function";
+  if (!Array.isArray(internalArray) && !hasPublicApi) {
+    const msg = "Dedicated tracerProvider does not support adding span processors.";
+    if ((_a = options.advanced) == null ? void 0 : _a.throwOnSetupError) throw new Error(msg);
+    logger.error(msg);
+    return createNoOpHandle(logger);
+  }
+  const addProcessor = (processor) => {
+    if (hasPublicApi) {
+      callMember(provider, "addSpanProcessor", [processor]);
+    } else if (Array.isArray(internalArray)) {
+      internalArray.push(processor);
+    }
+  };
+  if (!langwatch.disabled) {
+    const traceExporter = new (0, _chunkMAO3SIBBjs.LangWatchTraceExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const processor = langwatch.processorType === "batch" ? new (0, _sdktracebase.BatchSpanProcessor)(traceExporter) : new (0, _sdktracebase.SimpleSpanProcessor)(traceExporter);
+    addedProcessors.push(processor);
+    addProcessor(processor);
+    logger.info("Attached LangWatch span processor to dedicated provider");
+  }
+  if (options.traceExporter) {
+    const p = new (0, _sdktracebase.SimpleSpanProcessor)(options.traceExporter);
+    addedProcessors.push(p);
+    addProcessor(p);
+  }
+  if ((_b = options.spanProcessors) == null ? void 0 : _b.length) {
+    for (const p of options.spanProcessors) {
+      addedProcessors.push(p);
+      addProcessor(p);
+    }
+  }
+  let unregisterInstrumentations;
+  if ((_c = options.instrumentations) == null ? void 0 : _c.length) {
+    unregisterInstrumentations = loadInstrumentation().registerInstrumentations({
+      tracerProvider: provider,
+      instrumentations: options.instrumentations
+    });
+    logger.info(
+      `Registered ${options.instrumentations.length} instrumentations against dedicated provider`
+    );
+  }
+  logger.info(
+    "LangWatch Observability SDK setup completed with dedicated provider (trace-only, global provider untouched)"
+  );
+  return {
+    shutdown: async () => {
+      logger.debug("Shutting down dedicated LangWatch processors");
+      try {
+        await Promise.all(addedProcessors.map((p) => p.shutdown()));
+      } finally {
+        detachProcessors(provider, addedProcessors);
+        unregisterInstrumentations == null ? void 0 : unregisterInstrumentations();
+      }
+      logger.info("LangWatch processor shutdown complete");
+    }
+  };
+}
+function attachToExistingProvider(provider, options, logger) {
+  var _a;
+  const internalArray = readMember(readMember(provider, "_activeSpanProcessor"), "_spanProcessors");
+  const hasPublicApi = typeof readMember(provider, "addSpanProcessor") === "function";
+  if (!Array.isArray(internalArray) && !hasPublicApi) {
+    return null;
+  }
+  const addProcessor = (processor) => {
+    if (hasPublicApi) {
+      callMember(provider, "addSpanProcessor", [processor]);
+    } else if (Array.isArray(internalArray)) {
+      internalArray.push(processor);
+    }
+  };
+  const langwatch = getLangWatchConfig(options);
+  const addedProcessors = [];
+  if (!langwatch.disabled) {
+    const traceExporter = new (0, _chunkMAO3SIBBjs.LangWatchTraceExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const processor = langwatch.processorType === "batch" ? new (0, _sdktracebase.BatchSpanProcessor)(traceExporter) : new (0, _sdktracebase.SimpleSpanProcessor)(traceExporter);
+    addedProcessors.push(processor);
+    addProcessor(processor);
+    logger.info("Attached LangWatch span processor to existing global provider");
+  }
+  if (options.traceExporter) {
+    const traceExporterProcessor = new (0, _sdktracebase.SimpleSpanProcessor)(options.traceExporter);
+    addedProcessors.push(traceExporterProcessor);
+    addProcessor(traceExporterProcessor);
+    logger.debug("Attached user-provided traceExporter to existing provider");
+  }
+  if ((_a = options.spanProcessors) == null ? void 0 : _a.length) {
+    for (const processor of options.spanProcessors) {
+      addedProcessors.push(processor);
+      addProcessor(processor);
+    }
+    logger.debug(
+      `Attached ${options.spanProcessors.length} user-provided span processors to existing provider`
+    );
+  }
+  return {
+    shutdown: async () => {
+      logger.debug("Shutting down attached LangWatch processors");
+      try {
+        await Promise.all(addedProcessors.map((p) => p.shutdown()));
+      } finally {
+        detachProcessors(provider, addedProcessors);
+      }
+      logger.info("LangWatch processor shutdown complete");
+    }
+  };
+}
+function applyNextJsProviderWorkaround(logger) {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    setImmediate(() => {
+      const globalProvider = _api.trace.getTracerProvider();
+      if (globalProvider.constructor.name === "ProxyTracerProvider") {
+        logger.warn(
+          "Global provider is still ProxyTracerProvider after SDK start - applying Next.js 15 workaround"
+        );
+        const realProvider = Reflect.get(globalProvider, "_delegate");
+        if (isNodeTracerProvider(realProvider)) {
+          _api.trace.setGlobalTracerProvider(realProvider);
+          logger.info("Successfully registered NodeTracerProvider globally for Next.js 15");
+        } else {
+          logger.error(
+            "Could not find NodeTracerProvider in proxy delegate - spans may not be exported"
+          );
+        }
+      } else {
+        logger.debug(`Provider registered correctly: ${globalProvider.constructor.name}`);
+      }
+    });
+  }
+}
+function createAndStartNodeSdk(options, logger, resource) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  refuseUnservedGrpc(options);
+  const langwatch = getLangWatchConfig(options);
+  if (langwatch.disabled) {
+    logger.warn(
+      "LangWatch integration disabled, using user-provided SpanProcessors and LogRecordProcessors"
+    );
+  } else {
+    logger.info(`Using LangWatch ${langwatch.processorType} processors for tracing and logging`);
+  }
+  const spanProcessors = [];
+  const logProcessors = [];
+  if ((_a = options.debug) == null ? void 0 : _a.consoleTracing) {
+    spanProcessors.push(new (0, _sdktracebase.SimpleSpanProcessor)(new (0, _sdktracebase.ConsoleSpanExporter)()));
+    logger.debug("Console tracing enabled; adding console span exporter");
+  }
+  if ((_b = options.debug) == null ? void 0 : _b.consoleLogging) {
+    logProcessors.push(new (0, _sdklogs.SimpleLogRecordProcessor)({ exporter: new (0, _sdklogs.ConsoleLogRecordExporter)() }));
+    logger.debug("Console recording of logs enabled; adding console log record processor");
+  }
+  if (!langwatch.disabled) {
+    const traceExporter = new (0, _chunkMAO3SIBBjs.LangWatchTraceExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const logExporter = new (0, _chunkMAO3SIBBjs.LangWatchLogsExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    if (langwatch.processorType === "batch") {
+      spanProcessors.push(new (0, _sdktracebase.BatchSpanProcessor)(traceExporter));
+      logProcessors.push(new (0, _sdklogs.BatchLogRecordProcessor)({ exporter: logExporter }));
+      logger.debug(
+        `Added LangWatch ${langwatch.processorType} SpanProcessor and LogRecordProcessor to SDK`
+      );
+    } else {
+      spanProcessors.push(new (0, _sdktracebase.SimpleSpanProcessor)(traceExporter));
+      logProcessors.push(new (0, _sdklogs.SimpleLogRecordProcessor)({ exporter: logExporter }));
+      logger.debug(
+        `Added LangWatch ${langwatch.processorType} SpanProcessor and LogRecordProcessor to SDK`
+      );
+    }
+  }
+  if (options.traceExporter) {
+    spanProcessors.push(new (0, _sdktracebase.SimpleSpanProcessor)(options.traceExporter));
+    logger.debug(`Added user-provided SpanProcessor to SDK`);
+  }
+  if ((_c = options.spanProcessors) == null ? void 0 : _c.length) {
+    spanProcessors.push(...options.spanProcessors);
+    logger.debug(`Added user-provided ${options.spanProcessors.length} SpanProcessors to SDK`);
+  }
+  if ((_d = options.logRecordProcessors) == null ? void 0 : _d.length) {
+    logProcessors.push(...options.logRecordProcessors);
+    logger.debug(
+      `Added user-provided ${options.logRecordProcessors.length} LogRecordProcessors to SDK`
+    );
+  }
+  warnIfMisconfigured(options, langwatch, logger);
+  const loggerProvider = logProcessors.length ? new (0, _sdklogs.LoggerProvider)({
+    resource,
+    processors: logProcessors
+  }) : void 0;
+  if (loggerProvider) {
+    logger.debug("Created LangWatch logger provider");
+  }
+  const sdk = new NodeSdk({
+    logger,
+    resource,
+    serviceName: options.serviceName,
+    autoDetectResources: options.autoDetectResources,
+    contextManager: options.contextManager,
+    textMapPropagator: options.textMapPropagator,
+    metricReader: options.metricReader,
+    views: options.views,
+    resourceDetectors: options.resourceDetectors,
+    sampler: options.sampler,
+    spanProcessors,
+    logRecordProcessors: logProcessors,
+    spanLimits: options.spanLimits,
+    idGenerator: options.idGenerator,
+    instrumentations: options.instrumentations
+  });
+  sdk.start();
+  logger.info("NodeSDK started successfully");
+  applyNextJsProviderWorkaround(logger);
+  if (loggerProvider) {
+    _chunkMAO3SIBBjs.setLangWatchLoggerProvider.call(void 0, loggerProvider);
+    logger.debug("Set LangWatch logger provider");
+  }
+  if (!((_e = options.advanced) == null ? void 0 : _e.disableAutoShutdown)) {
+    registerAutoShutdownHandlers({
+      sdk,
+      logger,
+      exitProcessAfterShutdown: (_g = (_f = options.advanced) == null ? void 0 : _f.UNSAFE_exitProcessAfterAutoShutdown) != null ? _g : false
+    });
+  }
+  return sdk;
+}
+var ensureSetup = () => {
+  const globalProvider = _api.trace.getTracerProvider();
+  const alreadySetup = isConcreteProvider(globalProvider);
+  if (alreadySetup) {
+    return {
+      shutdown: async () => {
+      }
+    };
+  }
+  if (!process.env.LANGWATCH_API_KEY) {
+    return {
+      shutdown: async () => {
+      }
+    };
+  }
+  return setupObservability();
+};
+function isNodeTracerProvider(value) {
+  return typeof value === "object" && value !== null && value.constructor.name === "NodeTracerProvider";
+}
+
+
+
+
+
+exports.resolveEndpoint = resolveEndpoint; exports.setupObservability = setupObservability; exports.ensureSetup = ensureSetup;
+//# sourceMappingURL=chunk-DLZCOUXC.js.map