@atrim/instrument-node 0.5.2-dev.ac2fbfe.20251221205322 → 0.7.0-14fdea7-20260108225522

package/target/dist/integrations/effect/index.d.cts

@@ -1,4 +1,5 @@
 import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
+import * as Tracer from '@effect/opentelemetry/Tracer';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -6,9 +7,10 @@ import * as effect_Scope from 'effect/Scope';
 import { RuntimeFiber } from 'effect/Fiber';
 
 /**
- * Node.js configuration loader using Effect Platform
+ * Node.js configuration loader
  *
- * Provides FileSystem and HttpClient layers for the core ConfigLoader service
+ * Provides configuration loading using native Node.js APIs (fs, fetch)
+ * This module doesn't require Effect Platform, making it work without Effect installed.
  */
 
 /**
@@ -46,17 +48,12 @@ interface ConfigLoaderOptions {
  */
 interface EffectInstrumentationOptions extends ConfigLoaderOptions {
     /**
-     * OTLP endpoint URL
-     * @default process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318'
-     */
-    otlpEndpoint?: string;
-    /**
-     * Service name
+     * Service name for Effect spans
      * @default process.env.OTEL_SERVICE_NAME || 'effect-service'
      */
     serviceName?: string;
     /**
-     * Service version
+     * Service version for Effect spans
      * @default process.env.npm_package_version || '1.0.0'
      */
     serviceVersion?: string;
@@ -66,20 +63,17 @@ interface EffectInstrumentationOptions extends ConfigLoaderOptions {
      */
     autoExtractMetadata?: boolean;
     /**
-     * Whether to continue existing traces from NodeSDK auto-instrumentation
-     *
-     * When true (default):
-     * - Effect spans become children of existing NodeSDK spans
-     * - Example: HTTP request span → Effect business logic span
-     * - Uses OpenTelemetry Context API for propagation
-     *
-     * When false:
-     * - Effect operations always create new root spans
-     * - Not recommended unless you have specific requirements
-     *
-     * @default true
+     * OTLP endpoint URL (only used when exporter mode is 'standalone')
+     * @default process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318'
+     */
+    otlpEndpoint?: string;
+    /**
+     * Exporter mode:
+     * - 'unified': Use global TracerProvider from Node SDK (recommended, enables filtering)
+     * - 'standalone': Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+     * @default 'unified'
      */
-    continueExistingTraces?: boolean;
+    exporterMode?: 'unified' | 'standalone';
 }
 /**
  * Create Effect instrumentation layer with custom options
@@ -118,11 +112,12 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  *
  * Uses the global OpenTelemetry tracer provider that was set up by
  * initializeInstrumentation(). This ensures all traces (Express, Effect, etc.)
- * go to the same OTLP endpoint.
+ * go through the same TracerProvider and PatternSpanProcessor.
  *
  * Context Propagation:
  * - Automatically continues traces from NodeSDK auto-instrumentation
  * - Effect spans become children of HTTP request spans
+ * - Respects http.ignore_incoming_paths and other filtering patterns
  * - No configuration needed
  *
  * @example
@@ -138,7 +133,7 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  * )
  * ```
  */
-declare const EffectInstrumentationLive: Layer.Layer<never, never, never>;
+declare const EffectInstrumentationLive: Layer.Layer<Tracer.OtelTracer, never, never>;
 
 /**
  * Effect-specific span annotation helpers

package/target/dist/integrations/effect/index.d.ts

@@ -1,4 +1,5 @@
 import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
+import * as Tracer from '@effect/opentelemetry/Tracer';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -6,9 +7,10 @@ import * as effect_Scope from 'effect/Scope';
 import { RuntimeFiber } from 'effect/Fiber';
 
 /**
- * Node.js configuration loader using Effect Platform
+ * Node.js configuration loader
  *
- * Provides FileSystem and HttpClient layers for the core ConfigLoader service
+ * Provides configuration loading using native Node.js APIs (fs, fetch)
+ * This module doesn't require Effect Platform, making it work without Effect installed.
  */
 
 /**
@@ -46,17 +48,12 @@ interface ConfigLoaderOptions {
  */
 interface EffectInstrumentationOptions extends ConfigLoaderOptions {
     /**
-     * OTLP endpoint URL
-     * @default process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318'
-     */
-    otlpEndpoint?: string;
-    /**
-     * Service name
+     * Service name for Effect spans
      * @default process.env.OTEL_SERVICE_NAME || 'effect-service'
      */
     serviceName?: string;
     /**
-     * Service version
+     * Service version for Effect spans
      * @default process.env.npm_package_version || '1.0.0'
      */
     serviceVersion?: string;
@@ -66,20 +63,17 @@ interface EffectInstrumentationOptions extends ConfigLoaderOptions {
      */
     autoExtractMetadata?: boolean;
     /**
-     * Whether to continue existing traces from NodeSDK auto-instrumentation
-     *
-     * When true (default):
-     * - Effect spans become children of existing NodeSDK spans
-     * - Example: HTTP request span → Effect business logic span
-     * - Uses OpenTelemetry Context API for propagation
-     *
-     * When false:
-     * - Effect operations always create new root spans
-     * - Not recommended unless you have specific requirements
-     *
-     * @default true
+     * OTLP endpoint URL (only used when exporter mode is 'standalone')
+     * @default process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318'
+     */
+    otlpEndpoint?: string;
+    /**
+     * Exporter mode:
+     * - 'unified': Use global TracerProvider from Node SDK (recommended, enables filtering)
+     * - 'standalone': Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+     * @default 'unified'
      */
-    continueExistingTraces?: boolean;
+    exporterMode?: 'unified' | 'standalone';
 }
 /**
  * Create Effect instrumentation layer with custom options
@@ -118,11 +112,12 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  *
  * Uses the global OpenTelemetry tracer provider that was set up by
  * initializeInstrumentation(). This ensures all traces (Express, Effect, etc.)
- * go to the same OTLP endpoint.
+ * go through the same TracerProvider and PatternSpanProcessor.
  *
  * Context Propagation:
  * - Automatically continues traces from NodeSDK auto-instrumentation
  * - Effect spans become children of HTTP request spans
+ * - Respects http.ignore_incoming_paths and other filtering patterns
  * - No configuration needed
  *
  * @example
@@ -138,7 +133,7 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  * )
  * ```
  */
-declare const EffectInstrumentationLive: Layer.Layer<never, never, never>;
+declare const EffectInstrumentationLive: Layer.Layer<Tracer.OtelTracer, never, never>;
 
 /**
  * Effect-specific span annotation helpers

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

@@ -1,20 +1,17 @@
-import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, Fiber, Option, FiberId, Tracer } from 'effect';
+import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, Fiber, Option, FiberId, Tracer as Tracer$1 } from 'effect';
+import * as Tracer from '@effect/opentelemetry/Tracer';
+import * as Resource from '@effect/opentelemetry/Resource';
 import * as Otlp from '@effect/opentelemetry/Otlp';
 import { FetchHttpClient } from '@effect/platform';
 import { TraceFlags, trace, context } from '@opentelemetry/api';
+import { TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_LANGUAGE } from '@opentelemetry/semantic-conventions';
 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 { NodeContext } from '@effect/platform-node';
 
 // src/integrations/effect/effect-tracer.ts
-
-// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.38.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
-var ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
-var TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
-var ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
 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;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -45,6 +42,69 @@ var AutoIsolationConfigSchema = z.object({
     add_metadata: z.boolean().default(true)
   }).default({})
 });
+var SpanNamingRuleSchema = z.object({
+  // Match criteria (all specified criteria must match)
+  match: z.object({
+    // Regex pattern to match file path
+    file: z.string().optional(),
+    // Regex pattern to match function name
+    function: z.string().optional(),
+    // Regex pattern to match module name
+    module: z.string().optional()
+  }),
+  // Span name template with variables:
+  // {fiber_id} - Fiber ID
+  // {function} - Function name
+  // {module} - Module name
+  // {file} - File path
+  // {line} - Line number
+  // {operator} - Effect operator (gen, all, forEach, etc.)
+  // {match:field:N} - Captured regex group from match
+  name: z.string()
+});
+var AutoInstrumentationConfigSchema = z.object({
+  // Enable/disable auto-instrumentation
+  enabled: z.boolean().default(false),
+  // Tracing granularity
+  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+  granularity: z.enum(["fiber", "operator"]).default("fiber"),
+  // Smart span naming configuration
+  span_naming: z.object({
+    // Default span name template when no rules match
+    default: z.string().default("effect.fiber.{fiber_id}"),
+    // Infer span names from source code (requires stack trace parsing)
+    // Adds ~50-100μs overhead per fiber
+    infer_from_source: z.boolean().default(true),
+    // Naming rules (first match wins)
+    rules: z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern-based filtering
+  filter: z.object({
+    // Only trace spans matching these patterns (empty = trace all)
+    include: z.array(z.string()).default([]),
+    // Never trace spans matching these patterns
+    exclude: z.array(z.string()).default([])
+  }).default({}),
+  // Performance controls
+  performance: z.object({
+    // Sample rate (0.0 - 1.0)
+    sampling_rate: z.number().min(0).max(1).default(1),
+    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+    min_duration: z.string().default("0ms"),
+    // Maximum concurrent traced fibers (0 = unlimited)
+    max_concurrent: z.number().default(0)
+  }).default({}),
+  // Automatic metadata extraction
+  metadata: z.object({
+    // Extract Effect fiber information
+    fiber_info: z.boolean().default(true),
+    // Extract source location (file:line)
+    source_location: z.boolean().default(true),
+    // Extract parent fiber information
+    parent_fiber: 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(),
@@ -66,6 +126,30 @@ var HttpFilteringConfigSchema = z.object({
     include_urls: z.array(z.string()).optional()
   }).optional()
 });
+var ExporterConfigSchema = z.object({
+  // Exporter type: 'otlp' | 'console' | 'none'
+  // - 'otlp': Export to OTLP endpoint (production)
+  // - 'console': Log spans to console (development)
+  // - 'none': No export (disable tracing)
+  type: z.enum(["otlp", "console", "none"]).default("otlp"),
+  // OTLP endpoint URL (for type: otlp)
+  // Defaults to OTEL_EXPORTER_OTLP_ENDPOINT env var or http://localhost:4318
+  endpoint: z.string().optional(),
+  // Custom headers to send with OTLP requests (for type: otlp)
+  // Useful for authentication (x-api-key, Authorization, etc.)
+  headers: z.record(z.string()).optional(),
+  // Span processor type
+  // - 'batch': Batch spans for export (production, lower overhead)
+  // - 'simple': Export immediately (development, no batching delay)
+  processor: z.enum(["batch", "simple"]).default("batch"),
+  // Batch processor settings (for processor: batch)
+  batch: z.object({
+    // Max time to wait before exporting (milliseconds)
+    scheduled_delay_millis: z.number().default(1e3),
+    // Max batch size
+    max_export_batch_size: z.number().default(100)
+  }).optional()
+});
 var InstrumentationConfigSchema = z.object({
   version: z.string(),
   instrumentation: z.object({
@@ -76,11 +160,54 @@ var InstrumentationConfigSchema = z.object({
     ignore_patterns: z.array(PatternConfigSchema)
   }),
   effect: z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: z.boolean().default(true),
+    // Exporter mode (legacy - use exporter.type instead):
+    // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
+    // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+    exporter: z.enum(["unified", "standalone"]).default("unified"),
+    // Exporter configuration (for auto-instrumentation)
+    exporter_config: ExporterConfigSchema.optional(),
     auto_extract_metadata: z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional()
+    auto_isolation: AutoIsolationConfigSchema.optional(),
+    // Auto-instrumentation: automatic tracing of all Effect fibers
+    auto_instrumentation: AutoInstrumentationConfigSchema.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
+  }
+};
+function parseAndValidateConfig(content) {
+  let parsed;
+  if (typeof content === "string") {
+    parsed = parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
 (class extends Data.TaggedError("ConfigError") {
   get message() {
     return this.reason;
@@ -258,7 +385,7 @@ var makeConfigLoader = Effect.gen(function* () {
     })
   });
 });
-var ConfigLoaderLive = Layer.effect(ConfigLoader, makeConfigLoader);
+Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField(this, "ignorePatterns", []);
@@ -406,84 +533,58 @@ var Logger = class {
   }
 };
 var logger = new Logger();
-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))
-    );
+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.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 loadConfig(uri, _options) {
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return loadFromUrl(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.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-otlp";
+var SDK_NAME = "@effect/opentelemetry";
+var ATTR_TELEMETRY_EXPORTER_MODE = "telemetry.exporter.mode";
 function createEffectInstrumentation(options = {}) {
   return Layer.unwrapEffect(
     Effect.gen(function* () {
@@ -494,90 +595,89 @@ 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 Layer.empty;
+      }
       yield* Effect.sync(() => {
         const loggingLevel = config.instrumentation.logging || "on";
         logger.setLevel(loggingLevel);
       });
       yield* 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.layer({
-        baseUrl: otlpEndpoint,
-        resource: {
-          serviceName,
-          serviceVersion,
-          attributes: {
-            "platform.component": "effect",
-            "effect.auto_metadata": autoExtractMetadata,
-            "effect.context_propagation": continueExistingTraces,
-            [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
-            [ATTR_TELEMETRY_SDK_NAME]: SDK_NAME
-          }
-        },
-        // 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",
+        [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+        [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.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 ? TraceFlags.SAMPLED : TraceFlags.NONE
+            };
+            const otelSpan = trace.wrapSpanContext(spanContext);
+            return context.with(trace.setSpan(context.active(), otelSpan), f);
           }
-          const spanContext = {
-            traceId: span.traceId,
-            spanId: span.spanId,
-            traceFlags: span.sampled ? TraceFlags.SAMPLED : TraceFlags.NONE
-          };
-          const otelSpan = trace.wrapSpanContext(spanContext);
-          return context.with(trace.setSpan(context.active(), otelSpan), f);
-        }
-      }).pipe(Layer.provide(FetchHttpClient.layer));
-      if (autoExtractMetadata) {
-        return otlpLayer;
+        }).pipe(Layer.provide(FetchHttpClient.layer));
+      } else {
+        logger.log("Effect OpenTelemetry instrumentation (unified)");
+        logger.log(`  Service: ${serviceName}`);
+        logger.log("  Using global TracerProvider for span export");
+        return Tracer.layerGlobal.pipe(
+          Layer.provide(
+            Resource.layer({
+              serviceName,
+              serviceVersion,
+              attributes: resourceAttributes
+            })
+          )
+        );
       }
-      return otlpLayer;
     })
   ).pipe(Layer.orDie);
 }
 var EffectInstrumentationLive = 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.layer({
-    baseUrl: endpoint,
-    resource: {
-      serviceName,
-      serviceVersion,
-      attributes: {
-        "platform.component": "effect",
-        [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
-        [ATTR_TELEMETRY_SDK_NAME]: SDK_NAME
-      }
-    },
-    // 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 ? TraceFlags.SAMPLED : TraceFlags.NONE
-      };
-      const otelSpan = trace.wrapSpanContext(spanContext);
-      return context.with(trace.setSpan(context.active(), otelSpan), f);
-    }
-  }).pipe(Layer.provide(FetchHttpClient.layer));
+  logger.log("Effect OpenTelemetry tracer (unified)");
+  logger.log(`  Service: ${serviceName}`);
+  return Tracer.layerGlobal.pipe(
+    Layer.provide(
+      Resource.layer({
+        serviceName,
+        serviceVersion,
+        attributes: {
+          "platform.component": "effect",
+          [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+          [ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+          [ATTR_TELEMETRY_EXPORTER_MODE]: "unified"
+        }
+      })
+    )
+  );
 }).pipe(Layer.unwrapEffect);
 function annotateUser(userId, email, username) {
   const attributes = {
@@ -766,7 +866,7 @@ var runIsolated = (set, effect, name, options) => {
     return FiberSet$1.run(set, effect, { propagateInterruption });
   }
   return Effect.gen(function* () {
-    const maybeParent = yield* Effect.serviceOption(Tracer.ParentSpan);
+    const maybeParent = yield* Effect.serviceOption(Tracer$1.ParentSpan);
     if (maybeParent._tag === "None" || !captureLogicalParent) {
       const isolated2 = effect.pipe(
         Effect.withSpan(name, {