langwatch 0.3.2 → 0.4.0

package/dist/observability-sdk/setup/node/index.d.ts

@@ -0,0 +1,368 @@
+import { L as Logger } from '../../../index-DTEZr0Jn.js';
+import { Instrumentation } from '@opentelemetry/instrumentation';
+import { SpanExporter, SpanProcessor, SpanLimits, Sampler, IdGenerator } from '@opentelemetry/sdk-trace-base';
+import { ContextManager, TextMapPropagator } from '@opentelemetry/api';
+import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { IMetricReader, ViewOptions } from '@opentelemetry/sdk-metrics';
+import { ResourceDetector, Resource } from '@opentelemetry/resources';
+import { S as SemConvAttributes } from '../../../types-DRiQaKFG.js';
+import { D as DataCaptureOptions } from '../../../types-Dmazk5Bk.js';
+import '@opentelemetry/api-logs';
+import '@opentelemetry/semantic-conventions';
+import '@opentelemetry/semantic-conventions/incubating';
+
+/**
+ * Configuration options for setting up LangWatch observability.
+ *
+ * This interface provides comprehensive configuration for initializing
+ * LangWatch tracing with a familiar flat structure for main options
+ * and grouped sections for debug and advanced configuration.
+ *
+ * @example
+ * ```typescript
+ * const options: SetupObservabilityOptions = {
+ *   langwatch: {
+ *     apiKey: "sk-lw-1234567890abcdef"
+ *   },
+ *   serviceName: "my-service",
+ *   attributes: {
+ *     "service.version": "1.0.0",
+ *     "deployment.environment": "production"
+ *   },
+ *   spanProcessors: [new BatchSpanProcessor(new JaegerExporter())],
+ *   debug: {
+ *     consoleTracing: true,
+ *     logLevel: 'debug'
+ *   }
+ * };
+ * ```
+ */
+interface SetupObservabilityOptions {
+    /**
+     * LangWatch configuration for sending observability data to LangWatch.
+     *
+     * Set to 'disabled' to completely disable LangWatch integration.
+     * API key and endpoint can also be set via LANGWATCH_API_KEY and
+     * LANGWATCH_ENDPOINT environment variables.
+     */
+    langwatch?: {
+        /**
+         * LangWatch API key for authentication.
+         * Defaults to LANGWATCH_API_KEY environment variable.
+         *
+         * @example "sk-lw-1234567890abcdef"
+         * @default LANGWATCH_API_KEY environment variable
+         */
+        apiKey?: string;
+        /**
+         * LangWatch endpoint URL for sending traces and logs.
+         * Defaults to LANGWATCH_ENDPOINT environment variable or production endpoint.
+         *
+         * @default "https://api.langwatch.ai"
+         * @default LANGWATCH_ENDPOINT environment variable
+         */
+        endpoint?: string;
+        /**
+         * Type of span processor to use for LangWatch exporter.
+         *
+         * - 'simple': Exports spans immediately (good for debugging)
+         * - 'batch': Batches spans for better performance (recommended for production)
+         *
+         * @default 'simple'
+         */
+        processorType?: "simple" | "batch";
+    } | "disabled";
+    /**
+     * Name of the service being instrumented.
+     * Used to identify your service in traces, logs, and metrics.
+     *
+     * @example "user-service"
+     */
+    serviceName?: string;
+    /**
+     * Global attributes added to all telemetry data.
+     * Useful for adding service-level metadata like version, environment, etc.
+     *
+     * @example { "service.version": "1.0.0", "deployment.environment": "production" }
+     */
+    attributes?: SemConvAttributes;
+    /**
+     * Configuration for automatic data capture.
+     *
+     * This provides control over input/output data capture by LangWatch instrumentations.
+     * You can use a simple string mode, a configuration object, or a predicate function
+     * for dynamic control based on the operation context.
+     *
+     * @example
+     * ```typescript
+     * // Simple mode - capture everything
+     * dataCapture: "all"
+     *
+     * // Simple mode - capture only input data
+     * dataCapture: "input"
+     *
+     * // Simple mode - capture only output data
+     * dataCapture: "output"
+     *
+     * // Simple mode - capture nothing
+     * dataCapture: "none"
+     *
+     * // Configuration object
+     * dataCapture: {
+     *   mode: "all"
+     * }
+     *
+     * // Dynamic predicate function
+     * dataCapture: (context) => {
+     *   // Don't capture sensitive data in production
+     *   if (context.environment === "production" &&
+     *       context.operationName.includes("password")) {
+     *     return "none";
+     *   }
+     *   // Capture everything else
+     *   return "all";
+     * }
+     * ```
+     *
+     * @default "all"
+     */
+    dataCapture?: DataCaptureOptions;
+    /**
+     * Custom trace exporter for sending spans to external systems.
+     * If not provided, LangWatch will create its own exporter.
+     * This is a simpler alternative to spanProcessors for single exporter use cases.
+     *
+     * @example new OTLPTraceExporter({ url: "https://custom-collector.com/v1/traces" })
+     */
+    traceExporter?: SpanExporter;
+    /**
+     * Custom span processors for advanced trace processing.
+     * Use this when you need full control over batching, filtering, or
+     * custom processing logic.
+     *
+     * @example [new SimpleSpanProcessor(new LangWatchExporter())]
+     * @example [new BatchSpanProcessor(exporter, { maxExportBatchSize: 100 })]
+     */
+    spanProcessors?: SpanProcessor[];
+    /**
+     * Span limits configuration.
+     * Controls the maximum number of attributes, events, and links per span.
+     *
+     * @example { attributeCountLimit: 128, eventCountLimit: 128 }
+     */
+    spanLimits?: SpanLimits;
+    /**
+     * Sampling strategy for controlling which traces to collect.
+     *
+     * @example new TraceIdRatioBasedSampler(0.1) // Sample 10% of traces
+     */
+    sampler?: Sampler;
+    /**
+     * Custom ID generator for span and trace IDs.
+     *
+     * @example new RandomIdGenerator()
+     */
+    idGenerator?: IdGenerator;
+    /**
+     * Custom log record processors for advanced log processing.
+     * Use this when you need full control over batching, filtering, or
+     * custom processing logic.
+     *
+     * @example [new BatchLogRecordProcessor(exporter, { maxExportBatchSize: 100 })]
+     */
+    logRecordProcessors?: LogRecordProcessor[];
+    /**
+     * Custom metric reader for collecting and exporting metrics.
+     *
+     * @example new PeriodicExportingMetricReader({ exporter: new PrometheusExporter() })
+     */
+    metricReader?: IMetricReader;
+    /**
+     * Metric views for controlling aggregation and filtering.
+     * Views determine which metrics are collected and how they are processed.
+     *
+     * @example [{ instrumentName: 'http.server.duration', aggregation: Aggregation.Histogram() }]
+     */
+    views?: ViewOptions[];
+    /**
+     * Auto-instrumentation libraries to enable.
+     * These automatically capture telemetry from common libraries and frameworks.
+     *
+     * @example [new HttpInstrumentation(), new ExpressInstrumentation()]
+     */
+    instrumentations?: (Instrumentation | Instrumentation[])[];
+    /**
+     * Whether to automatically detect and configure resource attributes.
+     * When enabled, OpenTelemetry automatically detects host, process, and environment info.
+     *
+     * @default true
+     */
+    autoDetectResources?: boolean;
+    /**
+     * Custom context manager for managing trace context across async operations.
+     */
+    contextManager?: ContextManager;
+    /**
+     * Text map propagator for trace context propagation across service boundaries.
+     * Controls how trace context is serialized in HTTP headers and other carriers.
+     *
+     * @example new W3CTraceContextPropagator()
+     */
+    textMapPropagator?: TextMapPropagator;
+    /**
+     * Resource detectors for automatic resource attribute detection.
+     * These detect information about the runtime environment.
+     *
+     * @example [envDetector, processDetector, hostDetector]
+     */
+    resourceDetectors?: Array<ResourceDetector>;
+    /**
+     * Custom resource configuration representing the entity being monitored.
+     * Includes service, host, and deployment metadata.
+     *
+     * @example new Resource({ "service.name": "my-service", "service.version": "1.0.0" })
+     */
+    resource?: Resource;
+    /**
+     * Debug and development options.
+     * These control console output and SDK internal logging behavior.
+     */
+    debug?: {
+        /**
+         * Enable console output for traces (debugging).
+         * When true, spans will be logged to the console in addition
+         * to any other configured exporters.
+         *
+         * @default false
+         */
+        consoleTracing?: boolean;
+        /**
+         * Enable console output for logs (debugging).
+         * When true, log records will be logged to the console in addition
+         * to any other configured exporters.
+         *
+         * @default false
+         */
+        consoleLogging?: boolean;
+        /**
+         * Log level for LangWatch SDK internal logging.
+         * Controls verbosity of SDK diagnostic messages.
+         *
+         * @default 'warn'
+         */
+        logLevel?: "debug" | "info" | "warn" | "error";
+        /**
+         * Custom logger for LangWatch SDK internal logging.
+         * If not provided, a console logger will be used.
+         */
+        logger?: Logger;
+    };
+    /**
+     * Advanced and potentially unsafe configuration options.
+     * These options are for special use cases and should be used with caution.
+     */
+    advanced?: {
+        /**
+         * Whether to throw errors during setup or return no-op handles.
+         *
+         * When false (default), setup errors are logged but the function
+         * returns no-op handles to prevent breaking your application.
+         * When true, setup errors will be thrown.
+         *
+         * @default false
+         */
+        throwOnSetupError?: boolean;
+        /**
+         * Skip OpenTelemetry setup entirely and return no-op handles.
+         * Useful when you want to handle OpenTelemetry setup yourself.
+         *
+         * @default false
+         */
+        skipOpenTelemetrySetup?: boolean;
+        /**
+         * Force reinitialization of OpenTelemetry even if already set up.
+         *
+         * WARNING: This can cause conflicts and is primarily intended for testing.
+         * Use with extreme caution in production.
+         *
+         * @default false
+         */
+        UNSAFE_forceOpenTelemetryReinitialization?: boolean;
+        /**
+         * Disable all observability setup and return no-op handles.
+         *
+         * When true, no OpenTelemetry setup will occur and all operations
+         * will be no-ops. Useful for testing or when you want to completely
+         * disable observability without changing your code.
+         *
+         * @default false
+         */
+        disabled?: boolean;
+        /**
+         * Disable the automatic shutdown of the observability system when the application
+         * terminates.
+         *
+         * @default false
+         */
+        disableAutoShutdown?: boolean;
+    };
+}
+/**
+ * Handle returned from observability setup. If you disable the automatic shutdown,
+ * do you are running in an environment where you can't listen to SIGTERM to handle
+ * shutdowns, you can use the shutdown function to manually shut down the
+ * observability system, and ensure that no data is lost.
+ *
+ * @example
+ * ```typescript
+ * const { shutdown } = setupObservability(options);
+ *
+ * // Shutdown when the application is terminating
+ * process.on('SIGTERM', async () => {
+ *   await shutdown();
+ *   process.exit(0);
+ * });
+ * ```
+ */
+interface ObservabilityHandle {
+    /**
+     * Gracefully shuts down the observability system.
+     *
+     * This method should be called when the application is terminating
+     * to ensure all pending traces are exported before shutdown.
+     *
+     * The shutdown process:
+     * 1. Flushes any pending traces to the exporter
+     * 2. Closes the trace exporter
+     * 3. Shuts down the tracer provider
+     * 4. Cleans up any registered instrumentations
+     *
+     * @returns Promise that resolves when shutdown is complete
+     *
+     * @example
+     * ```typescript
+     * // Graceful shutdown
+     * process.on('SIGTERM', async () => {
+     *   console.log('Shutting down observability...');
+     *   await shutdown();
+     *   console.log('Observability shutdown complete');
+     *   process.exit(0);
+     * });
+     *
+     * // Force shutdown with timeout
+     * process.on('SIGINT', async () => {
+     *   console.log('Force shutdown...');
+     *   await Promise.race([
+     *     shutdown(),
+     *     new Promise(resolve => setTimeout(resolve, 5000))
+     *   ]);
+     *   process.exit(1);
+     * });
+     * ```
+     */
+    shutdown: () => Promise<void>;
+}
+
+declare function setupObservability(options?: SetupObservabilityOptions): ObservabilityHandle;
+
+export { type ObservabilityHandle, type SetupObservabilityOptions, setupObservability };

