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

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

@@ -1,13 +1,20 @@
-import { Data, Effect, Cache, Layer, FiberSet as FiberSet$1, Duration, Schedule, Tracer } from 'effect';
+import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, Fiber, Option, FiberId, Tracer } from 'effect';
 import * as Otlp from '@effect/opentelemetry/Otlp';
 import { FetchHttpClient } from '@effect/platform';
 import { TraceFlags, trace, context } 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 { 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);
@@ -38,13 +45,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(),
@@ -57,238 +120,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) {
     __publicField(this, "ignorePatterns", []);
@@ -436,13 +450,89 @@ 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))
+    );
+  }
+  return cachedLoaderPromise;
+}
+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 } = await import('path');
+  const defaultPath = join(process.cwd(), "instrumentation.yaml");
+  if (existsSync(defaultPath)) {
+    return loadConfig(defaultPath, loadOptions);
+  }
+  return getDefaultConfig();
+}
 
 // src/integrations/effect/effect-tracer.ts
+var SDK_NAME = "@effect/opentelemetry-otlp";
 function createEffectInstrumentation(options = {}) {
   return Layer.unwrapEffect(
     Effect.gen(function* () {
       const config = yield* Effect.tryPromise({
-        try: () => loadConfig(options),
+        try: () => loadConfigWithOptions(options),
         catch: (error) => ({
           _tag: "ConfigError",
           message: error instanceof Error ? error.message : String(error)
@@ -471,7 +561,9 @@ function createEffectInstrumentation(options = {}) {
           attributes: {
             "platform.component": "effect",
             "effect.auto_metadata": autoExtractMetadata,
-            "effect.context_propagation": continueExistingTraces
+            "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
@@ -510,7 +602,9 @@ var EffectInstrumentationLive = Effect.sync(() => {
       serviceName,
       serviceVersion,
       attributes: {
-        "platform.component": "effect"
+        "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
@@ -529,25 +623,144 @@ var EffectInstrumentationLive = Effect.sync(() => {
     }
   }).pipe(Layer.provide(FetchHttpClient.layer));
 }).pipe(Layer.unwrapEffect);
-
-// src/integrations/effect/effect-helpers.ts
-function annotateUser(_userId, _email) {
+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, _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.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.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 annotateLLM(_model, _operation, _inputTokens, _outputTokens) {
+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 annotateQuery(_query, _database) {
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return Effect.annotateCurrentSpan(attributes);
 }
-function annotateHttpRequest(_method, _url, _statusCode) {
+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 annotateError(_error, _context) {
+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 annotatePriority(_priority) {
+function autoEnrichSpan() {
+  return Effect.gen(function* () {
+    const metadata = yield* extractEffectMetadata();
+    yield* Effect.annotateCurrentSpan(metadata);
+  });
 }
-function annotateCache(_operation, _hit) {
+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) {
@@ -674,6 +887,6 @@ var FiberSet = {
   runWithSpan
 };
 
-export { EffectInstrumentationLive, FiberSet, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, createEffectInstrumentation, 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