@atrim/instrument-node 0.5.0-c05e3a1-20251119131235 → 0.5.1

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

@@ -1,4 +1,4 @@
-import { Layer, FiberSet as FiberSet$1, Effect } from 'effect';
+import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -142,23 +142,111 @@ declare const EffectInstrumentationLive: Layer.Layer<never, never, never>;
 
 /**
  * Effect-specific span annotation helpers
+ *
+ * Provides reusable helper functions for adding common span attributes.
+ * These helpers follow OpenTelemetry semantic conventions and platform patterns.
+ *
+ * Usage:
+ * ```typescript
+ * Effect.gen(function* () {
+ *   yield* annotateUser(userId, email)
+ *   yield* annotateBatch(items.length, 5)
+ *   const results = yield* storage.writeBatch(items)
+ *   yield* annotateBatch(items.length, 5, results.success, results.failures)
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ * ```
  */
-declare function annotateUser(_userId: string, _email?: string): void;
-declare function annotateDataSize(_bytes: number, _count: number): void;
-declare function annotateBatch(_size: number, _batchSize: number): void;
-declare function annotateLLM(_model: string, _operation: string, _inputTokens: number, _outputTokens: number): void;
-declare function annotateQuery(_query: string, _database: string): void;
-declare function annotateHttpRequest(_method: string, _url: string, _statusCode: number): void;
-declare function annotateError(_error: Error, _context?: Record<string, string | number | boolean>): void;
-declare function annotatePriority(_priority: string): void;
-declare function annotateCache(_operation: string, _hit: boolean): void;
+
+/**
+ * Annotate span with user context
+ *
+ * @param userId - User identifier
+ * @param email - Optional user email
+ * @param username - Optional username
+ */
+declare function annotateUser(userId: string, email?: string, username?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with data size metrics
+ *
+ * @param bytes - Total bytes processed
+ * @param items - Number of items
+ * @param compressionRatio - Optional compression ratio
+ */
+declare function annotateDataSize(bytes: number, items: number, compressionRatio?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with batch operation metadata
+ *
+ * @param totalItems - Total number of items in batch
+ * @param batchSize - Size of each batch
+ * @param successCount - Optional number of successful items
+ * @param failureCount - Optional number of failed items
+ */
+declare function annotateBatch(totalItems: number, batchSize: number, successCount?: number, failureCount?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with LLM operation metadata
+ *
+ * @param model - Model name (e.g., 'gpt-4', 'claude-3-opus')
+ * @param provider - LLM provider (e.g., 'openai', 'anthropic')
+ * @param tokens - Optional token usage information
+ */
+declare function annotateLLM(model: string, provider: string, tokens?: {
+    prompt?: number;
+    completion?: number;
+    total?: number;
+}): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with database query metadata
+ *
+ * @param query - SQL query or query description
+ * @param duration - Optional query duration in milliseconds
+ * @param rowCount - Optional number of rows returned/affected
+ * @param database - Optional database name
+ */
+declare function annotateQuery(query: string, duration?: number, rowCount?: number, database?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with HTTP request metadata
+ *
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param url - Request URL
+ * @param statusCode - Optional HTTP status code
+ * @param contentLength - Optional response content length
+ */
+declare function annotateHttpRequest(method: string, url: string, statusCode?: number, contentLength?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with error context
+ *
+ * @param error - Error object or message
+ * @param recoverable - Whether the error is recoverable
+ * @param errorType - Optional error type/category
+ */
+declare function annotateError(error: Error | string, recoverable: boolean, errorType?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with operation priority
+ *
+ * @param priority - Priority level (high, medium, low)
+ * @param reason - Optional reason for priority level
+ */
+declare function annotatePriority(priority: 'high' | 'medium' | 'low', reason?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with cache operation metadata
+ *
+ * @param hit - Whether the cache was hit
+ * @param key - Cache key
+ * @param ttl - Optional time-to-live in seconds
+ */
+declare function annotateCache(hit: boolean, key: string, ttl?: number): Effect.Effect<void, never, never>;
 
 /**
  * Effect metadata extraction
  *
  * Automatically extracts metadata from Effect fibers and adds them as span attributes.
  * This provides valuable context about the Effect execution environment.
+ *
+ * Uses Effect's public APIs:
+ * - Fiber.getCurrentFiber() - Get current fiber information
+ * - Effect.currentSpan - Detect parent spans and nesting
  */
+
 /**
  * Metadata extracted from Effect fibers
  */
@@ -166,8 +254,95 @@ interface EffectMetadata {
     'effect.fiber.id'?: string;
     'effect.fiber.status'?: string;
     'effect.operation.root'?: boolean;
-    'effect.operation.interrupted'?: boolean;
+    'effect.operation.nested'?: boolean;
+    'effect.parent.span.id'?: string;
+    'effect.parent.span.name'?: string;
+    'effect.parent.trace.id'?: string;
 }
+/**
+ * Extract Effect-native metadata from current execution context
+ *
+ * Uses Effect's native APIs:
+ * - Fiber.getCurrentFiber() - Get current fiber information
+ * - Effect.currentSpan - Detect parent spans and nesting
+ *
+ * @returns Effect that yields extracted metadata
+ */
+declare function extractEffectMetadata(): Effect.Effect<EffectMetadata>;
+
+/**
+ * Effect Auto-Enrichment Utilities
+ *
+ * Provides utilities for automatically extracting and enriching spans with Effect-native metadata.
+ *
+ * Usage:
+ * ```typescript
+ * import { autoEnrichSpan, withAutoEnrichedSpan } from '@atrim/instrument-node/effect'
+ *
+ * // Option 1: Manual enrichment
+ * Effect.gen(function* () {
+ *   yield* autoEnrichSpan()  // Auto-add Effect metadata
+ *   yield* annotateBatch(items.length, 10)  // Add custom attributes
+ *   const result = yield* storage.writeBatch(items)
+ *   return result
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ *
+ * // Option 2: Automatic enrichment wrapper
+ * const instrumented = withAutoEnrichedSpan('storage.writeBatch')(
+ *   Effect.gen(function* () {
+ *     yield* annotateBatch(items.length, 10)
+ *     return yield* storage.writeBatch(items)
+ *   })
+ * )
+ * ```
+ */
+
+/**
+ * Auto-enrich the current span with Effect metadata
+ *
+ * This function should be called within an Effect.withSpan() context.
+ * It extracts Effect metadata (fiber ID, status, parent span info)
+ * and adds it as span attributes.
+ *
+ * Best practice: Call this at the start of your instrumented Effect:
+ *
+ * ```typescript
+ * Effect.gen(function* () {
+ *   yield* autoEnrichSpan()  // Auto-add metadata
+ *   yield* annotateBatch(items.length, 10)  // Add custom attributes
+ *   const result = yield* storage.writeBatch(items)
+ *   return result
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ * ```
+ *
+ * @returns Effect that annotates the current span with Effect metadata
+ */
+declare function autoEnrichSpan(): Effect.Effect<void>;
+/**
+ * Create a wrapper that combines Effect.withSpan with automatic enrichment
+ *
+ * This is a convenience function that wraps an Effect with both:
+ * 1. A span (via Effect.withSpan)
+ * 2. Automatic metadata extraction (via autoEnrichSpan)
+ *
+ * Usage:
+ * ```typescript
+ * const instrumented = withAutoEnrichedSpan('storage.writeBatch')(
+ *   Effect.gen(function* () {
+ *     yield* annotateBatch(items.length, 10)
+ *     return yield* storage.writeBatch(items)
+ *   })
+ * )
+ * ```
+ *
+ * @param spanName - The name of the span
+ * @param options - Optional span options
+ * @returns Function that wraps an Effect with an auto-enriched span
+ */
+declare function withAutoEnrichedSpan<A, E, R>(spanName: string, options?: {
+    readonly attributes?: Record<string, unknown>;
+    readonly kind?: 'client' | 'server' | 'producer' | 'consumer' | 'internal';
+}): (self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 
 /**
  * Options for span isolation when running effects in FiberSet
@@ -356,4 +531,4 @@ declare const FiberSet: {
     }) => Effect.Effect<RuntimeFiber<A, E>, never, R>;
 };
 
-export { EffectInstrumentationLive, type EffectMetadata, FiberSet, type IsolationOptions, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, createEffectInstrumentation, runIsolated, runWithSpan };
+export { EffectInstrumentationLive, type EffectMetadata, FiberSet, type IsolationOptions, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, runIsolated, runWithSpan, withAutoEnrichedSpan };

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

@@ -1,4 +1,4 @@
-import { Layer, FiberSet as FiberSet$1, Effect } from 'effect';
+import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -142,23 +142,111 @@ declare const EffectInstrumentationLive: Layer.Layer<never, never, never>;
 
 /**
  * Effect-specific span annotation helpers
+ *
+ * Provides reusable helper functions for adding common span attributes.
+ * These helpers follow OpenTelemetry semantic conventions and platform patterns.
+ *
+ * Usage:
+ * ```typescript
+ * Effect.gen(function* () {
+ *   yield* annotateUser(userId, email)
+ *   yield* annotateBatch(items.length, 5)
+ *   const results = yield* storage.writeBatch(items)
+ *   yield* annotateBatch(items.length, 5, results.success, results.failures)
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ * ```
  */
-declare function annotateUser(_userId: string, _email?: string): void;
-declare function annotateDataSize(_bytes: number, _count: number): void;
-declare function annotateBatch(_size: number, _batchSize: number): void;
-declare function annotateLLM(_model: string, _operation: string, _inputTokens: number, _outputTokens: number): void;
-declare function annotateQuery(_query: string, _database: string): void;
-declare function annotateHttpRequest(_method: string, _url: string, _statusCode: number): void;
-declare function annotateError(_error: Error, _context?: Record<string, string | number | boolean>): void;
-declare function annotatePriority(_priority: string): void;
-declare function annotateCache(_operation: string, _hit: boolean): void;
+
+/**
+ * Annotate span with user context
+ *
+ * @param userId - User identifier
+ * @param email - Optional user email
+ * @param username - Optional username
+ */
+declare function annotateUser(userId: string, email?: string, username?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with data size metrics
+ *
+ * @param bytes - Total bytes processed
+ * @param items - Number of items
+ * @param compressionRatio - Optional compression ratio
+ */
+declare function annotateDataSize(bytes: number, items: number, compressionRatio?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with batch operation metadata
+ *
+ * @param totalItems - Total number of items in batch
+ * @param batchSize - Size of each batch
+ * @param successCount - Optional number of successful items
+ * @param failureCount - Optional number of failed items
+ */
+declare function annotateBatch(totalItems: number, batchSize: number, successCount?: number, failureCount?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with LLM operation metadata
+ *
+ * @param model - Model name (e.g., 'gpt-4', 'claude-3-opus')
+ * @param provider - LLM provider (e.g., 'openai', 'anthropic')
+ * @param tokens - Optional token usage information
+ */
+declare function annotateLLM(model: string, provider: string, tokens?: {
+    prompt?: number;
+    completion?: number;
+    total?: number;
+}): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with database query metadata
+ *
+ * @param query - SQL query or query description
+ * @param duration - Optional query duration in milliseconds
+ * @param rowCount - Optional number of rows returned/affected
+ * @param database - Optional database name
+ */
+declare function annotateQuery(query: string, duration?: number, rowCount?: number, database?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with HTTP request metadata
+ *
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param url - Request URL
+ * @param statusCode - Optional HTTP status code
+ * @param contentLength - Optional response content length
+ */
+declare function annotateHttpRequest(method: string, url: string, statusCode?: number, contentLength?: number): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with error context
+ *
+ * @param error - Error object or message
+ * @param recoverable - Whether the error is recoverable
+ * @param errorType - Optional error type/category
+ */
+declare function annotateError(error: Error | string, recoverable: boolean, errorType?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with operation priority
+ *
+ * @param priority - Priority level (high, medium, low)
+ * @param reason - Optional reason for priority level
+ */
+declare function annotatePriority(priority: 'high' | 'medium' | 'low', reason?: string): Effect.Effect<void, never, never>;
+/**
+ * Annotate span with cache operation metadata
+ *
+ * @param hit - Whether the cache was hit
+ * @param key - Cache key
+ * @param ttl - Optional time-to-live in seconds
+ */
+declare function annotateCache(hit: boolean, key: string, ttl?: number): Effect.Effect<void, never, never>;
 
 /**
  * Effect metadata extraction
  *
  * Automatically extracts metadata from Effect fibers and adds them as span attributes.
  * This provides valuable context about the Effect execution environment.
+ *
+ * Uses Effect's public APIs:
+ * - Fiber.getCurrentFiber() - Get current fiber information
+ * - Effect.currentSpan - Detect parent spans and nesting
  */
+
 /**
  * Metadata extracted from Effect fibers
  */
@@ -166,8 +254,95 @@ interface EffectMetadata {
     'effect.fiber.id'?: string;
     'effect.fiber.status'?: string;
     'effect.operation.root'?: boolean;
-    'effect.operation.interrupted'?: boolean;
+    'effect.operation.nested'?: boolean;
+    'effect.parent.span.id'?: string;
+    'effect.parent.span.name'?: string;
+    'effect.parent.trace.id'?: string;
 }
+/**
+ * Extract Effect-native metadata from current execution context
+ *
+ * Uses Effect's native APIs:
+ * - Fiber.getCurrentFiber() - Get current fiber information
+ * - Effect.currentSpan - Detect parent spans and nesting
+ *
+ * @returns Effect that yields extracted metadata
+ */
+declare function extractEffectMetadata(): Effect.Effect<EffectMetadata>;
+
+/**
+ * Effect Auto-Enrichment Utilities
+ *
+ * Provides utilities for automatically extracting and enriching spans with Effect-native metadata.
+ *
+ * Usage:
+ * ```typescript
+ * import { autoEnrichSpan, withAutoEnrichedSpan } from '@atrim/instrument-node/effect'
+ *
+ * // Option 1: Manual enrichment
+ * Effect.gen(function* () {
+ *   yield* autoEnrichSpan()  // Auto-add Effect metadata
+ *   yield* annotateBatch(items.length, 10)  // Add custom attributes
+ *   const result = yield* storage.writeBatch(items)
+ *   return result
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ *
+ * // Option 2: Automatic enrichment wrapper
+ * const instrumented = withAutoEnrichedSpan('storage.writeBatch')(
+ *   Effect.gen(function* () {
+ *     yield* annotateBatch(items.length, 10)
+ *     return yield* storage.writeBatch(items)
+ *   })
+ * )
+ * ```
+ */
+
+/**
+ * Auto-enrich the current span with Effect metadata
+ *
+ * This function should be called within an Effect.withSpan() context.
+ * It extracts Effect metadata (fiber ID, status, parent span info)
+ * and adds it as span attributes.
+ *
+ * Best practice: Call this at the start of your instrumented Effect:
+ *
+ * ```typescript
+ * Effect.gen(function* () {
+ *   yield* autoEnrichSpan()  // Auto-add metadata
+ *   yield* annotateBatch(items.length, 10)  // Add custom attributes
+ *   const result = yield* storage.writeBatch(items)
+ *   return result
+ * }).pipe(Effect.withSpan('storage.writeBatch'))
+ * ```
+ *
+ * @returns Effect that annotates the current span with Effect metadata
+ */
+declare function autoEnrichSpan(): Effect.Effect<void>;
+/**
+ * Create a wrapper that combines Effect.withSpan with automatic enrichment
+ *
+ * This is a convenience function that wraps an Effect with both:
+ * 1. A span (via Effect.withSpan)
+ * 2. Automatic metadata extraction (via autoEnrichSpan)
+ *
+ * Usage:
+ * ```typescript
+ * const instrumented = withAutoEnrichedSpan('storage.writeBatch')(
+ *   Effect.gen(function* () {
+ *     yield* annotateBatch(items.length, 10)
+ *     return yield* storage.writeBatch(items)
+ *   })
+ * )
+ * ```
+ *
+ * @param spanName - The name of the span
+ * @param options - Optional span options
+ * @returns Function that wraps an Effect with an auto-enriched span
+ */
+declare function withAutoEnrichedSpan<A, E, R>(spanName: string, options?: {
+    readonly attributes?: Record<string, unknown>;
+    readonly kind?: 'client' | 'server' | 'producer' | 'consumer' | 'internal';
+}): (self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 
 /**
  * Options for span isolation when running effects in FiberSet
@@ -356,4 +531,4 @@ declare const FiberSet: {
     }) => Effect.Effect<RuntimeFiber<A, E>, never, R>;
 };
 
-export { EffectInstrumentationLive, type EffectMetadata, FiberSet, type IsolationOptions, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, createEffectInstrumentation, runIsolated, runWithSpan };
+export { EffectInstrumentationLive, type EffectMetadata, FiberSet, type IsolationOptions, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, runIsolated, runWithSpan, withAutoEnrichedSpan };

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

@@ -1,4 +1,4 @@
-import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, 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';
@@ -10,6 +10,11 @@ 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);
@@ -478,6 +483,7 @@ async function loadConfigWithOptions(options = {}) {
 }
 
 // src/integrations/effect/effect-tracer.ts
+var SDK_NAME = "@effect/opentelemetry-otlp";
 function createEffectInstrumentation(options = {}) {
   return Layer.unwrapEffect(
     Effect.gen(function* () {
@@ -511,7 +517,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
@@ -550,7 +558,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
@@ -569,25 +579,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, 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 annotateDataSize(_bytes, _count) {
+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 annotateBatch(_size, _batchSize) {
+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 annotateLLM(_model, _operation, _inputTokens, _outputTokens) {
+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 annotateQuery(_query, _database) {
+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 annotateHttpRequest(_method, _url, _statusCode) {
+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 annotateError(_error, _context) {
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return Effect.annotateCurrentSpan(attributes);
 }
-function annotatePriority(_priority) {
+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 annotateCache(_operation, _hit) {
+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) {
@@ -714,6 +843,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