@atrim/instrument-node 0.4.0 → 0.5.0-3a3dd2c-20251124202015

package/target/dist/index.js

@@ -1,14 +1,18 @@
-import { Data, Effect, Cache, Duration, Schedule } from 'effect';
+import { Data, Context, 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 { FileSystem } from '@effect/platform/FileSystem';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
 import { parse } from 'yaml';
 import { z } from 'zod';
 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;
@@ -49,13 +53,69 @@ var AutoIsolationConfigSchema = z.object({
     add_metadata: z.boolean().default(true)
   }).default({})
 });
+var SpanNamingRuleSchema = z.object({
+  // Match conditions (all specified conditions must match)
+  match: z.object({
+    // Match by file path pattern (regex)
+    file: z.string().optional(),
+    // Match by function name pattern (regex)
+    function: z.string().optional(),
+    // Match by operator type (gen, all, forEach, etc.)
+    operator: z.string().optional(),
+    // Match by call stack pattern (regex)
+    stack: z.string().optional(),
+    // Match by fiber annotation key
+    annotation: z.string().optional()
+  }),
+  // Name template with substitution variables
+  // Available: {operator}, {function}, {module}, {file}, {line}, {class}, {match:N}
+  name: z.string()
+});
+var AutoTracingConfigSchema = z.object({
+  // Global enable/disable for auto-tracing
+  enabled: z.boolean().default(true),
+  // Span naming configuration
+  span_naming: z.object({
+    // Default name template when no rules match
+    default: z.string().default("effect.{operator}"),
+    // Custom naming rules (applied in order, first match wins)
+    rules: z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern filtering
+  filter_patterns: z.object({
+    // Only trace spans matching these patterns
+    include: z.array(z.string()).default([]),
+    // Exclude spans matching these patterns (takes precedence)
+    exclude: z.array(z.string()).default([])
+  }).default({}),
+  // Sampling configuration
+  sampling: z.object({
+    // Sampling rate (0.0 to 1.0)
+    rate: z.number().min(0).max(1).default(1),
+    // Only trace effects with duration > this value
+    min_duration: z.string().default("0 millis")
+  }).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()
+  require_parent_for_outgoing_spans: z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: 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: 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: z.array(z.string()).optional()
+  }).optional()
 });
 var InstrumentationConfigSchema = z.object({
   version: z.string(),
@@ -68,238 +128,189 @@ var InstrumentationConfigSchema = z.object({
   }),
   effect: z.object({
     auto_extract_metadata: z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional()
+    auto_isolation: AutoIsolationConfigSchema.optional(),
+    auto_tracing: AutoTracingConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });
 (class extends Data.TaggedError("ConfigError") {
+  get message() {
+    return this.reason;
+  }
 });
 var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
 };
 var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
 };
 var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
 };
 (class extends Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
 });
 (class extends Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
 });
 (class extends Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
 });
 (class extends 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.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}`,
+var ConfigLoader = class extends Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => Effect.gen(function* () {
+  const parsed = yield* Effect.try({
+    try: () => parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* Effect.try({
+    try: () => InstrumentationConfigSchema.parse(parsed),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
       cause: error
     })
   });
-  if (fileContents.length > SECURITY_DEFAULTS.maxConfigSize) {
+});
+var loadFromFileWithFs = (fs, path, uri) => Effect.gen(function* () {
+  const content = yield* fs.readFileString(path).pipe(
+    Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.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);
+  return yield* parseYamlContent(content, uri);
 });
-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
+var loadFromHttpWithClient = (client, url) => Effect.scoped(
+  Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest.get(url).pipe(
+      HttpClientRequest.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
       })
     );
-  }
-  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* client.execute(request).pipe(
+      Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      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.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`
+    if (response.status >= 400) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          cause: error
+        })
+      )
+    );
+    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = Effect.gen(function* () {
+  const fs = yield* Effect.serviceOption(FileSystem);
+  const http = yield* HttpClient.HttpClient;
+  const loadFromUriUncached = (uri) => Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* Effect.fail(
+          new ConfigFileError({
+            reason: "FileSystem not available (browser environment?)",
+            cause: { uri }
           })
         );
       }
-      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
+      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.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* 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.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 ConfigLoaderLive = Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField2(this, "ignorePatterns", []);
@@ -725,6 +736,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 +953,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();
@@ -1020,13 +1109,13 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
 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(
@@ -1043,7 +1132,7 @@ var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* ()
   });
   if (sdk) {
     yield* Effect.tryPromise({
-      try: () => loadConfig(options),
+      try: () => loadConfigWithOptions(options),
       catch: (error) => new ConfigError2({
         reason: "Failed to load config for pattern matcher",
         cause: error
@@ -1060,7 +1149,7 @@ var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* ()
 });
 var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
   const config = yield* Effect.tryPromise({
-    try: () => loadConfig(options),
+    try: () => loadConfigWithOptions(options),
     catch: (error) => new ConfigError2({
       reason: "Failed to load configuration",
       cause: error
@@ -1169,6 +1258,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 { 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, _resetConfigLoaderCache as clearConfigCache, 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, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map