package/dist/observability-sdk/setup/node/index.js

@@ -0,0 +1,276 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+
+
+
+
+
+var _chunkOUCVXP4Gjs = require('../../../chunk-OUCVXP4G.js');
+
+
+
+var _chunkDISMHYXCjs = require('../../../chunk-DISMHYXC.js');
+
+
+var _chunkOXBO24RBjs = require('../../../chunk-OXBO24RB.js');
+
+// src/observability-sdk/setup/node/setup.ts
+var _sdknode = require('@opentelemetry/sdk-node');
+var _sdklogs = require('@opentelemetry/sdk-logs');
+
+// src/observability-sdk/setup/utils.ts
+
+
+
+var _resources = require('@opentelemetry/resources');
+var _incubating = require('@opentelemetry/semantic-conventions/incubating'); var semconv = _interopRequireWildcard(_incubating);
+function createMergedResource(attributes, serviceName, givenResource) {
+  const langwatchResource = _resources.resourceFromAttributes.call(void 0, {
+    [semconv.ATTR_TELEMETRY_SDK_NAME]: _chunkOUCVXP4Gjs.LANGWATCH_SDK_NAME_OBSERVABILITY,
+    [semconv.ATTR_TELEMETRY_SDK_LANGUAGE]: _chunkOUCVXP4Gjs.LANGWATCH_SDK_LANGUAGE,
+    [semconv.ATTR_TELEMETRY_SDK_VERSION]: _chunkOUCVXP4Gjs.LANGWATCH_SDK_VERSION
+  });
+  const userResource = _resources.resourceFromAttributes.call(void 0, _chunkOXBO24RBjs.__spreadValues.call(void 0, {
+    [semconv.ATTR_SERVICE_NAME]: serviceName != null ? serviceName : _chunkOUCVXP4Gjs.DEFAULT_SERVICE_NAME
+  }, attributes != null ? attributes : {}));
+  return (givenResource != null ? givenResource : _resources.defaultResource.call(void 0, )).merge(langwatchResource).merge(userResource);
+}
+function getConcreteProvider(provider) {
+  var _a, _b;
+  if (!provider || typeof provider !== "object") return void 0;
+  const constructorName = (_a = provider.constructor) == null ? void 0 : _a.name;
+  if (["NodeTracerProvider", "BasicTracerProvider"].includes(constructorName)) {
+    return provider;
+  }
+  if (typeof provider.addSpanProcessor === "function") {
+    return provider;
+  }
+  let delegate;
+  if (typeof provider.getDelegate === "function") {
+    delegate = provider.getDelegate();
+  } else if (provider.delegate) {
+    delegate = provider.delegate;
+  }
+  if (delegate && typeof delegate === "object") {
+    const delegateConstructorName = (_b = delegate.constructor) == null ? void 0 : _b.name;
+    if (["NodeTracerProvider", "BasicTracerProvider"].includes(delegateConstructorName)) {
+      return delegate;
+    }
+    if (typeof delegate.addSpanProcessor === "function") {
+      return delegate;
+    }
+  }
+  return void 0;
+}
+function isConcreteProvider(provider) {
+  return !!getConcreteProvider(provider);
+}
+
+// src/observability-sdk/setup/node/setup.ts
+var _api = require('@opentelemetry/api');
+
+
+
+
+var _sdktracebase = require('@opentelemetry/sdk-trace-base');
+var createNoOpHandle = (logger) => ({
+  shutdown: async () => {
+    logger.debug("Shutdown called for LangWatch no-op. Nothing will be shutdown");
+  }
+});
+var getLangWatchConfig = (options) => {
+  var _a, _b, _c, _d;
+  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 : (_c = (_b = config.endpoint) != null ? _b : process.env.LANGWATCH_ENDPOINT) != null ? _c : "https://api.langwatch.ai",
+    processorType: (_d = config.processorType) != null ? _d : "simple"
+  };
+};
+var checkForEarlyExit = (options, logger) => {
+  var _a, _b, _c;
+  if ((_a = options.advanced) == null ? void 0 : _a.disabled) {
+    logger.debug("Observability disabled via advanced.disabled");
+    return createNoOpHandle(logger);
+  }
+  if ((_b = options.advanced) == null ? void 0 : _b.skipOpenTelemetrySetup) {
+    logger.debug("Skipping OpenTelemetry setup");
+    return createNoOpHandle(logger);
+  }
+  const globalProvider = _api.trace.getTracerProvider();
+  const alreadySetup = isConcreteProvider(globalProvider);
+  if (alreadySetup && !((_c = options.advanced) == null ? void 0 : _c.UNSAFE_forceOpenTelemetryReinitialization)) {
+    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.
+
+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);
+      }
+    }
+  }
+};
+function setupObservability(options = {}) {
+  var _a, _b, _c, _d, _e;
+  const logger = (_d = (_a = options.debug) == null ? void 0 : _a.logger) != null ? _d : new (0, _chunkDISMHYXCjs.ConsoleLogger)({
+    level: (_c = (_b = options.debug) == null ? void 0 : _b.logLevel) != null ? _c : "warn",
+    prefix: "LangWatch Observability SDK"
+  });
+  _chunkDISMHYXCjs.initializeObservabilitySdkConfig.call(void 0, {
+    logger,
+    dataCapture: options.dataCapture
+  });
+  const earlyExit = checkForEarlyExit(options, logger);
+  if (earlyExit) return earlyExit;
+  try {
+    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 ((_e = options.advanced) == null ? void 0 : _e.throwOnSetupError) throw err;
+    return createNoOpHandle(logger);
+  }
+}
+function createAndStartNodeSdk(options, logger, resource) {
+  var _a, _b, _c, _d, _e;
+  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)(new (0, _sdklogs.ConsoleLogRecordExporter)()));
+    logger.debug("Console recording of logs enabled; adding console log record processor");
+  }
+  if (!langwatch.disabled) {
+    const traceExporter = new (0, _chunkOUCVXP4Gjs.LangWatchTraceExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const logExporter = new (0, _chunkOUCVXP4Gjs.LangWatchLogsExporter)({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    if (langwatch.processorType === "batch") {
+      spanProcessors.push(new (0, _sdktracebase.BatchSpanProcessor)(traceExporter));
+      logProcessors.push(new (0, _sdklogs.BatchLogRecordProcessor)(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)(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 (0, _sdknode.NodeSDK)({
+    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");
+  if (loggerProvider) {
+    _chunkOUCVXP4Gjs.setLangWatchLoggerProvider.call(void 0, loggerProvider);
+    logger.debug("Set LangWatch logger provider");
+  }
+  if (!((_e = options.advanced) == null ? void 0 : _e.disableAutoShutdown)) {
+    process.on("SIGTERM", () => {
+      void (async () => {
+        logger.debug("SIGTERM received: shutting down OpenTelemetry...");
+        try {
+          await sdk.shutdown();
+          logger.debug("OpenTelemetry shutdown complete");
+        } catch (err) {
+          logger.error("Error shutting down OpenTelemetry", err);
+        } finally {
+          process.exit(0);
+        }
+      })();
+    });
+  }
+  return sdk;
+}
+
+
+exports.setupObservability = setupObservability;
+//# sourceMappingURL=index.js.map