@atrim/instrument-node 0.5.0-14fdea7-20260108232035 → 0.5.0-14fdea7-20260109020503

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

@@ -0,0 +1,948 @@
+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';
+
+// src/integrations/effect/effect-tracer.ts
+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);
+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 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(),
+  // 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(),
+  // 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 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({
+    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({
+    // 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-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;
+  }
+});
+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
+  // 5 seconds
+};
+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
+    })
+  });
+});
+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`
+      })
+    );
+  }
+  return yield* parseYamlContent(content, uri);
+});
+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"
+      })
+    );
+    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
+        });
+      })
+    );
+    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 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
+        })
+      });
+    })
+  });
+});
+Layer.effect(ConfigLoader, makeConfigLoader);
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField(this, "ignorePatterns", []);
+    __publicField(this, "instrumentPatterns", []);
+    __publicField(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
+    };
+  }
+};
+function initializePatternMatcher(config) {
+  new PatternMatcher(config);
+}
+var Logger = class {
+  constructor() {
+    __publicField(this, "level", "on");
+    __publicField(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();
+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}`);
+  }
+  const content = await response.text();
+  return parseAndValidateConfig(content);
+}
+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) {
+  return parseAndValidateConfig(content);
+}
+async function loadConfigWithOptions(options = {}) {
+  if (options.config) {
+    return loadConfigFromInline(options.config);
+  }
+  const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
+  if (envConfigPath) {
+    return loadConfig(envConfigPath);
+  }
+  if (options.configUrl) {
+    return loadConfig(options.configUrl);
+  }
+  if (options.configPath) {
+    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);
+  }
+  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 Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const config = yield* Effect.tryPromise({
+        try: () => loadConfigWithOptions(options),
+        catch: (error) => ({
+          _tag: "ConfigError",
+          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 serviceName = options.serviceName || process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = options.serviceVersion || process.env.npm_package_version || "1.0.0";
+      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);
+          }
+        }).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
+            })
+          )
+        );
+      }
+    })
+  ).pipe(Layer.orDie);
+}
+var EffectInstrumentationLive = Effect.sync(() => {
+  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("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 = {
+    "user.id": userId
+  };
+  if (email) attributes["user.email"] = email;
+  if (username) attributes["user.name"] = username;
+  return Effect.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+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.annotateCurrentSpan(attributes);
+}
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return Effect.annotateCurrentSpan(attributes);
+}
+function annotateCache(hit, key, ttl) {
+  const attributes = {
+    "cache.hit": hit,
+    "cache.key": key
+  };
+  if (ttl !== void 0) attributes["cache.ttl.seconds"] = ttl;
+  return Effect.annotateCurrentSpan(attributes);
+}
+function extractEffectMetadata() {
+  return Effect.gen(function* () {
+    const metadata = {};
+    const currentFiber = Fiber.getCurrentFiber();
+    if (Option.isSome(currentFiber)) {
+      const fiber = currentFiber.value;
+      const fiberId = fiber.id();
+      metadata["effect.fiber.id"] = FiberId.threadName(fiberId);
+      const status = yield* Fiber.status(fiber);
+      if (status._tag) {
+        metadata["effect.fiber.status"] = status._tag;
+      }
+    }
+    const parentSpanResult = yield* Effect.currentSpan.pipe(
+      Effect.option
+      // Convert NoSuchElementException to Option
+    );
+    if (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.gen(function* () {
+    const metadata = yield* extractEffectMetadata();
+    yield* Effect.annotateCurrentSpan(metadata);
+  });
+}
+function withAutoEnrichedSpan(spanName, options) {
+  return (self) => {
+    return Effect.gen(function* () {
+      yield* autoEnrichSpan();
+      return yield* self;
+    }).pipe(Effect.withSpan(spanName, options));
+  };
+}
+var createLogicalParentLink = (parentSpan, useSpanLinks) => {
+  if (!useSpanLinks) {
+    return [];
+  }
+  return [
+    {
+      _tag: "SpanLink",
+      span: parentSpan,
+      attributes: {
+        "link.type": "logical_parent",
+        "atrim.relationship": "spawned_by",
+        description: "Logical parent (isolated to prevent context leakage)"
+      }
+    }
+  ];
+};
+var createLogicalParentAttributes = (parentSpan, useAttributes, category, useSpanLinks, customAttributes) => {
+  if (!useAttributes) {
+    return customAttributes;
+  }
+  return {
+    // Logical parent tracking (works in ALL tools)
+    "atrim.logical_parent.span_id": parentSpan.spanId,
+    "atrim.logical_parent.trace_id": parentSpan.traceId,
+    "atrim.logical_parent.name": parentSpan._tag === "Span" ? parentSpan.name : "external",
+    // Categorization and metadata
+    "atrim.fiberset.isolated": true,
+    "atrim.span.category": category,
+    "atrim.has_logical_parent": true,
+    "atrim.isolation.method": useSpanLinks ? "hybrid" : "attributes_only",
+    // User-provided attributes
+    ...customAttributes
+  };
+};
+var runIsolated = (set, effect, name, options) => {
+  const {
+    createRoot = true,
+    captureLogicalParent = true,
+    useSpanLinks = true,
+    useAttributes = true,
+    propagateInterruption,
+    attributes = {},
+    category = "background_task"
+  } = options ?? {};
+  if (!createRoot && !captureLogicalParent) {
+    return FiberSet$1.run(set, effect, { propagateInterruption });
+  }
+  return Effect.gen(function* () {
+    const maybeParent = yield* Effect.serviceOption(Tracer$1.ParentSpan);
+    if (maybeParent._tag === "None" || !captureLogicalParent) {
+      const isolated2 = effect.pipe(
+        Effect.withSpan(name, {
+          root: createRoot,
+          attributes: {
+            "atrim.fiberset.isolated": createRoot,
+            "atrim.span.category": category,
+            "atrim.has_logical_parent": false,
+            ...attributes
+          }
+        })
+      );
+      return yield* FiberSet$1.run(set, isolated2, { propagateInterruption });
+    }
+    const parent = maybeParent.value;
+    const links = createLogicalParentLink(parent, useSpanLinks);
+    const spanAttributes = createLogicalParentAttributes(
+      parent,
+      useAttributes,
+      category,
+      useSpanLinks,
+      attributes
+    );
+    const isolated = effect.pipe(
+      Effect.withSpan(name, {
+        root: createRoot,
+        links: links.length > 0 ? links : void 0,
+        attributes: spanAttributes
+      })
+    );
+    return yield* FiberSet$1.run(set, isolated, { propagateInterruption });
+  });
+};
+var runWithSpan = (set, name, effect, options) => {
+  return runIsolated(set, effect, name, {
+    createRoot: true,
+    captureLogicalParent: true,
+    useSpanLinks: true,
+    useAttributes: true,
+    ...options
+  });
+};
+var annotateSpawnedTasks = (tasks) => {
+  return Effect.annotateCurrentSpan({
+    "atrim.fiberset.spawned_count": tasks.length,
+    "atrim.fiberset.task_names": tasks.map((t) => t.name).join(","),
+    "atrim.has_background_tasks": true,
+    "atrim.spawned_tasks": JSON.stringify(
+      tasks.map((t) => ({
+        name: t.name,
+        ...t.spanId && { span_id: t.spanId },
+        ...t.category && { category: t.category }
+      }))
+    )
+  });
+};
+var FiberSet = {
+  // Re-export all original FiberSet functions
+  make: FiberSet$1.make,
+  add: FiberSet$1.add,
+  unsafeAdd: FiberSet$1.unsafeAdd,
+  run: FiberSet$1.run,
+  clear: FiberSet$1.clear,
+  join: FiberSet$1.join,
+  awaitEmpty: FiberSet$1.awaitEmpty,
+  size: FiberSet$1.size,
+  runtime: FiberSet$1.runtime,
+  runtimePromise: FiberSet$1.runtimePromise,
+  makeRuntime: FiberSet$1.makeRuntime,
+  makeRuntimePromise: FiberSet$1.makeRuntimePromise,
+  isFiberSet: FiberSet$1.isFiberSet,
+  // Add our isolation helpers
+  runIsolated,
+  runWithSpan
+};
+
+export { EffectInstrumentationLive, FiberSet, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, runIsolated, runWithSpan, withAutoEnrichedSpan };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map