@atrim/instrument-node 0.1.3-fea6398-20251118005809 → 0.4.0-08fae61-20251118193009

package/target/dist/index.js

@@ -1,14 +1,15 @@
-import { Data, Effect, Cache, Duration, Schedule } from 'effect';
+import { Data, Effect, Layer } from 'effect';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 import { trace } from '@opentelemetry/api';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { parse } from 'yaml';
-import { z } from 'zod';
+import { ConfigLoaderLive, PatternMatcher, ConfigLoader, initializePatternMatcher, logger } from '@atrim/instrument-core';
+export { PatternMatcher, getPatternMatcher, shouldInstrumentSpan } from '@atrim/instrument-core';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { NodeContext } from '@effect/platform-node';
+import { FetchHttpClient } from '@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;
@@ -19,446 +20,6 @@ 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 = z.object({
-  pattern: z.string(),
-  enabled: z.boolean().optional(),
-  description: z.string().optional()
-});
-var AutoIsolationConfigSchema = z.object({
-  // Global enable/disable for auto-isolation
-  enabled: z.boolean().default(false),
-  // Which operators to auto-isolate
-  operators: z.object({
-    fiberset_run: z.boolean().default(true),
-    effect_fork: z.boolean().default(true),
-    effect_fork_daemon: z.boolean().default(true),
-    effect_fork_in: z.boolean().default(false)
-  }).default({}),
-  // Virtual parent tracking configuration
-  tracking: z.object({
-    use_span_links: z.boolean().default(true),
-    use_attributes: z.boolean().default(true),
-    capture_logical_parent: z.boolean().default(true)
-  }).default({}),
-  // Span categorization
-  attributes: z.object({
-    category: z.string().default("background_task"),
-    add_metadata: z.boolean().default(true)
-  }).default({})
-});
-var HttpFilteringConfigSchema = z.object({
-  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
-  ignore_outgoing_urls: z.array(z.string()).optional(),
-  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
-  ignore_incoming_paths: z.array(z.string()).optional(),
-  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: z.boolean().optional()
-});
-var InstrumentationConfigSchema = z.object({
-  version: z.string(),
-  instrumentation: z.object({
-    enabled: z.boolean(),
-    description: z.string().optional(),
-    logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
-    instrument_patterns: z.array(PatternConfigSchema),
-    ignore_patterns: z.array(PatternConfigSchema)
-  }),
-  effect: z.object({
-    auto_extract_metadata: z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional()
-  }).optional(),
-  http: HttpFilteringConfigSchema.optional()
-});
-(class extends Data.TaggedError("ConfigError") {
-});
-var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
-};
-var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
-};
-var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
-};
-(class extends Data.TaggedError("ServiceDetectionError") {
-});
-(class extends Data.TaggedError("InitializationError") {
-});
-(class extends Data.TaggedError("ExportError") {
-});
-(class extends 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.try({
-  try: () => InstrumentationConfigSchema.parse(rawConfig),
-  catch: (error) => new ConfigValidationError({
-    reason: "Invalid configuration schema",
-    cause: error
-  })
-});
-var loadConfigFromFileEffect = (filePath) => Effect.gen(function* () {
-  const fileContents = yield* Effect.try({
-    try: () => 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.fail(
-      new ConfigFileError({
-        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = parse(fileContents);
-  } catch (error) {
-    return yield* Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var fetchAndParseConfig = (url) => Effect.gen(function* () {
-  let urlObj;
-  try {
-    urlObj = new URL(url);
-  } catch (error) {
-    return yield* Effect.fail(
-      new ConfigUrlError({
-        reason: `Invalid URL: ${url}`,
-        cause: error
-      })
-    );
-  }
-  if (!SECURITY_DEFAULTS.allowedProtocols.includes(urlObj.protocol)) {
-    return yield* Effect.fail(
-      new ConfigUrlError({
-        reason: `Insecure protocol ${urlObj.protocol}. Only ${SECURITY_DEFAULTS.allowedProtocols.join(", ")} are allowed`
-      })
-    );
-  }
-  const response = yield* 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.timeout(Duration.millis(SECURITY_DEFAULTS.requestTimeout)),
-    Effect.retry({
-      times: 3,
-      schedule: Schedule.exponential(Duration.millis(100))
-    }),
-    Effect.catchAll((error) => {
-      if (error._tag === "TimeoutException") {
-        return Effect.fail(
-          new ConfigUrlError({
-            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms`
-          })
-        );
-      }
-      return Effect.fail(error);
-    })
-  );
-  if (!response.ok) {
-    return yield* 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.fail(
-      new ConfigUrlError({
-        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  const text = yield* 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.fail(
-      new ConfigUrlError({
-        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = parse(text);
-  } catch (error) {
-    return yield* Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var makeConfigCache = () => Cache.make({
-  capacity: 100,
-  timeToLive: Duration.minutes(5),
-  lookup: (url) => fetchAndParseConfig(url)
-});
-var cacheInstance = null;
-var getCache = Effect.gen(function* () {
-  if (!cacheInstance) {
-    cacheInstance = yield* makeConfigCache();
-  }
-  return cacheInstance;
-});
-var loadConfigFromUrlEffect = (url, cacheTimeout = SECURITY_DEFAULTS.cacheTimeout) => Effect.gen(function* () {
-  if (cacheTimeout === 0) {
-    return yield* fetchAndParseConfig(url);
-  }
-  const cache = yield* getCache;
-  return yield* cache.get(url);
-});
-var loadConfigEffect = (options = {}) => 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 = join(process.cwd(), "instrumentation.yaml");
-  const exists = yield* Effect.sync(() => existsSync(defaultPath));
-  if (exists) {
-    return yield* loadConfigFromFileEffect(defaultPath);
-  }
-  return getDefaultConfig();
-});
-async function loadConfig(options = {}) {
-  return Effect.runPromise(
-    loadConfigEffect(options).pipe(
-      // Convert typed errors to regular Error with reason message for backward compatibility
-      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");
@@ -536,8 +97,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) {
@@ -637,21 +196,21 @@ var SafeSpanExporter = class {
     return false;
   }
 };
-var ConfigError2 = class extends Data.TaggedError("ConfigError") {
+var ConfigError = class extends Data.TaggedError("ConfigError") {
 };
-var ConfigUrlError2 = class extends Data.TaggedError("ConfigUrlError") {
+var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
 };
-var ConfigValidationError2 = class extends Data.TaggedError("ConfigValidationError") {
+var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
 };
-var ConfigFileError2 = class extends Data.TaggedError("ConfigFileError") {
+var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
 };
-var ServiceDetectionError2 = class extends Data.TaggedError("ServiceDetectionError") {
+var ServiceDetectionError = class extends Data.TaggedError("ServiceDetectionError") {
 };
-var InitializationError2 = class extends Data.TaggedError("InitializationError") {
+var InitializationError = class extends Data.TaggedError("InitializationError") {
 };
-var ExportError2 = class extends Data.TaggedError("ExportError") {
+var ExportError = class extends Data.TaggedError("ExportError") {
 };
-var ShutdownError2 = class extends Data.TaggedError("ShutdownError") {
+var ShutdownError = class extends Data.TaggedError("ShutdownError") {
 };
 
 // src/core/service-detector.ts
@@ -668,7 +227,7 @@ var detectServiceInfo = Effect.gen(
     const packageJsonPath = join(process.cwd(), "package.json");
     const packageJsonContent = yield* Effect.tryPromise({
       try: () => readFile(packageJsonPath, "utf-8"),
-      catch: (error) => new ServiceDetectionError2({
+      catch: (error) => new ServiceDetectionError({
         reason: `Failed to read package.json at ${packageJsonPath}`,
         cause: error
       })
@@ -678,7 +237,7 @@ var detectServiceInfo = Effect.gen(
       parsed = JSON.parse(packageJsonContent);
     } catch (error) {
       yield* Effect.fail(
-        new ServiceDetectionError2({
+        new ServiceDetectionError({
           reason: "Invalid JSON in package.json",
           cause: error
         })
@@ -694,7 +253,7 @@ var detectServiceInfo = Effect.gen(
       }
     }
     return yield* Effect.fail(
-      new ServiceDetectionError2({
+      new ServiceDetectionError({
         reason: 'package.json exists but has no "name" field'
       })
     );
@@ -725,6 +284,84 @@ async function getServiceNameAsync() {
 async function getServiceVersionAsync() {
   return Effect.runPromise(getServiceVersion);
 }
+var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
+  Layer.provide(Layer.mergeAll(NodeContext.layer, FetchHttpClient.layer))
+);
+var cachedLoaderPromise = null;
+function getCachedLoader() {
+  if (!cachedLoaderPromise) {
+    cachedLoaderPromise = Effect.runPromise(
+      Effect.gen(function* () {
+        return yield* ConfigLoader;
+      }).pipe(Effect.provide(NodeConfigLoaderLive))
+    );
+  }
+  return cachedLoaderPromise;
+}
+function _resetConfigLoaderCache() {
+  cachedLoaderPromise = null;
+}
+async function loadConfig(uri, options) {
+  if (options?.cacheTimeout === 0) {
+    const program = Effect.gen(function* () {
+      const loader2 = yield* ConfigLoader;
+      return yield* loader2.loadFromUri(uri);
+    });
+    return Effect.runPromise(program.pipe(Effect.provide(NodeConfigLoaderLive)));
+  }
+  const loader = await getCachedLoader();
+  return Effect.runPromise(loader.loadFromUri(uri));
+}
+async function loadConfigFromInline(content) {
+  const loader = await getCachedLoader();
+  return 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;
@@ -864,7 +501,7 @@ 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);
   const alreadyInitialized = isTracingAlreadyInitialized();
@@ -1015,18 +652,16 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
   logger.log(`  - OTLP endpoint: ${endpoint}`);
   logger.log("");
 }
-
-// src/api.ts
 async function initializeInstrumentation(options = {}) {
   const sdk = await initializeSdk(options);
   if (sdk) {
-    const config = await loadConfig(options);
+    const config = await loadConfigWithOptions(options);
     initializePatternMatcher(config);
   }
   return sdk;
 }
 async function initializePatternMatchingOnly(options = {}) {
-  const config = await loadConfig(options);
+  const config = await loadConfigWithOptions(options);
   initializePatternMatcher(config);
   logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
   logger.log(
@@ -1036,15 +671,15 @@ async function initializePatternMatchingOnly(options = {}) {
 var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* () {
   const sdk = yield* Effect.tryPromise({
     try: () => initializeSdk(options),
-    catch: (error) => new InitializationError2({
+    catch: (error) => new InitializationError({
       reason: "SDK initialization failed",
       cause: error
     })
   });
   if (sdk) {
     yield* 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
       })
@@ -1060,8 +695,8 @@ var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* ()
 });
 var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
   const config = yield* Effect.tryPromise({
-    try: () => loadConfig(options),
-    catch: (error) => new ConfigError2({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => new ConfigError({
       reason: "Failed to load configuration",
       cause: error
     })
@@ -1169,6 +804,6 @@ function suppressShutdownErrors() {
   });
 }
 
-export { ConfigError2 as ConfigError, ConfigFileError2 as ConfigFileError, ConfigUrlError2 as ConfigUrlError, ConfigValidationError2 as ConfigValidationError, ExportError2 as ExportError, InitializationError2 as InitializationError, PatternMatcher, PatternSpanProcessor, ServiceDetectionError2 as ServiceDetectionError, ShutdownError2 as ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getPatternMatcher, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
+export { ConfigError, ConfigFileError, ConfigUrlError, ConfigValidationError, ExportError, InitializationError, PatternSpanProcessor, ServiceDetectionError, ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shutdownSdk, suppressShutdownErrors };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map