@atrim/instrument-node 0.4.0 → 0.5.0-c05e3a1-20251119131235

package/target/dist/index.cjs

@@ -5,12 +5,37 @@ 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 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;
@@ -57,7 +82,20 @@ var HttpFilteringConfigSchema = zod.z.object({
   // 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()
+  require_parent_for_outgoing_spans: zod.z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: zod.z.object({
+    // Strategy for trace propagation
+    // - "all": Propagate to all cross-origin requests (may cause CORS errors)
+    // - "none": Never propagate trace headers
+    // - "same-origin": Only propagate to same-origin requests (default, safe)
+    // - "patterns": Propagate based on include_urls patterns
+    strategy: zod.z.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
+    // URL patterns to include when strategy is "patterns"
+    // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
+    include_urls: zod.z.array(zod.z.string()).optional()
+  }).optional()
 });
 var InstrumentationConfigSchema = zod.z.object({
   version: zod.z.string(),
@@ -75,233 +113,183 @@ var InstrumentationConfigSchema = zod.z.object({
   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,
-  allowedProtocols: ["https:"],
-  // Only HTTPS for remote configs
-  cacheTimeout: 3e5
-  // 5 minutes
+  requestTimeout: 5e3
+  // 5 seconds
 };
-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}`,
+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
     })
   });
-  if (fileContents.length > SECURITY_DEFAULTS.maxConfigSize) {
+  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`
       })
     );
   }
-  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);
+  return yield* parseYamlContent(content, uri);
 });
-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
+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"
       })
     );
-  }
-  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* 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
+        });
       })
     );
