@atrim/instrument-node 0.5.0 → 0.5.1-21bb978-20260105202350

package/target/dist/integrations/effect/index.cjs

@@ -1,15 +1,17 @@
 'use strict';
 
 var effect = require('effect');
+var Tracer = require('@effect/opentelemetry/Tracer');
+var Resource = require('@effect/opentelemetry/Resource');
 var Otlp = require('@effect/opentelemetry/Otlp');
 var platform = require('@effect/platform');
 var api = require('@opentelemetry/api');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
 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 platformNode = require('@effect/platform-node');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -29,6 +31,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var Tracer__namespace = /*#__PURE__*/_interopNamespace(Tracer);
+var Resource__namespace = /*#__PURE__*/_interopNamespace(Resource);
 var Otlp__namespace = /*#__PURE__*/_interopNamespace(Otlp);
 var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
 var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
@@ -70,7 +74,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(),
@@ -82,11 +99,56 @@ var InstrumentationConfigSchema = zod.z.object({
     ignore_patterns: zod.z.array(PatternConfigSchema)
   }),
   effect: zod.z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: zod.z.boolean().default(true),
+    // Exporter mode:
+    // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
+    // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+    exporter: zod.z.enum(["unified", "standalone"]).default("unified"),
     auto_extract_metadata: zod.z.boolean(),
+    // Auto-bridge OpenTelemetry context to Effect spans
+    // When true, Effect spans automatically become children of the active OTel span
+    // (e.g., HTTP request span from auto-instrumentation)
+    // This is essential for proper trace hierarchy when using Effect with HTTP frameworks
+    auto_bridge_context: zod.z.boolean().default(true),
     auto_isolation: AutoIsolationConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });
+var defaultConfig = {
+  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: {
+    enabled: true,
+    exporter: "unified",
+    auto_extract_metadata: true,
+    auto_bridge_context: true
+  }
+};
+function parseAndValidateConfig(content) {
+  let parsed;
+  if (typeof content === "string") {
+    parsed = yaml.parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
 (class extends effect.Data.TaggedError("ConfigError") {
   get message() {
     return this.reason;
@@ -264,7 +326,7 @@ var makeConfigLoader = effect.Effect.gen(function* () {
     })
   });
 });
-var ConfigLoaderLive = effect.Layer.effect(ConfigLoader, makeConfigLoader);
+effect.Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField(this, "ignorePatterns", []);
@@ -412,83 +474,58 @@ var Logger = class {
   }
 };
 var logger = new Logger();
