@atrim/instrument-node 0.5.0-14fdea7-20260108232035 → 0.5.0-14fdea7-20260109020503

package/target/dist/index.js

@@ -0,0 +1,1385 @@
+import { Data, Context, Effect, Layer } from 'effect';
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+import { trace } from '@opentelemetry/api';
+import { FileSystem } from '@effect/platform/FileSystem';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { createRequire } from 'module';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var PatternConfigSchema = z.object({
+  pattern: z.string(),
+  enabled: z.boolean().optional(),
+  description: z.string().optional()
+});
+var AutoIsolationConfigSchema = z.object({
+  // Global enable/disable for auto-isolation
+  enabled: z.boolean().default(false),
+  // Which operators to auto-isolate
+  operators: z.object({
+    fiberset_run: z.boolean().default(true),
+    effect_fork: z.boolean().default(true),
+    effect_fork_daemon: z.boolean().default(true),
+    effect_fork_in: z.boolean().default(false)
+  }).default({}),
+  // Virtual parent tracking configuration
+  tracking: z.object({
+    use_span_links: z.boolean().default(true),
+    use_attributes: z.boolean().default(true),
+    capture_logical_parent: z.boolean().default(true)
+  }).default({}),
+  // Span categorization
+  attributes: z.object({
+    category: z.string().default("background_task"),
+    add_metadata: z.boolean().default(true)
+  }).default({})
+});
+var SpanNamingRuleSchema = z.object({
+  // Match criteria (all specified criteria must match)
+  match: z.object({
+    // Regex pattern to match file path
+    file: z.string().optional(),
+    // Regex pattern to match function name
+    function: z.string().optional(),
+    // Regex pattern to match module name
+    module: z.string().optional()
+  }),
+  // Span name template with variables:
+  // {fiber_id} - Fiber ID
+  // {function} - Function name
+  // {module} - Module name
+  // {file} - File path
+  // {line} - Line number
+  // {operator} - Effect operator (gen, all, forEach, etc.)
+  // {match:field:N} - Captured regex group from match
+  name: z.string()
+});
+var AutoInstrumentationConfigSchema = z.object({
+  // Enable/disable auto-instrumentation
+  enabled: z.boolean().default(false),
+  // Tracing granularity
+  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+  granularity: z.enum(["fiber", "operator"]).default("fiber"),
+  // Smart span naming configuration
+  span_naming: z.object({
+    // Default span name template when no rules match
+    default: z.string().default("effect.fiber.{fiber_id}"),
+    // Infer span names from source code (requires stack trace parsing)
+    // Adds ~50-100μs overhead per fiber
+    infer_from_source: z.boolean().default(true),
+    // Naming rules (first match wins)
+    rules: z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern-based filtering
+  filter: z.object({
+    // Only trace spans matching these patterns (empty = trace all)
+    include: z.array(z.string()).default([]),
+    // Never trace spans matching these patterns
+    exclude: z.array(z.string()).default([])
+  }).default({}),
+  // Performance controls
+  performance: z.object({
+    // Sample rate (0.0 - 1.0)
+    sampling_rate: z.number().min(0).max(1).default(1),
+    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+    min_duration: z.string().default("0ms"),
+    // Maximum concurrent traced fibers (0 = unlimited)
+    max_concurrent: z.number().default(0)
+  }).default({}),
+  // Automatic metadata extraction
+  metadata: z.object({
+    // Extract Effect fiber information
+    fiber_info: z.boolean().default(true),
+    // Extract source location (file:line)
+    source_location: z.boolean().default(true),
+    // Extract parent fiber information
+    parent_fiber: z.boolean().default(true)
+  }).default({})
+});
+var HttpFilteringConfigSchema = z.object({
+  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
+  ignore_outgoing_urls: z.array(z.string()).optional(),
+  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+  ignore_incoming_paths: z.array(z.string()).optional(),
+  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+  require_parent_for_outgoing_spans: z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: z.object({
+    // Strategy for trace propagation
+    // - "all": Propagate to all cross-origin requests (may cause CORS errors)
+    // - "none": Never propagate trace headers
+    // - "same-origin": Only propagate to same-origin requests (default, safe)
+    // - "patterns": Propagate based on include_urls patterns
+    strategy: z.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
+    // URL patterns to include when strategy is "patterns"
+    // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
+    include_urls: z.array(z.string()).optional()
+  }).optional()
+});
+var ExporterConfigSchema = z.object({
+  // Exporter type: 'otlp' | 'console' | 'none'
+  // - 'otlp': Export to OTLP endpoint (production)
+  // - 'console': Log spans to console (development)
+  // - 'none': No export (disable tracing)
+  type: z.enum(["otlp", "console", "none"]).default("otlp"),
+  // OTLP endpoint URL (for type: otlp)
+  // Defaults to OTEL_EXPORTER_OTLP_ENDPOINT env var or http://localhost:4318
+  endpoint: z.string().optional(),
+  // Custom headers to send with OTLP requests (for type: otlp)
+  // Useful for authentication (x-api-key, Authorization, etc.)
+  headers: z.record(z.string()).optional(),
+  // Span processor type
+  // - 'batch': Batch spans for export (production, lower overhead)
+  // - 'simple': Export immediately (development, no batching delay)
+  processor: z.enum(["batch", "simple"]).default("batch"),
+  // Batch processor settings (for processor: batch)
+  batch: z.object({
+    // Max time to wait before exporting (milliseconds)
+    scheduled_delay_millis: z.number().default(1e3),
+    // Max batch size
+    max_export_batch_size: z.number().default(100)
+  }).optional()
+});
+var InstrumentationConfigSchema = z.object({
+  version: z.string(),
+  instrumentation: z.object({
+    enabled: z.boolean(),
+    description: z.string().optional(),
+    logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
+    instrument_patterns: z.array(PatternConfigSchema),
+    ignore_patterns: z.array(PatternConfigSchema)
+  }),
+  effect: z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: z.boolean().default(true),
+    // Exporter mode (legacy - use exporter.type instead):
+    // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
+    // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+    exporter: z.enum(["unified", "standalone"]).default("unified"),
+    // Exporter configuration (for auto-instrumentation)
+    exporter_config: ExporterConfigSchema.optional(),
+    auto_extract_metadata: z.boolean(),
+    auto_isolation: AutoIsolationConfigSchema.optional(),
+    // Auto-instrumentation: automatic tracing of all Effect fibers
+    auto_instrumentation: AutoInstrumentationConfigSchema.optional()
+  }).optional(),
+  http: HttpFilteringConfigSchema.optional()
+});
+var defaultConfig = {
+  version: "1.0",
+  instrumentation: {
+    enabled: true,
+    logging: "on",
+    description: "Default instrumentation configuration",
+    instrument_patterns: [
+      { pattern: "^app\\.", enabled: true, description: "Application operations" },
+      { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
+      { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
+    ],
+    ignore_patterns: [
+      { pattern: "^test\\.", description: "Test utilities" },
+      { pattern: "^internal\\.", description: "Internal operations" },
+      { pattern: "^health\\.", description: "Health checks" }
+    ]
+  },
+  effect: {
+    enabled: true,
+    exporter: "unified",
+    auto_extract_metadata: true
+  }
+};
+function parseAndValidateConfig(content) {
+  let parsed;
+  if (typeof content === "string") {
+    parsed = parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
+(class extends Data.TaggedError("ConfigError") {
+  get message() {
+    return this.reason;
+  }
+});
+var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
+};
+(class extends Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("ShutdownError") {
+  get message() {
+    return this.reason;
+  }
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3
+  // 5 seconds
+};
+var ConfigLoader = class extends Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => Effect.gen(function* () {
+  const parsed = yield* Effect.try({
+    try: () => parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* Effect.try({
+    try: () => InstrumentationConfigSchema.parse(parsed),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
+      cause: error
+    })
+  });
+});
+var loadFromFileWithFs = (fs, path, uri) => Effect.gen(function* () {
+  const content = yield* fs.readFileString(path).pipe(
+    Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* Effect.fail(
+      new ConfigFileError({
+        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  return yield* parseYamlContent(content, uri);
+});
+var loadFromHttpWithClient = (client, url) => Effect.scoped(
+  Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest.get(url).pipe(
+      HttpClientRequest.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
+      })
+    );
+    const response = yield* client.execute(request).pipe(
+      Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      Effect.mapError((error) => {
+        if (error._tag === "TimeoutException") {
+          return new ConfigUrlError({
+            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms from ${url}`
+          });
+        }
+        return new ConfigUrlError({
+          reason: `Failed to load config from URL: ${url}`,
+          cause: error
+        });
+      })
+    );
+    if (response.status >= 400) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          cause: error
+        })
+      )
+    );
+    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = Effect.gen(function* () {
+  const fs = yield* Effect.serviceOption(FileSystem);
+  const http = yield* HttpClient.HttpClient;
+  const loadFromUriUncached = (uri) => Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* Effect.fail(
+          new ConfigFileError({
+            reason: "FileSystem not available (browser environment?)",
+            cause: { uri }
+          })
+        );
+      }
+      return yield* loadFromFileWithFs(fs.value, path, uri);
+    }
+    if (uri.startsWith("http://") || uri.startsWith("https://")) {
+      return yield* loadFromHttpWithClient(http, uri);
+    }
+    if (fs._tag === "Some") {
+      return yield* loadFromFileWithFs(fs.value, uri, uri);
+    } else {
+      return yield* loadFromHttpWithClient(http, uri);
+    }
+  });
+  const loadFromUriCached = yield* Effect.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* Effect.try({
+        try: () => InstrumentationConfigSchema.parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: "Invalid configuration schema",
+          cause: error
+        })
+      });
+    })
+  });
+});
+Layer.effect(ConfigLoader, makeConfigLoader);
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField2(this, "ignorePatterns", []);
+    __publicField2(this, "instrumentPatterns", []);
+    __publicField2(this, "enabled", true);
+    this.enabled = config.instrumentation.enabled;
+    this.ignorePatterns = config.instrumentation.ignore_patterns.map((p) => this.compilePattern(p));
+    this.instrumentPatterns = config.instrumentation.instrument_patterns.filter((p) => p.enabled !== false).map((p) => this.compilePattern(p));
+  }
+  /**
+   * Compile a pattern configuration into a RegExp
+   */
+  compilePattern(pattern) {
+    try {
+      const compiled = {
+        regex: new RegExp(pattern.pattern),
+        enabled: pattern.enabled !== false
+      };
+      if (pattern.description !== void 0) {
+        compiled.description = pattern.description;
+      }
+      return compiled;
+    } catch (error) {
+      throw new Error(
+        `Failed to compile pattern "${pattern.pattern}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if a span should be instrumented
+   *
+   * Returns true if the span should be created, false otherwise.
+   *
+   * Logic:
+   * 1. If instrumentation disabled globally, return false
+   * 2. Check ignore patterns - if any match, return false
+   * 3. Check instrument patterns - if any match, return true
+   * 4. Default: return true (fail-open - create span if no patterns match)
+   */
+  shouldInstrument(spanName) {
+    if (!this.enabled) {
+      return false;
+    }
+    for (const pattern of this.ignorePatterns) {
+      if (pattern.regex.test(spanName)) {
+        return false;
+      }
+    }
+    for (const pattern of this.instrumentPatterns) {
+      if (pattern.enabled && pattern.regex.test(spanName)) {
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get statistics about pattern matching (for debugging/monitoring)
+   */
+  getStats() {
+    return {
+      enabled: this.enabled,
+      ignorePatternCount: this.ignorePatterns.length,
+      instrumentPatternCount: this.instrumentPatterns.filter((p) => p.enabled).length
+    };
+  }
+};
+var globalMatcher = null;
+function initializePatternMatcher(config) {
+  globalMatcher = new PatternMatcher(config);
+}
+function shouldInstrumentSpan(spanName) {
+  if (!globalMatcher) {
+    return true;
+  }
+  return globalMatcher.shouldInstrument(spanName);
+}
+function getPatternMatcher() {
+  return globalMatcher;
+}
+var Logger = class {
+  constructor() {
+    __publicField2(this, "level", "on");
+    __publicField2(this, "hasLoggedMinimal", false);
+  }
+  /**
+   * Set the logging level
+   */
+  setLevel(level) {
+    this.level = level;
+    this.hasLoggedMinimal = false;
+  }
+  /**
+   * Get the current logging level
+   */
+  getLevel() {
+    return this.level;
+  }
+  /**
+   * Log a minimal initialization message (only shown once in minimal mode)
+   */
+  minimal(message) {
+    if (this.level === "off") {
+      return;
+    }
+    if (this.level === "minimal" && !this.hasLoggedMinimal) {
+      console.log(message);
+      this.hasLoggedMinimal = true;
+      return;
+    }
+    if (this.level === "on") {
+      console.log(message);
+    }
+  }
+  /**
+   * Log an informational message
+   */
+  log(...args) {
+    if (this.level === "on") {
+      console.log(...args);
+    }
+  }
+  /**
+   * Log a warning message (shown in minimal mode)
+   */
+  warn(...args) {
+    if (this.level !== "off") {
+      console.warn(...args);
+    }
+  }
+  /**
+   * Log an error message (shown in minimal mode)
+   */
+  error(...args) {
+    if (this.level !== "off") {
+      console.error(...args);
+    }
+  }
+  /**
+   * Check if full logging is enabled
+   */
+  isEnabled() {
+    return this.level === "on";
+  }
+  /**
+   * Check if minimal logging is enabled
+   */
+  isMinimal() {
+    return this.level === "minimal";
+  }
+  /**
+   * Check if logging is completely disabled
+   */
+  isDisabled() {
+    return this.level === "off";
+  }
+};
+var logger = new Logger();
+
+// src/core/span-processor.ts
+var PatternSpanProcessor = class {
+  constructor(config, wrappedProcessor) {
+    __publicField(this, "matcher");
+    __publicField(this, "wrappedProcessor");
+    __publicField(this, "httpIgnorePatterns", []);
+    this.matcher = new PatternMatcher(config);
+    this.wrappedProcessor = wrappedProcessor;
+    if (config.http?.ignore_incoming_paths) {
+      this.httpIgnorePatterns = config.http.ignore_incoming_paths.map(
+        (pattern) => new RegExp(pattern)
+      );
+    }
+  }
+  /**
+   * Called when a span is started
+   *
+   * We check if the span should be instrumented here. If not, we can mark it
+   * to be dropped later in onEnd().
+   */
+  onStart(span, parentContext) {
+    const spanName = span.name;
+    if (this.matcher.shouldInstrument(spanName)) {
+      this.wrappedProcessor.onStart(span, parentContext);
+    }
+  }
+  /**
+   * Called when a span is ended
+   *
+   * This is where we make the final decision on whether to export the span.
+   * We check both span name patterns and HTTP path patterns.
+   */
+  onEnd(span) {
+    const spanName = span.name;
+    if (!this.matcher.shouldInstrument(spanName)) {
+      return;
+    }
+    if (this.shouldIgnoreHttpSpan(span)) {
+      return;
+    }
+    this.wrappedProcessor.onEnd(span);
+  }
+  /**
+   * Check if span should be ignored based on HTTP path attributes
+   *
+   * This checks the span's url.path, http.route, or http.target attributes
+   * against the configured http.ignore_incoming_paths patterns.
+   *
+   * This enables filtering of Effect HTTP spans (and any other HTTP spans)
+   * based on path patterns, which is essential for filtering out OTLP
+   * endpoint requests like /v1/traces, /v1/logs, /v1/metrics.
+   */
+  shouldIgnoreHttpSpan(span) {
+    if (this.httpIgnorePatterns.length === 0) {
+      return false;
+    }
+    const urlPath = span.attributes["url.path"];
+    const httpRoute = span.attributes["http.route"];
+    const httpTarget = span.attributes["http.target"];
+    const pathToCheck = urlPath || httpRoute || httpTarget;
+    if (!pathToCheck) {
+      return false;
+    }
+    return this.httpIgnorePatterns.some((pattern) => pattern.test(pathToCheck));
+  }
+  /**
+   * Shutdown the processor
+   */
+  async shutdown() {
+    return this.wrappedProcessor.shutdown();
+  }
+  /**
+   * Force flush any pending spans
+   */
+  async forceFlush() {
+    return this.wrappedProcessor.forceFlush();
+  }
+  /**
+   * Get the pattern matcher (for debugging/testing)
+   */
+  getPatternMatcher() {
+    return this.matcher;
+  }
+};
+var DEFAULT_OTLP_ENDPOINT = "http://localhost:4318/v1/traces";
+function createOtlpExporter(options = {}) {
+  const endpoint = options.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTLP_ENDPOINT;
+  const normalizedEndpoint = normalizeEndpoint(endpoint);
+  const config = {
+    url: normalizedEndpoint
+  };
+  if (options.headers) {
+    config.headers = options.headers;
+  }
+  return new OTLPTraceExporter(config);
+}
+function normalizeEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    if (!url.pathname || url.pathname === "/") {
+      url.pathname = "/v1/traces";
+      return url.toString();
+    }
+    return endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function getOtlpEndpoint(options = {}) {
+  const endpoint = options.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTLP_ENDPOINT;
+  return normalizeEndpoint(endpoint);
+}
+
+// src/core/safe-exporter.ts
+var SafeSpanExporter = class {
+  // Log errors max once per minute
+  constructor(exporter) {
+    __publicField(this, "exporter");
+    __publicField(this, "errorCount", 0);
+    __publicField(this, "lastErrorTime", 0);
+    __publicField(this, "errorThrottleMs", 6e4);
+    this.exporter = exporter;
+  }
+  /**
+   * Export spans with error handling
+   */
+  export(spans, resultCallback) {
+    try {
+      this.exporter.export(spans, (result) => {
+        if (result.code !== 0) {
+          this.handleExportError(result.error);
+        }
+        resultCallback(result);
+      });
+    } catch (error) {
+      this.handleExportError(error);
+      resultCallback({
+        code: 2,
+        // FAILED
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  /**
+   * Shutdown with error handling
+   */
+  async shutdown() {
+    try {
+      await this.exporter.shutdown();
+    } catch (error) {
+      logger.error(
+        "@atrim/instrumentation: Error during exporter shutdown (non-critical):",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Force flush with error handling
+   */
+  async forceFlush() {
+    if (!this.exporter.forceFlush) {
+      return;
+    }
+    try {
+      await this.exporter.forceFlush();
+    } catch (error) {
+      this.handleExportError(error);
+    }
+  }
+  /**
+   * Handle export errors with throttling
+   */
+  handleExportError(error) {
+    this.errorCount++;
+    const now = Date.now();
+    const shouldLog = now - this.lastErrorTime > this.errorThrottleMs;
+    if (shouldLog) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.isConnectionError(error)) {
+        logger.warn(`@atrim/instrumentation: Unable to export spans - collector not available`);
+        logger.warn(`  Error: ${errorMessage}`);
+        logger.warn(`  Spans will be dropped. Ensure OTEL collector is running.`);
+      } else {
+        logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
+      }
+      if (this.errorCount > 1) {
+        logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
+      }
+      this.lastErrorTime = now;
+      this.errorCount = 0;
+    }
+  }
+  /**
+   * Check if error is a connection error (ECONNREFUSED, ENOTFOUND, etc.)
+   */
+  isConnectionError(error) {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+    const err = error;
+    if (err.code === "ECONNREFUSED" || err.code === "ENOTFOUND" || err.code === "ETIMEDOUT") {
+      return true;
+    }
+    if (Array.isArray(err.errors)) {
+      return err.errors.every((e) => this.isConnectionError(e));
+    }
+    if (err.message) {
+      const msg = err.message.toLowerCase();
+      return msg.includes("econnrefused") || msg.includes("enotfound") || msg.includes("etimedout") || msg.includes("connection refused");
+    }
+    return false;
+  }
+};
+var ConfigError2 = class extends Data.TaggedError("ConfigError") {
+};
+var ConfigUrlError2 = class extends Data.TaggedError("ConfigUrlError") {
+};
+var ConfigValidationError2 = class extends Data.TaggedError("ConfigValidationError") {
+};
+var ConfigFileError2 = class extends Data.TaggedError("ConfigFileError") {
+};
+var ServiceDetectionError2 = class extends Data.TaggedError("ServiceDetectionError") {
+};
+var InitializationError2 = class extends Data.TaggedError("InitializationError") {
+};
+var ExportError2 = class extends Data.TaggedError("ExportError") {
+};
+var ShutdownError2 = class extends Data.TaggedError("ShutdownError") {
+};
+
+// src/core/service-detector.ts
+var detectServiceInfo = Effect.gen(
+  function* () {
+    const envServiceName = process.env.OTEL_SERVICE_NAME;
+    const envServiceVersion = process.env.OTEL_SERVICE_VERSION;
+    if (envServiceName) {
+      return {
+        name: envServiceName,
+        version: envServiceVersion
+      };
+    }
+    const packageJsonPath = join(process.cwd(), "package.json");
+    const packageJsonContent = yield* Effect.tryPromise({
+      try: () => readFile(packageJsonPath, "utf-8"),
+      catch: (error) => new ServiceDetectionError2({
+        reason: `Failed to read package.json at ${packageJsonPath}`,
+        cause: error
+      })
+    });
+    let parsed;
+    try {
+      parsed = JSON.parse(packageJsonContent);
+    } catch (error) {
+      yield* Effect.fail(
+        new ServiceDetectionError2({
+          reason: "Invalid JSON in package.json",
+          cause: error
+        })
+      );
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const packageJson = parsed;
+      if (packageJson.name) {
+        return {
+          name: packageJson.name,
+          version: envServiceVersion || packageJson.version
+        };
+      }
+    }
+    return yield* Effect.fail(
+      new ServiceDetectionError2({
+        reason: 'package.json exists but has no "name" field'
+      })
+    );
+  }
+);
+var getServiceName = detectServiceInfo.pipe(
+  Effect.map((info) => info.name),
+  Effect.catchAll(() => Effect.succeed("unknown-service"))
+);
+var getServiceVersion = detectServiceInfo.pipe(
+  Effect.map((info) => info.version),
+  Effect.catchAll(() => Effect.succeed(void 0))
+);
+var getServiceInfoWithFallback = detectServiceInfo.pipe(
+  Effect.catchAll(
+    () => Effect.succeed({
+      name: "unknown-service",
+      version: process.env.OTEL_SERVICE_VERSION
+    })
+  )
+);
+async function detectServiceInfoAsync() {
+  return Effect.runPromise(getServiceInfoWithFallback);
+}
+async function getServiceNameAsync() {
+  return Effect.runPromise(getServiceName);
+}
+async function getServiceVersionAsync() {
+  return Effect.runPromise(getServiceVersion);
+}
+async function loadFromFile(filePath) {
+  const { readFile: readFile2 } = await import('fs/promises');
+  const content = await readFile2(filePath, "utf-8");
+  return parseAndValidateConfig(content);
+}
+async function loadFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch config from ${url}: ${response.statusText}`);
+  }
+  const content = await response.text();
+  return parseAndValidateConfig(content);
+}
+async function loadConfig(uri, _options) {
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return loadFromUrl(uri);
+  }
+  if (uri.startsWith("file://")) {
+    const filePath = uri.slice(7);
+    return loadFromFile(filePath);
+  }
+  return loadFromFile(uri);
+}
+async function loadConfigFromInline(content) {
+  return parseAndValidateConfig(content);
+}
+function _resetConfigLoaderCache() {
+}
+async function loadConfigWithOptions(options = {}) {
+  if (options.config) {
+    return loadConfigFromInline(options.config);
+  }
+  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
+  if (envConfigPath) {
+    return loadConfig(envConfigPath);
+  }
+  if (options.configUrl) {
+    return loadConfig(options.configUrl);
+  }
+  if (options.configPath) {
+    return loadConfig(options.configPath);
+  }
+  const { existsSync } = await import('fs');
+  const { join: join2 } = await import('path');
+  const defaultPath = join2(process.cwd(), "instrumentation.yaml");
+  if (existsSync(defaultPath)) {
+    return loadConfig(defaultPath);
+  }
+  return defaultConfig;
+}
+
+// src/core/sdk-initializer.ts
+var sdkInstance = null;
+var initializationPromise = null;
+function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
+  const httpConfig = { enabled: true };
+  const programmaticPatterns = options.http?.ignoreOutgoingUrls || [];
+  const yamlPatterns = config.http?.ignore_outgoing_urls || [];
+  const allOutgoingPatterns = [
+    ...programmaticPatterns.map((p) => typeof p === "string" ? new RegExp(p) : p),
+    ...yamlPatterns.map((p) => new RegExp(p))
+  ];
+  logger.log(`HTTP filtering: ${allOutgoingPatterns.length} outgoing patterns configured`);
+  if (options.http?.ignoreOutgoingRequestHook) {
+    httpConfig.ignoreOutgoingRequestHook = options.http.ignoreOutgoingRequestHook;
+  } else if (allOutgoingPatterns.length > 0) {
+    httpConfig.ignoreOutgoingRequestHook = (req) => {
+      const hostname = req.hostname || req.host || "";
+      const port = req.port || "";
+      const protocol = req.protocol || "http:";
+      const path = req.path || "";
+      const portStr = port ? `:${port}` : "";
+      const url = `${protocol}//${hostname}${portStr}${path}`;
+      const matchesPattern = allOutgoingPatterns.some(
+        (pattern) => pattern.test(url) || pattern.test(path)
+      );
+      return matchesPattern;
+    };
+  }
+  const programmaticIncomingPatterns = options.http?.ignoreIncomingPaths || [];
+  const yamlIncomingPatterns = config.http?.ignore_incoming_paths || [];
+  const allIncomingPatterns = [
+    ...programmaticIncomingPatterns.map((p) => typeof p === "string" ? new RegExp(p) : p),
+    ...yamlIncomingPatterns.map((p) => new RegExp(p))
+  ];
+  if (options.http?.ignoreIncomingRequestHook) {
+    httpConfig.ignoreIncomingRequestHook = options.http.ignoreIncomingRequestHook;
+  } else if (allIncomingPatterns.length > 0) {
+    httpConfig.ignoreIncomingRequestHook = (req) => {
+      const path = req.url || "";
+      return allIncomingPatterns.some((pattern) => pattern.test(path));
+    };
+  }
+  if (options.http?.requireParentForOutgoingSpans !== void 0 || config.http?.require_parent_for_outgoing_spans !== void 0) {
+    httpConfig.requireParentforOutgoingSpans = options.http?.requireParentForOutgoingSpans ?? config.http?.require_parent_for_outgoing_spans ?? false;
+  }
+  return httpConfig;
+}
+function buildUndiciInstrumentationConfig(options, config, _otlpEndpoint) {
+  const undiciConfig = { enabled: true };
+  const programmaticPatterns = options.http?.ignoreOutgoingUrls || [];
+  const yamlPatterns = config.http?.ignore_outgoing_urls || [];
+  const allPatterns = [
+    ...programmaticPatterns.map((p) => typeof p === "string" ? new RegExp(p) : p),
+    ...yamlPatterns.map((p) => new RegExp(p))
+  ];
+  if (allPatterns.length > 0) {
+    undiciConfig.ignoreRequestHook = (request) => {
+      const origin = request.origin;
+      const path = request.path;
+      const url = `${origin}${path}`;
+      const matchesPattern = allPatterns.some((pattern) => pattern.test(url) || pattern.test(path));
+      return matchesPattern;
+    };
+  }
+  return undiciConfig;
+}
+function isEffectProject() {
+  try {
+    __require.resolve("effect");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shouldEnableAutoInstrumentation(explicitValue, hasWebFramework) {
+  if (explicitValue !== void 0) {
+    return explicitValue;
+  }
+  const isEffect = isEffectProject();
+  if (isEffect && !hasWebFramework) {
+    logger.log("@atrim/instrumentation: Detected Effect-TS without web framework");
+    logger.log("  - Auto-instrumentation disabled by default");
+    logger.log("  - Effect.withSpan() will create spans");
+    return false;
+  }
+  return true;
+}
+function hasWebFrameworkInstalled() {
+  const frameworks = ["express", "fastify", "koa", "@hono/node-server", "restify"];
+  for (const framework of frameworks) {
+    try {
+      __require.resolve(framework);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function isTracingAlreadyInitialized() {
+  try {
+    const provider = trace.getTracerProvider();
+    const providerWithDelegate = provider;
+    const delegate = providerWithDelegate._delegate || providerWithDelegate.getDelegate?.();
+    if (delegate) {
+      const delegateName = delegate.constructor.name;
+      if (!delegateName.includes("Noop")) {
+        return true;
+      }
+    }
+    const providerWithProps = provider;
+    const hasResource = providerWithProps.resource !== void 0;
+    const hasActiveSpanProcessor = providerWithProps.activeSpanProcessor !== void 0;
+    const hasTracers = providerWithProps._tracers !== void 0;
+    return hasResource || hasActiveSpanProcessor || hasTracers;
+  } catch {
+    return false;
+  }
+}
+async function initializeSdk(options = {}) {
+  if (sdkInstance) {
+    logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
+    return sdkInstance;
+  }
+  if (initializationPromise) {
+    logger.log(
+      "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
+    );
+    return initializationPromise;
+  }
+  initializationPromise = performInitialization(options);
+  try {
+    const result = await initializationPromise;
+    return result;
+  } finally {
+    initializationPromise = null;
+  }
+}
+async function performInitialization(options) {
+  const config = await loadConfigWithOptions(options);
+  const loggingLevel = config.instrumentation.logging || "on";
+  logger.setLevel(loggingLevel);
+  const alreadyInitialized = isTracingAlreadyInitialized();
+  if (alreadyInitialized) {
+    logger.log("@atrim/instrumentation: Detected existing OpenTelemetry initialization.");
+    logger.log("  - Skipping NodeSDK setup");
+    logger.log("  - Setting up pattern-based filtering only");
+    logger.log("");
+    initializePatternMatcher(config);
+    logger.log("@atrim/instrumentation: Pattern filtering initialized");
+    logger.log("  \u26A0\uFE0F  Note: Pattern filtering will only work with manual spans");
+    logger.log("  \u26A0\uFE0F  Auto-instrumentation must be configured separately");
+    logger.log("");
+    return null;
+  }
+  const serviceInfo = await detectServiceInfoAsync();
+  const serviceName = options.serviceName || serviceInfo.name;
+  const serviceVersion = options.serviceVersion || serviceInfo.version;
+  const rawExporter = createOtlpExporter(options.otlp);
+  const exporter = new SafeSpanExporter(rawExporter);
+  const useSimpleProcessor = process.env.NODE_ENV === "test" || process.env.OTEL_USE_SIMPLE_PROCESSOR === "true";
+  const baseProcessor = useSimpleProcessor ? new SimpleSpanProcessor(exporter) : new BatchSpanProcessor(exporter);
+  const patternProcessor = new PatternSpanProcessor(config, baseProcessor);
+  const instrumentations = [];
+  const hasWebFramework = hasWebFrameworkInstalled();
+  const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
+    options.autoInstrument,
+    hasWebFramework
+  );
+  if (enableAutoInstrumentation) {
+    options.otlp?.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318/v1/traces";
+    const httpConfig = buildHttpInstrumentationConfig(options, config);
+    const undiciConfig = buildUndiciInstrumentationConfig(options, config);
+    instrumentations.push(
+      ...getNodeAutoInstrumentations({
+        // Enable HTTP instrumentation with filtering (for http/https modules)
+        "@opentelemetry/instrumentation-http": httpConfig,
+        // Enable undici instrumentation with filtering (for fetch API)
+        "@opentelemetry/instrumentation-undici": undiciConfig,
+        // Enable web framework instrumentations
+        "@opentelemetry/instrumentation-express": { enabled: true },
+        "@opentelemetry/instrumentation-fastify": { enabled: true },
+        "@opentelemetry/instrumentation-koa": { enabled: true },
+        // Disable noisy instrumentations by default
+        "@opentelemetry/instrumentation-fs": { enabled: false },
+        "@opentelemetry/instrumentation-dns": { enabled: false }
+      })
+    );
+    logger.log(`Auto-instrumentation: ${instrumentations.length} instrumentations enabled`);
+  }
+  if (options.instrumentations) {
+    instrumentations.push(...options.instrumentations);
+  }
+  if (!enableAutoInstrumentation && instrumentations.length === 0) {
+    const wasExplicit = options.autoInstrument === false;
+    const detectionMessage = wasExplicit ? "@atrim/instrumentation: Auto-instrumentation: disabled" : "@atrim/instrumentation: Pure Effect-TS app detected (auto-detected)";
+    logger.log(detectionMessage);
+    logger.log("  - Skipping NodeSDK setup");
+    logger.log("  - Pattern matching configured from instrumentation.yaml");
+    if (!wasExplicit) {
+      logger.log("  - Use EffectInstrumentationLive for tracing");
+    }
+    logger.log("");
+    initializePatternMatcher(config);
+    return null;
+  }
+  const sdkConfig = {
+    spanProcessor: patternProcessor,
+    serviceName,
+    ...serviceVersion && { serviceVersion },
+    instrumentations,
+    // Allow advanced overrides
+    ...options.sdk
+  };
+  const sdk = new NodeSDK(sdkConfig);
+  sdk.start();
+  sdkInstance = sdk;
+  if (!options.disableAutoShutdown) {
+    registerShutdownHandlers(sdk);
+  }
+  logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
+  return sdk;
+}
+function getSdkInstance() {
+  return sdkInstance;
+}
+async function shutdownSdk() {
+  if (!sdkInstance) {
+    return;
+  }
+  await sdkInstance.shutdown();
+  sdkInstance = null;
+}
+function resetSdk() {
+  sdkInstance = null;
+  initializationPromise = null;
+}
+function registerShutdownHandlers(sdk) {
+  const shutdown = async (signal) => {
+    logger.log(`
+@atrim/instrumentation: Received ${signal}, shutting down gracefully...`);
+    try {
+      await sdk.shutdown();
+      logger.log("@atrim/instrumentation: Shutdown complete");
+      process.exit(0);
+    } catch (error) {
+      logger.error(
+        "@atrim/instrumentation: Error during shutdown:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("uncaughtException", async (error) => {
+    logger.error("@atrim/instrumentation: Uncaught exception:", error);
+    await sdk.shutdown();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", async (reason) => {
+    logger.error("@atrim/instrumentation: Unhandled rejection:", reason);
+    await sdk.shutdown();
+    process.exit(1);
+  });
+}
+function logInitialization(config, serviceName, serviceVersion, options, autoInstrumentEnabled) {
+  logger.minimal("@atrim/instrumentation: SDK initialized successfully");
+  logger.log(`  - Service: ${serviceName}${serviceVersion ? ` v${serviceVersion}` : ""}`);
+  if (config.instrumentation.enabled) {
+    const instrumentCount = config.instrumentation.instrument_patterns.filter(
+      (p) => p.enabled !== false
+    ).length;
+    const ignoreCount = config.instrumentation.ignore_patterns.length;
+    logger.log(`  - Pattern filtering: enabled`);
+    logger.log(`    - Instrument patterns: ${instrumentCount}`);
+    logger.log(`    - Ignore patterns: ${ignoreCount}`);
+  } else {
+    logger.log(`  - Pattern filtering: disabled`);
+  }
+  const autoInstrumentLabel = autoInstrumentEnabled ? "enabled" : "disabled";
+  const autoDetected = options.autoInstrument === void 0 ? " (auto-detected)" : "";
+  logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
+  if (options.instrumentations && options.instrumentations.length > 0) {
+    logger.log(`  - Custom instrumentations: ${options.instrumentations.length}`);
+  }
+  const endpoint = options.otlp?.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318/v1/traces";
+  logger.log(`  - OTLP endpoint: ${endpoint}`);
+  logger.log("");
+}
+var require2 = createRequire(import.meta.url);
+function validateOpenTelemetryApi() {
+  try {
+    require2.resolve("@opentelemetry/api");
+  } catch {
+    throw new Error(
+      "@atrim/instrument-node requires @opentelemetry/api as a peer dependency.\n\nInstall it with:\n  npm install @opentelemetry/api\n\nOr with your preferred package manager:\n  pnpm add @opentelemetry/api\n  yarn add @opentelemetry/api\n  bun add @opentelemetry/api"
+    );
+  }
+}
+function validateEffectDependencies() {
+  const packages = ["effect", "@effect/opentelemetry", "@effect/platform"];
+  for (const pkg of packages) {
+    try {
+      require2.resolve(pkg);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+var validateDependencies = Effect.try({
+  try: () => validateOpenTelemetryApi(),
+  catch: (error) => new InitializationError2({
+    reason: error instanceof Error ? error.message : "Dependency validation failed",
+    cause: error
+  })
+});
+Effect.sync(() => validateEffectDependencies());
+
+// src/api.ts
+async function initializeInstrumentation(options = {}) {
+  validateOpenTelemetryApi();
+  const sdk = await initializeSdk(options);
+  if (sdk) {
+    const config = await loadConfigWithOptions(options);
+    initializePatternMatcher(config);
+  }
+  return sdk;
+}
+async function initializePatternMatchingOnly(options = {}) {
+  const config = await loadConfigWithOptions(options);
+  initializePatternMatcher(config);
+  logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+  logger.log(
+    "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
+  );
+}
+var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* () {
+  yield* validateDependencies;
+  const sdk = yield* Effect.tryPromise({
+    try: () => initializeSdk(options),
+    catch: (error) => new InitializationError2({
+      reason: "SDK initialization failed",
+      cause: error
+    })
+  });
+  if (sdk) {
+    yield* Effect.tryPromise({
+      try: () => loadConfigWithOptions(options),
+      catch: (error) => new ConfigError2({
+        reason: "Failed to load config for pattern matcher",
+        cause: error
+      })
+    }).pipe(
+      Effect.tap(
+        (config) => Effect.sync(() => {
+          initializePatternMatcher(config);
+        })
+      )
+    );
+  }
+  return sdk;
+});
+var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
+  const config = yield* Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => new ConfigError2({
+      reason: "Failed to load configuration",
+      cause: error
+    })
+  });
+  yield* Effect.sync(() => {
+    initializePatternMatcher(config);
+    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    logger.log(
+      "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
+    );
+  });
+});
+
+// src/integrations/standard/span-helpers.ts
+function setSpanAttributes(span, attributes) {
+  for (const [key, value] of Object.entries(attributes)) {
+    span.setAttribute(key, value);
+  }
+}
+function recordException(span, error, context) {
+  span.recordException(error);
+  if (context) {
+    for (const [key, value] of Object.entries(context)) {
+      span.setAttribute(`error.${key}`, value);
+    }
+  }
+}
+function markSpanSuccess(span) {
+  span.setStatus({ code: 1 });
+}
+function markSpanError(span, message) {
+  if (message !== void 0) {
+    span.setStatus({
+      code: 2,
+      // SpanStatusCode.ERROR = 2
+      message
+    });
+  } else {
+    span.setStatus({
+      code: 2
+      // SpanStatusCode.ERROR = 2
+    });
+  }
+}
+function annotateHttpRequest(span, method, url, statusCode) {
+  span.setAttribute("http.method", method);
+  span.setAttribute("http.url", url);
+  if (statusCode !== void 0) {
+    span.setAttribute("http.status_code", statusCode);
+    if (statusCode >= 400) {
+      markSpanError(span, `HTTP ${statusCode}`);
+    } else {
+      markSpanSuccess(span);
+    }
+  }
+}
+function annotateDbQuery(span, system, statement, table) {
+  span.setAttribute("db.system", system);
+  span.setAttribute("db.statement", statement);
+  if (table) {
+    span.setAttribute("db.table", table);
+  }
+}
+function annotateCacheOperation(span, operation, key, hit) {
+  span.setAttribute("cache.operation", operation);
+  span.setAttribute("cache.key", key);
+  if (hit !== void 0) {
+    span.setAttribute("cache.hit", hit);
+  }
+}
+
+// src/core/test-utils.ts
+function suppressShutdownErrors() {
+  if (!process.env.CI && process.env.NODE_ENV !== "test") {
+    return;
+  }
+  const isHarmlessConnectionError = (error) => {
+    if (!error || typeof error !== "object") {
+      return false;
+    }
+    const nodeError = error;
+    if (nodeError.code === "ECONNREFUSED") {
+      return true;
+    }
+    if (nodeError.errors && Array.isArray(nodeError.errors) && nodeError.errors.length > 0 && nodeError.errors.every((e) => e?.code === "ECONNREFUSED")) {
+      return true;
+    }
+    return false;
+  };
+  process.on("uncaughtException", (error) => {
+    if (isHarmlessConnectionError(error)) {
+      console.log("\u{1F4E4} Export failed (collector stopped) - this is expected in tests");
+      return;
+    }
+    console.error("Uncaught exception:", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isHarmlessConnectionError(reason)) {
+      console.log("\u{1F4E4} Export failed (collector stopped) - this is expected in tests");
+      return;
+    }
+    console.error("Unhandled rejection:", reason);
+    process.exit(1);
+  });
+}
+
+export { ConfigError2 as ConfigError, ConfigFileError2 as ConfigFileError, ConfigUrlError2 as ConfigUrlError, ConfigValidationError2 as ConfigValidationError, ExportError2 as ExportError, InitializationError2 as InitializationError, PatternMatcher, PatternSpanProcessor, ServiceDetectionError2 as ServiceDetectionError, ShutdownError2 as ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getPatternMatcher, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map