@atrim/instrument-node 0.1.3-fea6398-20251118010933 → 0.4.0-7fcca2c-20251118194147

package/target/dist/index.cjs

@@ -5,12 +5,12 @@ 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 instrumentCore = require('@atrim/instrument-core');
 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');
 
 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;
@@ -21,451 +21,11 @@ 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") {
-});
-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.matcher = new instrumentCore.PatternMatcher(config);
     this.wrappedProcessor = wrappedProcessor;
   }
   /**
@@ -538,8 +98,6 @@ 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) {
@@ -576,7 +134,7 @@ var SafeSpanExporter = class {
     try {
       await this.exporter.shutdown();
     } catch (error) {
-      logger.error(
+      instrumentCore.logger.error(
         "@atrim/instrumentation: Error during exporter shutdown (non-critical):",
         error instanceof Error ? error.message : String(error)
       );
@@ -605,14 +163,14 @@ var SafeSpanExporter = class {
     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.`);
+        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.`);
       } else {
-        logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
+        instrumentCore.logger.error("@atrim/instrumentation: Span export failed:", errorMessage);
       }
       if (this.errorCount > 1) {
-        logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
+        instrumentCore.logger.warn(`  (${this.errorCount} errors total, throttled to 1/min)`);
       }
       this.lastErrorTime = now;
       this.errorCount = 0;
@@ -639,21 +197,21 @@ var SafeSpanExporter = class {
     return false;
   }
 };
-var ConfigError2 = class extends effect.Data.TaggedError("ConfigError") {
+var ConfigError = class extends effect.Data.TaggedError("ConfigError") {
 };
-var ConfigUrlError2 = class extends effect.Data.TaggedError("ConfigUrlError") {
+var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
 };
-var ConfigValidationError2 = class extends effect.Data.TaggedError("ConfigValidationError") {
+var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
 };
-var ConfigFileError2 = class extends effect.Data.TaggedError("ConfigFileError") {
+var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
 };
-var ServiceDetectionError2 = class extends effect.Data.TaggedError("ServiceDetectionError") {
+var ServiceDetectionError = class extends effect.Data.TaggedError("ServiceDetectionError") {
 };
-var InitializationError2 = class extends effect.Data.TaggedError("InitializationError") {
+var InitializationError = class extends effect.Data.TaggedError("InitializationError") {
 };
-var ExportError2 = class extends effect.Data.TaggedError("ExportError") {
+var ExportError = class extends effect.Data.TaggedError("ExportError") {
 };
-var ShutdownError2 = class extends effect.Data.TaggedError("ShutdownError") {
+var ShutdownError = class extends effect.Data.TaggedError("ShutdownError") {
 };
 
 // src/core/service-detector.ts
@@ -670,7 +228,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 ServiceDetectionError2({
+      catch: (error) => new ServiceDetectionError({
         reason: `Failed to read package.json at ${packageJsonPath}`,
         cause: error
       })
@@ -680,7 +238,7 @@ var detectServiceInfo = effect.Effect.gen(
       parsed = JSON.parse(packageJsonContent);
     } catch (error) {
       yield* effect.Effect.fail(
-        new ServiceDetectionError2({
+        new ServiceDetectionError({
           reason: "Invalid JSON in package.json",
           cause: error
         })
@@ -696,7 +254,7 @@ var detectServiceInfo = effect.Effect.gen(
       }
     }
     return yield* effect.Effect.fail(
-      new ServiceDetectionError2({
+      new ServiceDetectionError({
         reason: 'package.json exists but has no "name" field'
       })
     );
@@ -727,6 +285,84 @@ async function getServiceNameAsync() {
 async function getServiceVersionAsync() {
   return effect.Effect.runPromise(getServiceVersion);
 }
+var NodeConfigLoaderLive = instrumentCore.ConfigLoaderLive.pipe(
+  effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
+);
+var cachedLoaderPromise = null;
+function getCachedLoader() {
+  if (!cachedLoaderPromise) {
+    cachedLoaderPromise = effect.Effect.runPromise(
+      effect.Effect.gen(function* () {
+        return yield* instrumentCore.ConfigLoader;
+      }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
+    );
+  }
+  return cachedLoaderPromise;
+}
+function _resetConfigLoaderCache() {
+  cachedLoaderPromise = null;
+}
+async function loadConfig(uri, options) {
+  if (options?.cacheTimeout === 0) {
+    const program = effect.Effect.gen(function* () {
+      const loader2 = yield* instrumentCore.ConfigLoader;
+      return yield* loader2.loadFromUri(uri);
+    });
+    return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
+  }
+  const loader = await getCachedLoader();
+  return effect.Effect.runPromise(loader.loadFromUri(uri));
+}
+async function loadConfigFromInline(content) {
+  const loader = await getCachedLoader();
+  return effect.Effect.runPromise(loader.loadFromInline(content));
+}
+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
+    }
+  };
+}
+async function loadConfigWithOptions(options = {}) {
+  const loadOptions = options.cacheTimeout !== void 0 ? { cacheTimeout: options.cacheTimeout } : void 0;
+  if (options.config) {
+    return loadConfigFromInline(options.config);
+  }
+  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
+  if (envConfigPath) {
+    return loadConfig(envConfigPath, loadOptions);
+  }
+  if (options.configUrl) {
+    return loadConfig(options.configUrl, loadOptions);
+  }
+  if (options.configPath) {
+    return loadConfig(options.configPath, loadOptions);
+  }
+  const { existsSync } = await import('fs');
+  const { join: join2 } = await import('path');
+  const defaultPath = join2(process.cwd(), "instrumentation.yaml");
+  if (existsSync(defaultPath)) {
+    return loadConfig(defaultPath, loadOptions);
+  }
+  return getDefaultConfig();
+}
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
@@ -739,7 +375,7 @@ function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
     ...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`);
+  instrumentCore.logger.log(`HTTP filtering: ${allOutgoingPatterns.length} outgoing patterns configured`);
   if (options.http?.ignoreOutgoingRequestHook) {
     httpConfig.ignoreOutgoingRequestHook = options.http.ignoreOutgoingRequestHook;
   } else if (allOutgoingPatterns.length > 0) {
@@ -808,9 +444,9 @@ function shouldEnableAutoInstrumentation(explicitValue, hasWebFramework) {
   }
   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");
+    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");
     return false;
   }
   return true;
@@ -848,11 +484,11 @@ function isTracingAlreadyInitialized() {
 }
 async function initializeSdk(options = {}) {
   if (sdkInstance) {
-    logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
+    instrumentCore.logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
     return sdkInstance;
   }
   if (initializationPromise) {
-    logger.log(
+    instrumentCore.logger.log(
       "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
     );
     return initializationPromise;
@@ -866,20 +502,20 @@ async function initializeSdk(options = {}) {
   }
 }
 async function performInitialization(options) {
-  const config = await loadConfig(options);
+  const config = await loadConfigWithOptions(options);
   const loggingLevel = config.instrumentation.logging || "on";
-  logger.setLevel(loggingLevel);
+  instrumentCore.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("");
+    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("");
     return null;
   }
   const serviceInfo = await detectServiceInfoAsync();
@@ -915,7 +551,7 @@ async function performInitialization(options) {
         "@opentelemetry/instrumentation-dns": { enabled: false }
       })
     );
-    logger.log(`Auto-instrumentation: ${instrumentations.length} instrumentations enabled`);
+    instrumentCore.logger.log(`Auto-instrumentation: ${instrumentations.length} instrumentations enabled`);
   }
   if (options.instrumentations) {
     instrumentations.push(...options.instrumentations);
@@ -923,14 +559,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)";
-    logger.log(detectionMessage);
-    logger.log("  - Skipping NodeSDK setup");
-    logger.log("  - Pattern matching configured from instrumentation.yaml");
+    instrumentCore.logger.log(detectionMessage);
+    instrumentCore.logger.log("  - Skipping NodeSDK setup");
+    instrumentCore.logger.log("  - Pattern matching configured from instrumentation.yaml");
     if (!wasExplicit) {
-      logger.log("  - Use EffectInstrumentationLive for tracing");
+      instrumentCore.logger.log("  - Use EffectInstrumentationLive for tracing");
     }
-    logger.log("");
-    initializePatternMatcher(config);
+    instrumentCore.logger.log("");
+    instrumentCore.initializePatternMatcher(config);
     return null;
   }
   const sdkConfig = {
@@ -966,14 +602,14 @@ function resetSdk() {
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
-    logger.log(`
+    instrumentCore.logger.log(`
 @atrim/instrumentation: Received ${signal}, shutting down gracefully...`);
     try {
       await sdk.shutdown();
-      logger.log("@atrim/instrumentation: Shutdown complete");
+      instrumentCore.logger.log("@atrim/instrumentation: Shutdown complete");
       process.exit(0);
     } catch (error) {
-      logger.error(
+      instrumentCore.logger.error(
         "@atrim/instrumentation: Error during shutdown:",
         error instanceof Error ? error.message : String(error)
       );
@@ -983,77 +619,75 @@ function registerShutdownHandlers(sdk) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("uncaughtException", async (error) => {
-    logger.error("@atrim/instrumentation: Uncaught exception:", error);
+    instrumentCore.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);
+    instrumentCore.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}` : ""}`);
+  instrumentCore.logger.minimal("@atrim/instrumentation: SDK initialized successfully");
+  instrumentCore.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}`);
+    instrumentCore.logger.log(`  - Pattern filtering: enabled`);
+    instrumentCore.logger.log(`    - Instrument patterns: ${instrumentCount}`);
+    instrumentCore.logger.log(`    - Ignore patterns: ${ignoreCount}`);
   } else {
-    logger.log(`  - Pattern filtering: disabled`);
+    instrumentCore.logger.log(`  - Pattern filtering: disabled`);
   }
   const autoInstrumentLabel = autoInstrumentEnabled ? "enabled" : "disabled";
   const autoDetected = options.autoInstrument === void 0 ? " (auto-detected)" : "";
-  logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
+  instrumentCore.logger.log(`  - Auto-instrumentation: ${autoInstrumentLabel}${autoDetected}`);
   if (options.instrumentations && options.instrumentations.length > 0) {
-    logger.log(`  - Custom instrumentations: ${options.instrumentations.length}`);
+    instrumentCore.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("");
+  instrumentCore.logger.log(`  - OTLP endpoint: ${endpoint}`);
+  instrumentCore.logger.log("");
 }
-
-// src/api.ts
 async function initializeInstrumentation(options = {}) {
   const sdk = await initializeSdk(options);
   if (sdk) {
-    const config = await loadConfig(options);
-    initializePatternMatcher(config);
+    const config = await loadConfigWithOptions(options);
+    instrumentCore.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(
+  const config = await loadConfigWithOptions(options);
+  instrumentCore.initializePatternMatcher(config);
+  instrumentCore.logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+  instrumentCore.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({
+    catch: (error) => new InitializationError({
       reason: "SDK initialization failed",
       cause: error
     })
   });
   if (sdk) {
     yield* effect.Effect.tryPromise({
-      try: () => loadConfig(options),
-      catch: (error) => new ConfigError2({
+      try: () => loadConfigWithOptions(options),
+      catch: (error) => new ConfigError({
         reason: "Failed to load config for pattern matcher",
         cause: error
       })
     }).pipe(
       effect.Effect.tap(
         (config) => effect.Effect.sync(() => {
-          initializePatternMatcher(config);
+          instrumentCore.initializePatternMatcher(config);
         })
       )
     );
@@ -1062,16 +696,16 @@ var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(functi
 });
 var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
   const config = yield* effect.Effect.tryPromise({
-    try: () => loadConfig(options),
-    catch: (error) => new ConfigError2({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => new ConfigError({
       reason: "Failed to load configuration",
       cause: error
     })
   });
   yield* effect.Effect.sync(() => {
-    initializePatternMatcher(config);
-    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
-    logger.log(
+    instrumentCore.initializePatternMatcher(config);
+    instrumentCore.logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    instrumentCore.logger.log(
       "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
     );
   });
@@ -1171,24 +805,35 @@ function suppressShutdownErrors() {
   });
 }
 
-exports.ConfigError = ConfigError2;
-exports.ConfigFileError = ConfigFileError2;
-exports.ConfigUrlError = ConfigUrlError2;
-exports.ConfigValidationError = ConfigValidationError2;
-exports.ExportError = ExportError2;
-exports.InitializationError = InitializationError2;
-exports.PatternMatcher = PatternMatcher;
+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.PatternSpanProcessor = PatternSpanProcessor;
-exports.ServiceDetectionError = ServiceDetectionError2;
-exports.ShutdownError = ShutdownError2;
+exports.ServiceDetectionError = ServiceDetectionError;
+exports.ShutdownError = ShutdownError;
 exports.annotateCacheOperation = annotateCacheOperation;
 exports.annotateDbQuery = annotateDbQuery;
 exports.annotateHttpRequest = annotateHttpRequest;
+exports.clearConfigCache = _resetConfigLoaderCache;
 exports.createOtlpExporter = createOtlpExporter;
 exports.detectServiceInfo = detectServiceInfoAsync;
 exports.detectServiceInfoEffect = detectServiceInfo;
 exports.getOtlpEndpoint = getOtlpEndpoint;
-exports.getPatternMatcher = getPatternMatcher;
 exports.getSdkInstance = getSdkInstance;
 exports.getServiceInfoWithFallback = getServiceInfoWithFallback;
 exports.getServiceName = getServiceNameAsync;
@@ -1200,12 +845,13 @@ exports.initializeInstrumentationEffect = initializeInstrumentationEffect;
 exports.initializePatternMatchingOnly = initializePatternMatchingOnly;
 exports.initializePatternMatchingOnlyEffect = initializePatternMatchingOnlyEffect;
 exports.loadConfig = loadConfig;
+exports.loadConfigFromInline = loadConfigFromInline;
+exports.loadConfigWithOptions = loadConfigWithOptions;
 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