-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))
-    );
+async function loadFromFile(filePath) {
+  const { readFile } = await import('fs/promises');
+  const content = await readFile(filePath, "utf-8");
+  return parseAndValidateConfig(content);
+}
+async function loadFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch config from ${url}: ${response.statusText}`);
   }
-  return cachedLoaderPromise;
+  const content = await response.text();
+  return parseAndValidateConfig(content);
 }
-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)));
+async function loadConfig(uri, _options) {
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return loadFromUrl(uri);
   }
-  const loader = await getCachedLoader();
-  return effect.Effect.runPromise(loader.loadFromUri(uri));
+  if (uri.startsWith("file://")) {
+    const filePath = uri.slice(7);
+    return loadFromFile(filePath);
+  }
+  return loadFromFile(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
-    }
-  };
+  return parseAndValidateConfig(content);
 }
 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);
+    return loadConfig(envConfigPath);
   }
   if (options.configUrl) {
-    return loadConfig(options.configUrl, loadOptions);
+    return loadConfig(options.configUrl);
   }
   if (options.configPath) {
-    return loadConfig(options.configPath, loadOptions);
+    return loadConfig(options.configPath);
   }
   const { existsSync } = await import('fs');
   const { join } = await import('path');
   const defaultPath = join(process.cwd(), "instrumentation.yaml");
   if (existsSync(defaultPath)) {
-    return loadConfig(defaultPath, loadOptions);
+    return loadConfig(defaultPath);
   }
-  return getDefaultConfig();
+  return defaultConfig;
 }
 
 // src/integrations/effect/effect-tracer.ts
+var SDK_NAME = "@effect/opentelemetry";
+var ATTR_TELEMETRY_EXPORTER_MODE = "telemetry.exporter.mode";
 function createEffectInstrumentation(options = {}) {
   return effect.Layer.unwrapEffect(
     effect.Effect.gen(function* () {
@@ -499,106 +536,277 @@ function createEffectInstrumentation(options = {}) {
           message: error instanceof Error ? error.message : String(error)
         })
       });
+      const effectEnabled = process.env.OTEL_EFFECT_ENABLED !== "false" && (config.effect?.enabled ?? true);
+      if (!effectEnabled) {
+        logger.log("@atrim/instrumentation/effect: Effect tracing disabled via config");
+        return effect.Layer.empty;
+      }
       yield* effect.Effect.sync(() => {
         const loggingLevel = config.instrumentation.logging || "on";
         logger.setLevel(loggingLevel);
       });
       yield* effect.Effect.sync(() => initializePatternMatcher(config));
-      const otlpEndpoint = options.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
       const serviceName = options.serviceName || process.env.OTEL_SERVICE_NAME || "effect-service";
       const serviceVersion = options.serviceVersion || process.env.npm_package_version || "1.0.0";
-      const autoExtractMetadata = options.autoExtractMetadata ?? config.effect?.auto_extract_metadata ?? true;
-      const continueExistingTraces = options.continueExistingTraces ?? true;
-      logger.log("\u{1F50D} Effect OpenTelemetry instrumentation");
-      logger.log(`   \u{1F4E1} Endpoint: ${otlpEndpoint}`);
-      logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
-      logger.log(`   \u2705 Auto metadata extraction: ${autoExtractMetadata}`);
-      logger.log(`   \u2705 Continue existing traces: ${continueExistingTraces}`);
-      const otlpLayer = Otlp__namespace.layer({
-        baseUrl: otlpEndpoint,
-        resource: {
-          serviceName,
-          serviceVersion,
-          attributes: {
-            "platform.component": "effect",
-            "effect.auto_metadata": autoExtractMetadata,
-            "effect.context_propagation": continueExistingTraces
-          }
-        },
-        // Bridge Effect context to OpenTelemetry global context
-        // This is essential for context propagation to work properly
-        tracerContext: (f, span) => {
-          if (span._tag !== "Span") {
-            return f();
+      const exporterMode = options.exporterMode ?? config.effect?.exporter ?? "unified";
+      const resourceAttributes = {
+        "platform.component": "effect",
+        [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: semanticConventions.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+        [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+        [ATTR_TELEMETRY_EXPORTER_MODE]: exporterMode
+      };
+      if (exporterMode === "standalone") {
+        const otlpEndpoint = options.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+        logger.log("Effect OpenTelemetry instrumentation (standalone)");
+        logger.log(`  Service: ${serviceName}`);
+        logger.log(`  Endpoint: ${otlpEndpoint}`);
+        logger.log("  WARNING: Standalone mode bypasses Node SDK filtering");
+        return Otlp__namespace.layer({
+          baseUrl: otlpEndpoint,
+          resource: {
+            serviceName,
+            serviceVersion,
+            attributes: resourceAttributes
+          },
+          // Bridge Effect context to OpenTelemetry global context
+          tracerContext: (f, span) => {
+            if (span._tag !== "Span") {
+              return f();
+            }
+            const spanContext = {
+              traceId: span.traceId,
+              spanId: span.spanId,
+              traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+            };
+            const otelSpan = api.trace.wrapSpanContext(spanContext);
+            return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
           }
-          const spanContext = {
-            traceId: span.traceId,
-            spanId: span.spanId,
-            traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
-          };
-          const otelSpan = api.trace.wrapSpanContext(spanContext);
-          return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
-        }
-      }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
-      if (autoExtractMetadata) {
-        return otlpLayer;
+        }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+      } else {
+        logger.log("Effect OpenTelemetry instrumentation (unified)");
+        logger.log(`  Service: ${serviceName}`);
+        logger.log("  Using global TracerProvider for span export");
+        return Tracer__namespace.layerGlobal.pipe(
+          effect.Layer.provide(
+            Resource__namespace.layer({
+              serviceName,
+              serviceVersion,
+              attributes: resourceAttributes
+            })
+          )
+        );
       }
-      return otlpLayer;
     })
   ).pipe(effect.Layer.orDie);
 }
 var EffectInstrumentationLive = effect.Effect.sync(() => {
-  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
   const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
   const serviceVersion = process.env.npm_package_version || "1.0.0";
   logger.minimal(`@atrim/instrumentation/effect: Effect tracing enabled (${serviceName})`);
-  logger.log("\u{1F50D} Effect OpenTelemetry tracer");
-  logger.log(`   \u{1F4E1} Endpoint: ${endpoint}`);
-  logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
-  return Otlp__namespace.layer({
-    baseUrl: endpoint,
-    resource: {
-      serviceName,
-      serviceVersion,
-      attributes: {
-        "platform.component": "effect"
-      }
-    },
-    // CRITICAL: Bridge Effect context to OpenTelemetry global context
-    // This allows NodeSDK auto-instrumentation to see Effect spans as parent spans
-    tracerContext: (f, span) => {
-      if (span._tag !== "Span") {
-        return f();
-      }
-      const spanContext = {
-        traceId: span.traceId,
-        spanId: span.spanId,
-        traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
-      };
-      const otelSpan = api.trace.wrapSpanContext(spanContext);
-      return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
-    }
-  }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+  logger.log("Effect OpenTelemetry tracer (unified)");
+  logger.log(`  Service: ${serviceName}`);
+  return Tracer__namespace.layerGlobal.pipe(
+    effect.Layer.provide(
+      Resource__namespace.layer({
+        serviceName,
+        serviceVersion,
+        attributes: {
+          "platform.component": "effect",
+          [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: semanticConventions.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+          [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+          [ATTR_TELEMETRY_EXPORTER_MODE]: "unified"
+        }
+      })
+    )
+  );
 }).pipe(effect.Layer.unwrapEffect);
-
-// src/integrations/effect/effect-helpers.ts
-function annotateUser(_userId, _email) {
+var withOtelParentSpan = (effect) => {
+  const currentSpan = api.trace.getSpan(api.context.active());
+  if (currentSpan) {
+    const spanContext = currentSpan.spanContext();
+    return Tracer__namespace.withSpanContext(spanContext)(effect);
+  }
+  return effect;
+};
+var getCurrentOtelSpanContext = effect.Effect.sync(() => {
+  const currentSpan = api.trace.getSpan(api.context.active());
+  return currentSpan?.spanContext();
+});
+var getOtelParentSpan = effect.Effect.sync(
+  () => {
+    const currentSpan = api.trace.getSpan(api.context.active());
+    if (!currentSpan) {
+      return void 0;
+    }
+    const spanContext = currentSpan.spanContext();
+    return Tracer__namespace.makeExternalSpan({
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId,
+      traceFlags: spanContext.traceFlags,
+      traceState: spanContext.traceState?.serialize()
+    });
+  }
+);
+var runWithOtelContext = (effect$1) => {
+  return effect.Effect.flatMap(
+    Tracer__namespace.currentOtelSpan,
+    (otelSpan) => effect.Effect.async((resume) => {
+      api.context.with(api.trace.setSpan(api.context.active(), otelSpan), () => {
+        effect.Effect.runPromiseExit(effect$1).then((exit) => {
+          if (exit._tag === "Success") {
+            resume(effect.Effect.succeed(exit.value));
+          } else {
+            resume(effect.Effect.failCause(exit.cause));
+          }
+        });
+      });
+    })
+  ).pipe(
+    // If no OTel span is available, just run the effect normally
+    effect.Effect.catchAll(() => effect$1)
+  );
+};
+var withFullOtelBridging = (effect) => {
+  return withOtelParentSpan(effect);
+};
+function annotateUser(userId, email, username) {
+  const attributes = {
+    "user.id": userId
+  };
+  if (email) attributes["user.email"] = email;
+  if (username) attributes["user.name"] = username;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateDataSize(_bytes, _count) {
+function annotateDataSize(bytes, items, compressionRatio) {
+  const attributes = {
+    "data.size.bytes": bytes,
+    "data.size.items": items
+  };
+  if (compressionRatio !== void 0) {
+    attributes["data.compression.ratio"] = compressionRatio;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateBatch(_size, _batchSize) {
+function annotateBatch(totalItems, batchSize, successCount, failureCount) {
+  const attributes = {
+    "batch.size": batchSize,
+    "batch.total_items": totalItems,
+    "batch.count": Math.ceil(totalItems / batchSize)
+  };
+  if (successCount !== void 0) {
+    attributes["batch.success_count"] = successCount;
+  }
+  if (failureCount !== void 0) {
+    attributes["batch.failure_count"] = failureCount;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateLLM(_model, _operation, _inputTokens, _outputTokens) {
+function annotateLLM(model, provider, tokens) {
+  const attributes = {
+    "llm.model": model,
+    "llm.provider": provider
+  };
+  if (tokens) {
+    if (tokens.prompt !== void 0) attributes["llm.tokens.prompt"] = tokens.prompt;
+    if (tokens.completion !== void 0) attributes["llm.tokens.completion"] = tokens.completion;
+    if (tokens.total !== void 0) attributes["llm.tokens.total"] = tokens.total;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateQuery(_query, _database) {
+function annotateQuery(query, duration, rowCount, database) {
+  const attributes = {
+    "db.statement": query.length > 1e3 ? query.substring(0, 1e3) + "..." : query
+  };
+  if (duration !== void 0) attributes["db.duration.ms"] = duration;
+  if (rowCount !== void 0) attributes["db.row_count"] = rowCount;
+  if (database) attributes["db.name"] = database;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateHttpRequest(_method, _url, _statusCode) {
+function annotateHttpRequest(method, url, statusCode, contentLength) {
+  const attributes = {
+    "http.method": method,
+    "http.url": url
+  };
+  if (statusCode !== void 0) attributes["http.status_code"] = statusCode;
+  if (contentLength !== void 0) attributes["http.response.content_length"] = contentLength;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateError(_error, _context) {
+function annotateError(error, recoverable, errorType) {
+  const errorMessage = typeof error === "string" ? error : error.message;
+  const errorStack = typeof error === "string" ? void 0 : error.stack;
+  const attributes = {
+    "error.message": errorMessage,
+    "error.recoverable": recoverable
+  };
+  if (errorType) attributes["error.type"] = errorType;
+  if (errorStack) attributes["error.stack"] = errorStack;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotatePriority(_priority) {
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateCache(_operation, _hit) {
+function annotateCache(hit, key, ttl) {
+  const attributes = {
+    "cache.hit": hit,
+    "cache.key": key
+  };
+  if (ttl !== void 0) attributes["cache.ttl.seconds"] = ttl;
+  return effect.Effect.annotateCurrentSpan(attributes);
+}
+function extractEffectMetadata() {
+  return effect.Effect.gen(function* () {
+    const metadata = {};
+    const currentFiber = effect.Fiber.getCurrentFiber();
+    if (effect.Option.isSome(currentFiber)) {
+      const fiber = currentFiber.value;
+      const fiberId = fiber.id();
+      metadata["effect.fiber.id"] = effect.FiberId.threadName(fiberId);
+      const status = yield* effect.Fiber.status(fiber);
+      if (status._tag) {
+        metadata["effect.fiber.status"] = status._tag;
+      }
+    }
+    const parentSpanResult = yield* effect.Effect.currentSpan.pipe(
+      effect.Effect.option
+      // Convert NoSuchElementException to Option
+    );
+    if (effect.Option.isSome(parentSpanResult)) {
+      const parentSpan = parentSpanResult.value;
+      metadata["effect.operation.nested"] = true;
+      metadata["effect.operation.root"] = false;
+      if (parentSpan.spanId) {
+        metadata["effect.parent.span.id"] = parentSpan.spanId;
+      }
+      if (parentSpan.name) {
+        metadata["effect.parent.span.name"] = parentSpan.name;
+      }
+      if (parentSpan.traceId) {
+        metadata["effect.parent.trace.id"] = parentSpan.traceId;
+      }
+    } else {
+      metadata["effect.operation.nested"] = false;
+      metadata["effect.operation.root"] = true;
+    }
+    return metadata;
+  });
+}
+function autoEnrichSpan() {
+  return effect.Effect.gen(function* () {
+    const metadata = yield* extractEffectMetadata();
+    yield* effect.Effect.annotateCurrentSpan(metadata);
+  });
+}
+function withAutoEnrichedSpan(spanName, options) {
+  return (self) => {
+    return effect.Effect.gen(function* () {
+      yield* autoEnrichSpan();
+      return yield* self;
+    }).pipe(effect.Effect.withSpan(spanName, options));
+  };
 }
 var createLogicalParentLink = (parentSpan, useSpanLinks) => {
   if (!useSpanLinks) {
@@ -737,8 +945,16 @@ exports.annotatePriority = annotatePriority;
 exports.annotateQuery = annotateQuery;
 exports.annotateSpawnedTasks = annotateSpawnedTasks;
 exports.annotateUser = annotateUser;
+exports.autoEnrichSpan = autoEnrichSpan;
 exports.createEffectInstrumentation = createEffectInstrumentation;
+exports.extractEffectMetadata = extractEffectMetadata;
+exports.getCurrentOtelSpanContext = getCurrentOtelSpanContext;
+exports.getOtelParentSpan = getOtelParentSpan;
 exports.runIsolated = runIsolated;
+exports.runWithOtelContext = runWithOtelContext;
 exports.runWithSpan = runWithSpan;
+exports.withAutoEnrichedSpan = withAutoEnrichedSpan;
+exports.withFullOtelBridging = withFullOtelBridging;
+exports.withOtelParentSpan = withOtelParentSpan;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map