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

package/target/dist/index.cjs

@@ -1,1212 +0,0 @@
-'use strict';
-
-var effect = require('effect');
-var sdkNode = require('@opentelemetry/sdk-node');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
-var api = require('@opentelemetry/api');
-var fs = require('fs');
-var path = require('path');
-var yaml = require('yaml');
-var zod = require('zod');
-var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
-var promises = require('fs/promises');
-
-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 = zod.z.object({
-  pattern: zod.z.string(),
-  enabled: zod.z.boolean().optional(),
-  description: zod.z.string().optional()
-});
-var AutoIsolationConfigSchema = zod.z.object({
-  // Global enable/disable for auto-isolation
-  enabled: zod.z.boolean().default(false),
-  // Which operators to auto-isolate
-  operators: zod.z.object({
-    fiberset_run: zod.z.boolean().default(true),
-    effect_fork: zod.z.boolean().default(true),
-    effect_fork_daemon: zod.z.boolean().default(true),
-    effect_fork_in: zod.z.boolean().default(false)
-  }).default({}),
-  // Virtual parent tracking configuration
-  tracking: zod.z.object({
-    use_span_links: zod.z.boolean().default(true),
-    use_attributes: zod.z.boolean().default(true),
-    capture_logical_parent: zod.z.boolean().default(true)
-  }).default({}),
-  // Span categorization
-  attributes: zod.z.object({
-    category: zod.z.string().default("background_task"),
-    add_metadata: zod.z.boolean().default(true)
-  }).default({})
-});
-var HttpFilteringConfigSchema = zod.z.object({
-  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
-  ignore_outgoing_urls: zod.z.array(zod.z.string()).optional(),
-  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
-  ignore_incoming_paths: zod.z.array(zod.z.string()).optional(),
-  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: zod.z.boolean().optional()
-});
-var InstrumentationConfigSchema = zod.z.object({
-  version: zod.z.string(),
-  instrumentation: zod.z.object({
-    enabled: zod.z.boolean(),
-    description: zod.z.string().optional(),
-    logging: zod.z.enum(["on", "off", "minimal"]).optional().default("on"),
-    instrument_patterns: zod.z.array(PatternConfigSchema),
-    ignore_patterns: zod.z.array(PatternConfigSchema)
-  }),
-  effect: zod.z.object({
-    auto_extract_metadata: zod.z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional()
-  }).optional(),
-  http: HttpFilteringConfigSchema.optional()
-});
-(class extends effect.Data.TaggedError("ConfigError") {
-});
-var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
-};
-var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
-};
-var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
-};
-(class extends effect.Data.TaggedError("ServiceDetectionError") {
-});
-(class extends effect.Data.TaggedError("InitializationError") {
-});
-(class extends effect.Data.TaggedError("ExportError") {
-});
-(class extends effect.Data.TaggedError("ShutdownError") {
-});
-var SECURITY_DEFAULTS = {
-  maxConfigSize: 1e6,
-  // 1MB
-  requestTimeout: 5e3,
-  allowedProtocols: ["https:"],
-  // Only HTTPS for remote configs
-  cacheTimeout: 3e5
-  // 5 minutes
-};
-function getDefaultConfig() {
-  return {
-    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: {
-      auto_extract_metadata: true
-    }
-  };
-}
-var validateConfigEffect = (rawConfig) => effect.Effect.try({
-  try: () => InstrumentationConfigSchema.parse(rawConfig),
-  catch: (error) => new ConfigValidationError({
-    reason: "Invalid configuration schema",
-    cause: error
-  })
-});
-var loadConfigFromFileEffect = (filePath) => effect.Effect.gen(function* () {
-  const fileContents = yield* effect.Effect.try({
-    try: () => fs.readFileSync(filePath, "utf8"),
-    catch: (error) => new ConfigFileError({
-      reason: `Failed to read config file at ${filePath}`,
-      cause: error
-    })
-  });
-  if (fileContents.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.Effect.fail(
-      new ConfigFileError({
-        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = yaml.parse(fileContents);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var fetchAndParseConfig = (url) => effect.Effect.gen(function* () {
-  let urlObj;
-  try {
-    urlObj = new URL(url);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Invalid URL: ${url}`,
-        cause: error
-      })
-    );
-  }
-  if (!SECURITY_DEFAULTS.allowedProtocols.includes(urlObj.protocol)) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Insecure protocol ${urlObj.protocol}. Only ${SECURITY_DEFAULTS.allowedProtocols.join(", ")} are allowed`
-      })
-    );
-  }
-  const response = yield* effect.Effect.tryPromise({
-    try: () => fetch(url, {
-      redirect: "follow",
-      headers: {
-        Accept: "application/yaml, text/yaml, text/x-yaml"
-      }
-    }),
-    catch: (error) => new ConfigUrlError({
-      reason: `Failed to load config from URL ${url}`,
-      cause: error
-    })
-  }).pipe(
-    effect.Effect.timeout(effect.Duration.millis(SECURITY_DEFAULTS.requestTimeout)),
-    effect.Effect.retry({
-      times: 3,
-      schedule: effect.Schedule.exponential(effect.Duration.millis(100))
-    }),
-    effect.Effect.catchAll((error) => {
-      if (error._tag === "TimeoutException") {
-        return effect.Effect.fail(
-          new ConfigUrlError({
-            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms`
-          })
-        );
-      }
-      return effect.Effect.fail(error);
-    })
-  );
-  if (!response.ok) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `HTTP ${response.status}: ${response.statusText}`
-      })
-    );
-  }
-  const contentLength = response.headers.get("content-length");
-  if (contentLength && parseInt(contentLength) > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  const text = yield* effect.Effect.tryPromise({
-    try: () => response.text(),
-    catch: (error) => new ConfigUrlError({
-      reason: "Failed to read response body",
-      cause: error
-    })
-  });
-  if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = yaml.parse(text);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var makeConfigCache = () => effect.Cache.make({
-  capacity: 100,
-  timeToLive: effect.Duration.minutes(5),
-  lookup: (url) => fetchAndParseConfig(url)
-});
-var cacheInstance = null;
-var getCache = effect.Effect.gen(function* () {
-  if (!cacheInstance) {
-    cacheInstance = yield* makeConfigCache();
-  }
-  return cacheInstance;
-});
-var loadConfigFromUrlEffect = (url, cacheTimeout = SECURITY_DEFAULTS.cacheTimeout) => effect.Effect.gen(function* () {
-  if (cacheTimeout === 0) {
-    return yield* fetchAndParseConfig(url);
-  }
-  const cache = yield* getCache;
-  return yield* cache.get(url);
-});
-var loadConfigEffect = (options = {}) => effect.Effect.gen(function* () {
-  if (options.config) {
-    return yield* validateConfigEffect(options.config);
-  }
-  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
-  if (envConfigPath) {
-    if (envConfigPath.startsWith("http://") || envConfigPath.startsWith("https://")) {
-      return yield* loadConfigFromUrlEffect(envConfigPath, options.cacheTimeout);
-    }
-    return yield* loadConfigFromFileEffect(envConfigPath);
-  }
-  if (options.configUrl) {
-    return yield* loadConfigFromUrlEffect(options.configUrl, options.cacheTimeout);
-  }
-  if (options.configPath) {
-    return yield* loadConfigFromFileEffect(options.configPath);
-  }
-  const defaultPath = path.join(process.cwd(), "instrumentation.yaml");
-  const exists = yield* effect.Effect.sync(() => fs.existsSync(defaultPath));
-  if (exists) {
-    return yield* loadConfigFromFileEffect(defaultPath);
-  }
-  return getDefaultConfig();
-});
-async function loadConfig(options = {}) {
-  return effect.Effect.runPromise(
-    loadConfigEffect(options).pipe(
-      // Convert typed errors to regular Error with reason message for backward compatibility
-      effect.Effect.mapError((error) => {
-        const message = error.reason;
-        const newError = new Error(message);
-        newError.cause = error.cause;
-        return newError;
-      })
-    )
-  );
-}
-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");
-    this.matcher = new PatternMatcher(config);
-    this.wrappedProcessor = wrappedProcessor;
-  }
-  /**
-   * 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.
-   */
-  onEnd(span) {
-    const spanName = span.name;
-    if (this.matcher.shouldInstrument(spanName)) {
-      this.wrappedProcessor.onEnd(span);
-    }
-  }
-  /**
-   * 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 exporterTraceOtlpHttp.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 effect.Data.TaggedError("ConfigError") {
-};
-var ConfigUrlError2 = class extends effect.Data.TaggedError("ConfigUrlError") {
-};
-var ConfigValidationError2 = class extends effect.Data.TaggedError("ConfigValidationError") {
-};
-var ConfigFileError2 = class extends effect.Data.TaggedError("ConfigFileError") {
-};
-var ServiceDetectionError2 = class extends effect.Data.TaggedError("ServiceDetectionError") {
-};
-var InitializationError2 = class extends effect.Data.TaggedError("InitializationError") {
-};
-var ExportError2 = class extends effect.Data.TaggedError("ExportError") {
-};
-var ShutdownError2 = class extends effect.Data.TaggedError("ShutdownError") {
-};
-
-// src/core/service-detector.ts
-var detectServiceInfo = effect.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 = path.join(process.cwd(), "package.json");
-    const packageJsonContent = yield* effect.Effect.tryPromise({
-      try: () => promises.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.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.Effect.fail(
-      new ServiceDetectionError2({
-        reason: 'package.json exists but has no "name" field'
-      })
-    );
-  }
-);
-var getServiceName = detectServiceInfo.pipe(
-  effect.Effect.map((info) => info.name),
-  effect.Effect.catchAll(() => effect.Effect.succeed("unknown-service"))
-);
-var getServiceVersion = detectServiceInfo.pipe(
-  effect.Effect.map((info) => info.version),
-  effect.Effect.catchAll(() => effect.Effect.succeed(void 0))
-);
-var getServiceInfoWithFallback = detectServiceInfo.pipe(
-  effect.Effect.catchAll(
-    () => effect.Effect.succeed({
-      name: "unknown-service",
-      version: process.env.OTEL_SERVICE_VERSION
-    })
-  )
-);
-async function detectServiceInfoAsync() {
-  return effect.Effect.runPromise(getServiceInfoWithFallback);
-}
-async function getServiceNameAsync() {
-  return effect.Effect.runPromise(getServiceName);
-}
-async function getServiceVersionAsync() {
-  return effect.Effect.runPromise(getServiceVersion);
-}
-
-// 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 = api.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 loadConfig(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 sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.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(
-      ...autoInstrumentationsNode.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 sdkNode.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("");
-}
-
-// src/api.ts
-async function initializeInstrumentation(options = {}) {
-  const sdk = await initializeSdk(options);
-  if (sdk) {
-    const config = await loadConfig(options);
-    initializePatternMatcher(config);
-  }
-  return sdk;
-}
-async function initializePatternMatchingOnly(options = {}) {
-  const config = await loadConfig(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.Effect.gen(function* () {
-  const sdk = yield* effect.Effect.tryPromise({
-    try: () => initializeSdk(options),
-    catch: (error) => new InitializationError2({
-      reason: "SDK initialization failed",
-      cause: error
-    })
-  });
-  if (sdk) {
-    yield* effect.Effect.tryPromise({
-      try: () => loadConfig(options),
-      catch: (error) => new ConfigError2({
-        reason: "Failed to load config for pattern matcher",
-        cause: error
-      })
-    }).pipe(
-      effect.Effect.tap(
-        (config) => effect.Effect.sync(() => {
-          initializePatternMatcher(config);
-        })
-      )
-    );
-  }
-  return sdk;
-});
-var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
-  const config = yield* effect.Effect.tryPromise({
-    try: () => loadConfig(options),
-    catch: (error) => new ConfigError2({
-      reason: "Failed to load configuration",
-      cause: error
-    })
-  });
-  yield* effect.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);
-  });
-}
-
-exports.ConfigError = ConfigError2;
-exports.ConfigFileError = ConfigFileError2;
-exports.ConfigUrlError = ConfigUrlError2;
-exports.ConfigValidationError = ConfigValidationError2;
-exports.ExportError = ExportError2;
-exports.InitializationError = InitializationError2;
-exports.PatternMatcher = PatternMatcher;
-exports.PatternSpanProcessor = PatternSpanProcessor;
-exports.ServiceDetectionError = ServiceDetectionError2;
-exports.ShutdownError = ShutdownError2;
-exports.annotateCacheOperation = annotateCacheOperation;
-exports.annotateDbQuery = annotateDbQuery;
-exports.annotateHttpRequest = annotateHttpRequest;
-exports.createOtlpExporter = createOtlpExporter;
-exports.detectServiceInfo = detectServiceInfoAsync;
-exports.detectServiceInfoEffect = detectServiceInfo;
-exports.getOtlpEndpoint = getOtlpEndpoint;
-exports.getPatternMatcher = getPatternMatcher;
-exports.getSdkInstance = getSdkInstance;
-exports.getServiceInfoWithFallback = getServiceInfoWithFallback;
-exports.getServiceName = getServiceNameAsync;
-exports.getServiceNameEffect = getServiceName;
-exports.getServiceVersion = getServiceVersionAsync;
-exports.getServiceVersionEffect = getServiceVersion;
-exports.initializeInstrumentation = initializeInstrumentation;
-exports.initializeInstrumentationEffect = initializeInstrumentationEffect;
-exports.initializePatternMatchingOnly = initializePatternMatchingOnly;
-exports.initializePatternMatchingOnlyEffect = initializePatternMatchingOnlyEffect;
-exports.loadConfig = loadConfig;
-exports.markSpanError = markSpanError;
-exports.markSpanSuccess = markSpanSuccess;
-exports.recordException = recordException;
-exports.resetSdk = resetSdk;
-exports.setSpanAttributes = setSpanAttributes;
-exports.shouldInstrumentSpan = shouldInstrumentSpan;
-exports.shutdownSdk = shutdownSdk;
-exports.suppressShutdownErrors = suppressShutdownErrors;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map