-  }
-  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`
+    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 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
+      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
+        })
+      });
     })
   });
-  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 ConfigLoaderLive = effect.Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField2(this, "ignorePatterns", []);
@@ -718,19 +706,88 @@ var getServiceInfoWithFallback = detectServiceInfo.pipe(
     })
   )
 );
-async function detectServiceInfoAsync() {
-  return effect.Effect.runPromise(getServiceInfoWithFallback);
+var NodeConfigLoaderLive = 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* ConfigLoader;
+      }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
+    );
+  }
+  return cachedLoaderPromise;
 }
-async function getServiceNameAsync() {
-  return effect.Effect.runPromise(getServiceName);
+function _resetConfigLoaderCache() {
+  cachedLoaderPromise = null;
 }
-async function getServiceVersionAsync() {
-  return effect.Effect.runPromise(getServiceVersion);
+async function loadConfig(uri, options) {
+  if (options?.cacheTimeout === 0) {
+    const program = effect.Effect.gen(function* () {
+      const loader2 = yield* 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;
-var initializationPromise = null;
+var initializationDeferred = null;
 function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
   const httpConfig = { enabled: true };
   const programmaticPatterns = options.http?.ignoreOutgoingUrls || [];
@@ -846,27 +903,38 @@ function isTracingAlreadyInitialized() {
     return false;
   }
 }
-async function initializeSdk(options = {}) {
+var initializeSdkEffect = (options = {}) => effect.Effect.gen(function* () {
   if (sdkInstance) {
     logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
     return sdkInstance;
   }
-  if (initializationPromise) {
+  if (initializationDeferred) {
     logger.log(
-      "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
+      "@atrim/instrumentation: SDK initialization in progress, waiting for completion..."
     );
-    return initializationPromise;
-  }
-  initializationPromise = performInitialization(options);
-  try {
-    const result = await initializationPromise;
-    return result;
-  } finally {
-    initializationPromise = null;
-  }
-}
-async function performInitialization(options) {
-  const config = await loadConfig(options);
+    return yield* effect.Deferred.await(initializationDeferred);
+  }
+  const deferred = yield* effect.Deferred.make();
+  initializationDeferred = deferred;
+  const result = yield* performInitializationEffect(options).pipe(
+    effect.Effect.tap((sdk) => effect.Deferred.succeed(deferred, sdk)),
+    effect.Effect.tapError((error) => effect.Deferred.fail(deferred, error)),
+    effect.Effect.ensuring(
+      effect.Effect.sync(() => {
+        initializationDeferred = null;
+      })
+    )
+  );
+  return result;
+});
+var performInitializationEffect = (options) => effect.Effect.gen(function* () {
+  const config = yield* effect.Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => new InitializationError2({
+      reason: "Failed to load configuration",
+      cause: error
+    })
+  });
   const loggingLevel = config.instrumentation.logging || "on";
   logger.setLevel(loggingLevel);
   const alreadyInitialized = isTracingAlreadyInitialized();
@@ -882,14 +950,25 @@ async function performInitialization(options) {
     logger.log("");
     return null;
   }
-  const serviceInfo = await detectServiceInfoAsync();
+  const serviceInfo = yield* detectServiceInfo.pipe(
+    effect.Effect.catchAll(
+      () => effect.Effect.succeed({
+        name: "unknown-service",
+        version: void 0
+      })
+    )
+  );
   const serviceName = options.serviceName || serviceInfo.name;
   const serviceVersion = options.serviceVersion || serviceInfo.version;
-  const rawExporter = createOtlpExporter(options.otlp);
-  const exporter = new SafeSpanExporter(rawExporter);
+  const rawExporter = yield* effect.Effect.sync(() => createOtlpExporter(options.otlp));
+  const exporter = yield* effect.Effect.sync(() => 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 baseProcessor = yield* effect.Effect.sync(
+    () => useSimpleProcessor ? new sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.BatchSpanProcessor(exporter)
+  );
+  const patternProcessor = yield* effect.Effect.sync(
+    () => new PatternSpanProcessor(config, baseProcessor)
+  );
   const instrumentations = [];
   const hasWebFramework = hasWebFrameworkInstalled();
   const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
@@ -902,15 +981,11 @@ async function performInitialization(options) {
     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 }
       })
@@ -938,18 +1013,20 @@ async function performInitialization(options) {
     serviceName,
     ...serviceVersion && { serviceVersion },
     instrumentations,
-    // Allow advanced overrides
     ...options.sdk
   };
-  const sdk = new sdkNode.NodeSDK(sdkConfig);
-  sdk.start();
+  const sdk = yield* effect.Effect.sync(() => {
+    const s = new sdkNode.NodeSDK(sdkConfig);
+    s.start();
+    return s;
+  });
   sdkInstance = sdk;
   if (!options.disableAutoShutdown) {
-    registerShutdownHandlers(sdk);
+    yield* effect.Effect.sync(() => registerShutdownHandlers(sdk));
   }
   logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
   return sdk;
-}
+});
 function getSdkInstance() {
   return sdkInstance;
 }
@@ -962,7 +1039,7 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationPromise = null;
+  initializationDeferred = null;
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
@@ -1019,33 +1096,11 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
 }
 
 // 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
-    })
-  });
+var initializeInstrumentation = (options = {}) => effect.Effect.gen(function* () {
+  const sdk = yield* initializeSdkEffect(options);
   if (sdk) {
     yield* effect.Effect.tryPromise({
-      try: () => loadConfig(options),
+      try: () => loadConfigWithOptions(options),
       catch: (error) => new ConfigError2({
         reason: "Failed to load config for pattern matcher",
         cause: error
@@ -1060,9 +1115,9 @@ var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(functi
   }
   return sdk;
 });
-var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
+var initializePatternMatchingOnly = (options = {}) => effect.Effect.gen(function* () {
   const config = yield* effect.Effect.tryPromise({
-    try: () => loadConfig(options),
+    try: () => loadConfigWithOptions(options),
     catch: (error) => new ConfigError2({
       reason: "Failed to load configuration",
       cause: error
@@ -1070,7 +1125,7 @@ var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(fu
   });
   yield* effect.Effect.sync(() => {
     initializePatternMatcher(config);
-    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    logger.log("@atrim/instrumentation: Pattern matching initialized (pattern-only mode)");
     logger.log(
       "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
     );
@@ -1184,22 +1239,20 @@ exports.ShutdownError = ShutdownError2;
 exports.annotateCacheOperation = annotateCacheOperation;
 exports.annotateDbQuery = annotateDbQuery;
 exports.annotateHttpRequest = annotateHttpRequest;
+exports.clearConfigCache = _resetConfigLoaderCache;
 exports.createOtlpExporter = createOtlpExporter;
-exports.detectServiceInfo = detectServiceInfoAsync;
-exports.detectServiceInfoEffect = detectServiceInfo;
+exports.detectServiceInfo = 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.getServiceName = getServiceName;
+exports.getServiceVersion = getServiceVersion;
 exports.initializeInstrumentation = initializeInstrumentation;
-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;