@atrim/instrument-node 0.4.0-c3ef89c-20251118193817 → 0.4.1

package/target/dist/index.cjs

@@ -5,13 +5,38 @@ 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 instrumentCore = require('@atrim/instrument-core');
+var FileSystem = require('@effect/platform/FileSystem');
+var HttpClient = require('@effect/platform/HttpClient');
+var HttpClientRequest = require('@effect/platform/HttpClientRequest');
+var yaml = require('yaml');
+var zod = require('zod');
 var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
 var promises = require('fs/promises');
 var path = require('path');
 var platformNode = require('@effect/platform-node');
 var platform = require('@effect/platform');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
+var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
+
 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, {
@@ -21,11 +46,401 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   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") {
+  get message() {
+    return this.reason;
+  }
+});
+var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
+};
+(class extends effect.Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ShutdownError") {
+  get message() {
+    return this.reason;
+  }
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3
+  // 5 seconds
+};
+var ConfigLoader = class extends effect.Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => effect.Effect.gen(function* () {
+  const parsed = yield* effect.Effect.try({
+    try: () => yaml.parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* effect.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.Effect.gen(function* () {
+  const content = yield* fs.readFileString(path).pipe(
+    effect.Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* effect.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.Effect.scoped(
+  effect.Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest__namespace.get(url).pipe(
+      HttpClientRequest__namespace.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
+      })
+    );
+    const response = yield* client.execute(request).pipe(
+      effect.Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      effect.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.Effect.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      effect.Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          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`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = effect.Effect.gen(function* () {
+  const fs = yield* effect.Effect.serviceOption(FileSystem.FileSystem);
+  const http = yield* HttpClient__namespace.HttpClient;
+  const loadFromUriUncached = (uri) => effect.Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* effect.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.Effect.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => effect.Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* effect.Effect.try({
+        try: () => InstrumentationConfigSchema.parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: "Invalid configuration schema",
+          cause: error
+        })
+      });
+    })
+  });
+});
+var ConfigLoaderLive = effect.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");
-    this.matcher = new instrumentCore.PatternMatcher(config);
+    this.matcher = new PatternMatcher(config);
     this.wrappedProcessor = wrappedProcessor;
   }
   /**
@@ -98,6 +513,8 @@ 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) {
@@ -134,7 +551,7 @@ var SafeSpanExporter = class {
     try {
       await this.exporter.shutdown();
     } catch (error) {
-      instrumentCore.logger.error(
+      logger.error(
         "@atrim/instrumentation: Error during exporter shutdown (non-critical):",
         error instanceof Error ? error.message : String(error)
       );
@@ -163,14 +580,14 @@ var SafeSpanExporter = class {
     if (shouldLog) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (this.isConnectionError(error)) {
-        instrumentCore.logger.warn(`@atrim/instrumentation: Unable to export spans - collector not available`);
-        instrumentCore.logger.warn(`  Error: ${errorMessage}`);
-        instrumentCore.logger.warn(`  Spans will be dropped. Ensure OTEL collector is running.`);
+        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 {
-        instrumentCore.logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
+        logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
       }
       if (this.errorCount > 1) {
-        instrumentCore.logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
+        logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
       }
       this.lastErrorTime = now;
       this.errorCount = 0;
@@ -197,21 +614,21 @@ var SafeSpanExporter = class {
     return false;
   }
 };
-var ConfigError = class extends effect.Data.TaggedError("ConfigError") {
+var ConfigError2 = class extends effect.Data.TaggedError("ConfigError") {
 };
-var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+var ConfigUrlError2 = class extends effect.Data.TaggedError("ConfigUrlError") {
 };
-var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+var ConfigValidationError2 = class extends effect.Data.TaggedError("ConfigValidationError") {
 };
-var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+var ConfigFileError2 = class extends effect.Data.TaggedError("ConfigFileError") {
 };
-var ServiceDetectionError = class extends effect.Data.TaggedError("ServiceDetectionError") {
+var ServiceDetectionError2 = class extends effect.Data.TaggedError("ServiceDetectionError") {
 };
-var InitializationError = class extends effect.Data.TaggedError("InitializationError") {
+var InitializationError2 = class extends effect.Data.TaggedError("InitializationError") {
 };
-var ExportError = class extends effect.Data.TaggedError("ExportError") {
+var ExportError2 = class extends effect.Data.TaggedError("ExportError") {
 };
-var ShutdownError = class extends effect.Data.TaggedError("ShutdownError") {
+var ShutdownError2 = class extends effect.Data.TaggedError("ShutdownError") {
 };
 
 // src/core/service-detector.ts
@@ -228,7 +645,7 @@ var detectServiceInfo = effect.Effect.gen(
     const packageJsonPath = path.join(process.cwd(), "package.json");
     const packageJsonContent = yield* effect.Effect.tryPromise({
       try: () => promises.readFile(packageJsonPath, "utf-8"),
-      catch: (error) => new ServiceDetectionError({
+      catch: (error) => new ServiceDetectionError2({
         reason: `Failed to read package.json at ${packageJsonPath}`,
         cause: error
       })
@@ -238,7 +655,7 @@ var detectServiceInfo = effect.Effect.gen(
       parsed = JSON.parse(packageJsonContent);
     } catch (error) {
       yield* effect.Effect.fail(
-        new ServiceDetectionError({
+        new ServiceDetectionError2({
           reason: "Invalid JSON in package.json",
           cause: error
         })
@@ -254,7 +671,7 @@ var detectServiceInfo = effect.Effect.gen(
       }
     }
     return yield* effect.Effect.fail(
-      new ServiceDetectionError({
+      new ServiceDetectionError2({
         reason: 'package.json exists but has no "name" field'
       })
     );
@@ -285,7 +702,7 @@ async function getServiceNameAsync() {
 async function getServiceVersionAsync() {
   return effect.Effect.runPromise(getServiceVersion);
 }
-var NodeConfigLoaderLive = instrumentCore.ConfigLoaderLive.pipe(
+var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
   effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
 );
 var cachedLoaderPromise = null;
@@ -293,7 +710,7 @@ function getCachedLoader() {
   if (!cachedLoaderPromise) {
     cachedLoaderPromise = effect.Effect.runPromise(
       effect.Effect.gen(function* () {
-        return yield* instrumentCore.ConfigLoader;
+        return yield* ConfigLoader;
       }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
     );
   }
@@ -305,7 +722,7 @@ function _resetConfigLoaderCache() {
 async function loadConfig(uri, options) {
   if (options?.cacheTimeout === 0) {
     const program = effect.Effect.gen(function* () {
-      const loader2 = yield* instrumentCore.ConfigLoader;
+      const loader2 = yield* ConfigLoader;
       return yield* loader2.loadFromUri(uri);
     });
     return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
@@ -375,7 +792,7 @@ function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
     ...programmaticPatterns.map((p) => typeof p === "string" ? new RegExp(p) : p),
     ...yamlPatterns.map((p) => new RegExp(p))
   ];
-  instrumentCore.logger.log(`HTTP filtering: ${allOutgoingPatterns.length} outgoing patterns configured`);
+  logger.log(`HTTP filtering: ${allOutgoingPatterns.length} outgoing patterns configured`);
   if (options.http?.ignoreOutgoingRequestHook) {
     httpConfig.ignoreOutgoingRequestHook = options.http.ignoreOutgoingRequestHook;
   } else if (allOutgoingPatterns.length > 0) {
@@ -444,9 +861,9 @@ function shouldEnableAutoInstrumentation(explicitValue, hasWebFramework) {
   }
   const isEffect = isEffectProject();
   if (isEffect && !hasWebFramework) {
-    instrumentCore.logger.log("@atrim/instrumentation: Detected Effect-TS without web framework");
-    instrumentCore.logger.log("  - Auto-instrumentation disabled by default");
-    instrumentCore.logger.log("  - Effect.withSpan() will create spans");
+    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;
@@ -484,11 +901,11 @@ function isTracingAlreadyInitialized() {
 }
 async function initializeSdk(options = {}) {
   if (sdkInstance) {
-    instrumentCore.logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
+    logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
     return sdkInstance;
   }
   if (initializationPromise) {
-    instrumentCore.logger.log(
+    logger.log(
       "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
     );
     return initializationPromise;
@@ -504,18 +921,18 @@ async function initializeSdk(options = {}) {
 async function performInitialization(options) {
   const config = await loadConfigWithOptions(options);
   const loggingLevel = config.instrumentation.logging || "on";
-  instrumentCore.logger.setLevel(loggingLevel);
+  logger.setLevel(loggingLevel);
   const alreadyInitialized = isTracingAlreadyInitialized();
   if (alreadyInitialized) {
-    instrumentCore.logger.log("@atrim/instrumentation: Detected existing OpenTelemetry initialization.");
-    instrumentCore.logger.log("  - Skipping NodeSDK setup");
-    instrumentCore.logger.log("  - Setting up pattern-based filtering only");
-    instrumentCore.logger.log("");
-    instrumentCore.initializePatternMatcher(config);
-    instrumentCore.logger.log("@atrim/instrumentation: Pattern filtering initialized");
-    instrumentCore.logger.log("  \u26A0\uFE0F  Note: Pattern filtering will only work with manual spans");
-    instrumentCore.logger.log("  \u26A0\uFE0F  Auto-instrumentation must be configured separately");
-    instrumentCore.logger.log("");
+    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();
@@ -551,7 +968,7 @@ async function performInitialization(options) {
         "@opentelemetry/instrumentation-dns": { enabled: false }
       })
     );
-    instrumentCore.logger.log(`Auto-instrumentation: ${instrumentations.length} instrumentations enabled`);
+    logger.log(`Auto-instrumentation: ${instrumentations.length} instrumentations enabled`);
   }
   if (options.instrumentations) {
     instrumentations.push(...options.instrumentations);
@@ -559,14 +976,14 @@ async function performInitialization(options) {
   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)";
-    instrumentCore.logger.log(detectionMessage);
-    instrumentCore.logger.log("  - Skipping NodeSDK setup");
-    instrumentCore.logger.log("  - Pattern matching configured from instrumentation.yaml");
+    logger.log(detectionMessage);
+    logger.log("  - Skipping NodeSDK setup");
+    logger.log("  - Pattern matching configured from instrumentation.yaml");
     if (!wasExplicit) {
-      instrumentCore.logger.log("  - Use EffectInstrumentationLive for tracing");
+      logger.log("  - Use EffectInstrumentationLive for tracing");
     }
-    instrumentCore.logger.log("");
-    instrumentCore.initializePatternMatcher(config);
+    logger.log("");
+    initializePatternMatcher(config);
     return null;
   }
   const sdkConfig = {
@@ -602,14 +1019,14 @@ function resetSdk() {
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
-    instrumentCore.logger.log(`
+    logger.log(`
 @atrim/instrumentation: Received ${signal}, shutting down gracefully...`);
     try {
       await sdk.shutdown();
-      instrumentCore.logger.log("@atrim/instrumentation: Shutdown complete");
+      logger.log("@atrim/instrumentation: Shutdown complete");
       process.exit(0);
     } catch (error) {
-      instrumentCore.logger.error(
+      logger.error(
         "@atrim/instrumentation: Error during shutdown:",
         error instanceof Error ? error.message : String(error)
       );
@@ -619,60 +1036,62 @@ function registerShutdownHandlers(sdk) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("uncaughtException", async (error) => {
-    instrumentCore.logger.error("@atrim/instrumentation: Uncaught exception:", error);
+    logger.error("@atrim/instrumentation: Uncaught exception:", error);
     await sdk.shutdown();
     process.exit(1);
   });
   process.on("unhandledRejection", async (reason) => {
-    instrumentCore.logger.error("@atrim/instrumentation: Unhandled rejection:", reason);
+    logger.error("@atrim/instrumentation: Unhandled rejection:", reason);
     await sdk.shutdown();
     process.exit(1);
   });
 }
 function logInitialization(config, serviceName, serviceVersion, options, autoInstrumentEnabled) {
-  instrumentCore.logger.minimal("@atrim/instrumentation: SDK initialized successfully");
-  instrumentCore.logger.log(`  - Service: ${serviceName}${serviceVersion ? ` v${serviceVersion}` : ""}`);
+  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;
-    instrumentCore.logger.log(`  - Pattern filtering: enabled`);
-    instrumentCore.logger.log(`    - Instrument patterns: ${instrumentCount}`);
-    instrumentCore.logger.log(`    - Ignore patterns: ${ignoreCount}`);
+    logger.log(`  - Pattern filtering: enabled`);
+    logger.log(`    - Instrument patterns: ${instrumentCount}`);
+    logger.log(`    - Ignore patterns: ${ignoreCount}`);
   } else {
-    instrumentCore.logger.log(`  - Pattern filtering: disabled`);
+    logger.log(`  - Pattern filtering: disabled`);
   }
   const autoInstrumentLabel = autoInstrumentEnabled ? "enabled" : "disabled";
   const autoDetected = options.autoInstrument === void 0 ? " (auto-detected)" : "";
-  instrumentCore.logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
+  logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
   if (options.instrumentations && options.instrumentations.length > 0) {
-    instrumentCore.logger.log(`  - Custom instrumentations: ${options.instrumentations.length}`);
+    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";
-  instrumentCore.logger.log(`  - OTLP endpoint: ${endpoint}`);
-  instrumentCore.logger.log("");
+  logger.log(`  - OTLP endpoint: ${endpoint}`);
+  logger.log("");
 }
+
+// src/api.ts
 async function initializeInstrumentation(options = {}) {
   const sdk = await initializeSdk(options);
   if (sdk) {
     const config = await loadConfigWithOptions(options);
-    instrumentCore.initializePatternMatcher(config);
+    initializePatternMatcher(config);
   }
   return sdk;
 }
 async function initializePatternMatchingOnly(options = {}) {
   const config = await loadConfigWithOptions(options);
-  instrumentCore.initializePatternMatcher(config);
-  instrumentCore.logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
-  instrumentCore.logger.log(
+  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 InitializationError({
+    catch: (error) => new InitializationError2({
       reason: "SDK initialization failed",
       cause: error
     })
@@ -680,14 +1099,14 @@ var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(functi
   if (sdk) {
     yield* effect.Effect.tryPromise({
       try: () => loadConfigWithOptions(options),
-      catch: (error) => new ConfigError({
+      catch: (error) => new ConfigError2({
         reason: "Failed to load config for pattern matcher",
         cause: error
       })
     }).pipe(
       effect.Effect.tap(
         (config) => effect.Effect.sync(() => {
-          instrumentCore.initializePatternMatcher(config);
+          initializePatternMatcher(config);
         })
       )
     );
@@ -697,15 +1116,15 @@ var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(functi
 var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
   const config = yield* effect.Effect.tryPromise({
     try: () => loadConfigWithOptions(options),
-    catch: (error) => new ConfigError({
+    catch: (error) => new ConfigError2({
       reason: "Failed to load configuration",
       cause: error
     })
   });
   yield* effect.Effect.sync(() => {
-    instrumentCore.initializePatternMatcher(config);
-    instrumentCore.logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
-    instrumentCore.logger.log(
+    initializePatternMatcher(config);
+    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    logger.log(
       "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
     );
   });
@@ -805,27 +1224,16 @@ function suppressShutdownErrors() {
   });
 }
 
-Object.defineProperty(exports, "PatternMatcher", {
-  enumerable: true,
-  get: function () { return instrumentCore.PatternMatcher; }
-});
-Object.defineProperty(exports, "getPatternMatcher", {
-  enumerable: true,
-  get: function () { return instrumentCore.getPatternMatcher; }
-});
-Object.defineProperty(exports, "shouldInstrumentSpan", {
-  enumerable: true,
-  get: function () { return instrumentCore.shouldInstrumentSpan; }
-});
-exports.ConfigError = ConfigError;
-exports.ConfigFileError = ConfigFileError;
-exports.ConfigUrlError = ConfigUrlError;
-exports.ConfigValidationError = ConfigValidationError;
-exports.ExportError = ExportError;
-exports.InitializationError = InitializationError;
+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 = ServiceDetectionError;
-exports.ShutdownError = ShutdownError;
+exports.ServiceDetectionError = ServiceDetectionError2;
+exports.ShutdownError = ShutdownError2;
 exports.annotateCacheOperation = annotateCacheOperation;
 exports.annotateDbQuery = annotateDbQuery;
 exports.annotateHttpRequest = annotateHttpRequest;
@@ -834,6 +1242,7 @@ exports.createOtlpExporter = createOtlpExporter;
 exports.detectServiceInfo = detectServiceInfoAsync;
 exports.detectServiceInfoEffect = detectServiceInfo;
 exports.getOtlpEndpoint = getOtlpEndpoint;
+exports.getPatternMatcher = getPatternMatcher;
 exports.getSdkInstance = getSdkInstance;
 exports.getServiceInfoWithFallback = getServiceInfoWithFallback;
 exports.getServiceName = getServiceNameAsync;
@@ -852,6 +1261,7 @@ 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