@atrim/instrument-node 0.5.1-21bb978-20260105202350 → 0.5.1-dev.14fdea7.20260108231120

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

@@ -1,6 +1,5 @@
-import { Layer, Effect, Tracer as Tracer$1, FiberSet as FiberSet$1 } from 'effect';
+import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
 import * as Tracer from '@effect/opentelemetry/Tracer';
-import { SpanContext } from '@opentelemetry/api';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -135,134 +134,6 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  * ```
  */
 declare const EffectInstrumentationLive: Layer.Layer<Tracer.OtelTracer, never, never>;
-/**
- * Bridge the current OpenTelemetry span context to Effect's tracer.
- *
- * Use this when running Effect code inside an HTTP handler that was
- * auto-instrumented by OpenTelemetry. This ensures Effect spans become
- * children of the HTTP span rather than starting a new trace.
- *
- * @example
- * ```typescript
- * // In an Express handler
- * app.get('/api/users', async (req, res) => {
- *   const program = fetchUsers().pipe(
- *     Effect.withSpan('api.fetchUsers'),
- *     withOtelParentSpan,  // Bridge to HTTP span
- *     Effect.provide(EffectInstrumentationLive)
- *   )
- *   const result = await Effect.runPromise(program)
- *   res.json(result)
- * })
- * ```
- *
- * Without this utility, Effect spans would start a new trace instead of
- * continuing the HTTP request trace, resulting in disconnected spans.
- *
- * @param effect - The Effect to run with the current OTel span as parent
- * @returns The same Effect with OTel parent span context attached
- */
-declare const withOtelParentSpan: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Create an Effect that gets the current OpenTelemetry span context.
- *
- * This is useful when you need to access the current span context for
- * custom propagation or logging purposes.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   const spanContext = yield* getCurrentOtelSpanContext
- *   if (spanContext) {
- *     console.log('Current trace:', spanContext.traceId)
- *   }
- * })
- * ```
- *
- * @returns Effect that yields the current SpanContext or undefined if none
- */
-declare const getCurrentOtelSpanContext: Effect.Effect<SpanContext | undefined>;
-/**
- * Create an external span reference from the current OpenTelemetry context.
- *
- * This creates an Effect ExternalSpan that can be used as a parent for
- * Effect spans. Useful when you need more control over span parenting.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   const parentSpan = yield* getOtelParentSpan
- *   if (parentSpan) {
- *     yield* myOperation.pipe(
- *       Effect.withSpan('child.operation', { parent: parentSpan })
- *     )
- *   }
- * })
- * ```
- *
- * @returns Effect that yields an ExternalSpan or undefined if no active span
- */
-declare const getOtelParentSpan: Effect.Effect<Tracer$1.ExternalSpan | undefined>;
-/**
- * Run an async operation with the current Effect span set as the active OTel span.
- *
- * Use this when calling async code that uses OTel auto-instrumentation
- * (e.g., fetch, database drivers) from within an Effect span. This ensures
- * the auto-instrumented spans become children of the Effect span.
- *
- * @example
- * ```typescript
- * const fetchData = Effect.gen(function* () {
- *   // This fetch call will have the Effect span as its parent
- *   const result = yield* runWithOtelContext(
- *     Effect.tryPromise(() => fetch('https://api.example.com/data'))
- *   )
- *   return result
- * }).pipe(Effect.withSpan('fetch.data'))
- * ```
- *
- * Note: This is most useful when you need OTel auto-instrumentation (HTTP, DB)
- * to see Effect spans as parents. For Effect-only code, this isn't needed.
- *
- * @param effect - The Effect containing async operations with OTel auto-instrumentation
- * @returns The same Effect but with OTel context propagation during execution
- */
-declare const runWithOtelContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Higher-order function to create an Effect that bridges both directions:
- * 1. Captures active OTel span as Effect's parent (OTel → Effect)
- * 2. Sets Effect span as active OTel span during execution (Effect → OTel)
- *
- * This is the recommended way to run Effect code in HTTP handlers when you need
- * full bidirectional tracing with OTel auto-instrumentation.
- *
- * @example
- * ```typescript
- * // In an Express handler
- * app.get('/api/users', async (req, res) => {
- *   const program = Effect.gen(function* () {
- *     // Effect spans are children of HTTP request span
- *     const users = yield* fetchUsersFromDb()
- *
- *     // HTTP client spans (from fetch) are children of Effect span
- *     yield* notifyExternalService(users)
- *
- *     return users
- *   }).pipe(
- *     Effect.withSpan('api.getUsers'),
- *     withFullOtelBridging,  // Bidirectional bridging
- *     Effect.provide(EffectInstrumentationLive)
- *   )
- *
- *   const result = await Effect.runPromise(program)
- *   res.json(result)
- * })
- * ```
- *
- * @param effect - The Effect to run with full OTel bridging
- * @returns Effect with bidirectional OTel context bridging
- */
-declare const withFullOtelBridging: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 
 /**
  * Effect-specific span annotation helpers
@@ -655,4 +526,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, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, getCurrentOtelSpanContext, getOtelParentSpan, runIsolated, runWithOtelContext, runWithSpan, withAutoEnrichedSpan, withFullOtelBridging, withOtelParentSpan };
+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,6 +1,5 @@
-import { Layer, Effect, Tracer as Tracer$1, FiberSet as FiberSet$1 } from 'effect';
+import { Layer, Effect, FiberSet as FiberSet$1 } from 'effect';
 import * as Tracer from '@effect/opentelemetry/Tracer';
-import { SpanContext } from '@opentelemetry/api';
 import { InstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Runtime from 'effect/Runtime';
 import * as effect_FiberId from 'effect/FiberId';
@@ -135,134 +134,6 @@ declare function createEffectInstrumentation(options?: EffectInstrumentationOpti
  * ```
  */
 declare const EffectInstrumentationLive: Layer.Layer<Tracer.OtelTracer, never, never>;
-/**
- * Bridge the current OpenTelemetry span context to Effect's tracer.
- *
- * Use this when running Effect code inside an HTTP handler that was
- * auto-instrumented by OpenTelemetry. This ensures Effect spans become
- * children of the HTTP span rather than starting a new trace.
- *
- * @example
- * ```typescript
- * // In an Express handler
- * app.get('/api/users', async (req, res) => {
- *   const program = fetchUsers().pipe(
- *     Effect.withSpan('api.fetchUsers'),
- *     withOtelParentSpan,  // Bridge to HTTP span
- *     Effect.provide(EffectInstrumentationLive)
- *   )
- *   const result = await Effect.runPromise(program)
- *   res.json(result)
- * })
- * ```
- *
- * Without this utility, Effect spans would start a new trace instead of
- * continuing the HTTP request trace, resulting in disconnected spans.
- *
- * @param effect - The Effect to run with the current OTel span as parent
- * @returns The same Effect with OTel parent span context attached
- */
-declare const withOtelParentSpan: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Create an Effect that gets the current OpenTelemetry span context.
- *
- * This is useful when you need to access the current span context for
- * custom propagation or logging purposes.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   const spanContext = yield* getCurrentOtelSpanContext
- *   if (spanContext) {
- *     console.log('Current trace:', spanContext.traceId)
- *   }
- * })
- * ```
- *
- * @returns Effect that yields the current SpanContext or undefined if none
- */
-declare const getCurrentOtelSpanContext: Effect.Effect<SpanContext | undefined>;
-/**
- * Create an external span reference from the current OpenTelemetry context.
- *
- * This creates an Effect ExternalSpan that can be used as a parent for
- * Effect spans. Useful when you need more control over span parenting.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   const parentSpan = yield* getOtelParentSpan
- *   if (parentSpan) {
- *     yield* myOperation.pipe(
- *       Effect.withSpan('child.operation', { parent: parentSpan })
- *     )
- *   }
- * })
- * ```
- *
- * @returns Effect that yields an ExternalSpan or undefined if no active span
- */
-declare const getOtelParentSpan: Effect.Effect<Tracer$1.ExternalSpan | undefined>;
-/**
- * Run an async operation with the current Effect span set as the active OTel span.
- *
- * Use this when calling async code that uses OTel auto-instrumentation
- * (e.g., fetch, database drivers) from within an Effect span. This ensures
- * the auto-instrumented spans become children of the Effect span.
- *
- * @example
- * ```typescript
- * const fetchData = Effect.gen(function* () {
- *   // This fetch call will have the Effect span as its parent
- *   const result = yield* runWithOtelContext(
- *     Effect.tryPromise(() => fetch('https://api.example.com/data'))
- *   )
- *   return result
- * }).pipe(Effect.withSpan('fetch.data'))
- * ```
- *
- * Note: This is most useful when you need OTel auto-instrumentation (HTTP, DB)
- * to see Effect spans as parents. For Effect-only code, this isn't needed.
- *
- * @param effect - The Effect containing async operations with OTel auto-instrumentation
- * @returns The same Effect but with OTel context propagation during execution
- */
-declare const runWithOtelContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Higher-order function to create an Effect that bridges both directions:
- * 1. Captures active OTel span as Effect's parent (OTel → Effect)
- * 2. Sets Effect span as active OTel span during execution (Effect → OTel)
- *
- * This is the recommended way to run Effect code in HTTP handlers when you need
- * full bidirectional tracing with OTel auto-instrumentation.
- *
- * @example
- * ```typescript
- * // In an Express handler
- * app.get('/api/users', async (req, res) => {
- *   const program = Effect.gen(function* () {
- *     // Effect spans are children of HTTP request span
- *     const users = yield* fetchUsersFromDb()
- *
- *     // HTTP client spans (from fetch) are children of Effect span
- *     yield* notifyExternalService(users)
- *
- *     return users
- *   }).pipe(
- *     Effect.withSpan('api.getUsers'),
- *     withFullOtelBridging,  // Bidirectional bridging
- *     Effect.provide(EffectInstrumentationLive)
- *   )
- *
- *   const result = await Effect.runPromise(program)
- *   res.json(result)
- * })
- * ```
- *
- * @param effect - The Effect to run with full OTel bridging
- * @returns Effect with bidirectional OTel context bridging
- */
-declare const withFullOtelBridging: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 
 /**
  * Effect-specific span annotation helpers
@@ -655,4 +526,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, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, getCurrentOtelSpanContext, getOtelParentSpan, runIsolated, runWithOtelContext, runWithSpan, withAutoEnrichedSpan, withFullOtelBridging, withOtelParentSpan };
+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

@@ -3,7 +3,7 @@ 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 { trace, context, TraceFlags } from '@opentelemetry/api';
+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';
@@ -42,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(),
@@ -63,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,17 +163,16 @@ var InstrumentationConfigSchema = z.object({
     // Enable/disable Effect tracing entirely
     // When false, EffectInstrumentationLive returns Layer.empty
     enabled: z.boolean().default(true),
-    // Exporter mode:
+    // 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-bridge OpenTelemetry context to Effect spans
-    // When true, Effect spans automatically become children of the active OTel span
-    // (e.g., HTTP request span from auto-instrumentation)
-    // This is essential for proper trace hierarchy when using Effect with HTTP frameworks
-    auto_bridge_context: z.boolean().default(true),
-    auto_isolation: AutoIsolationConfigSchema.optional()
+    auto_isolation: AutoIsolationConfigSchema.optional(),
+    // Auto-instrumentation: automatic tracing of all Effect fibers
+    auto_instrumentation: AutoInstrumentationConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });
@@ -110,8 +196,7 @@ var defaultConfig = {
   effect: {
     enabled: true,
     exporter: "unified",
-    auto_extract_metadata: true,
-    auto_bridge_context: true
+    auto_extract_metadata: true
   }
 };
 function parseAndValidateConfig(content) {
@@ -594,55 +679,6 @@ var EffectInstrumentationLive = Effect.sync(() => {
     )
   );
 }).pipe(Layer.unwrapEffect);
-var withOtelParentSpan = (effect) => {
-  const currentSpan = trace.getSpan(context.active());
-  if (currentSpan) {
-    const spanContext = currentSpan.spanContext();
-    return Tracer.withSpanContext(spanContext)(effect);
-  }
-  return effect;
-};
-var getCurrentOtelSpanContext = Effect.sync(() => {
-  const currentSpan = trace.getSpan(context.active());
-  return currentSpan?.spanContext();
-});
-var getOtelParentSpan = Effect.sync(
-  () => {
-    const currentSpan = trace.getSpan(context.active());
-    if (!currentSpan) {
-      return void 0;
-    }
-    const spanContext = currentSpan.spanContext();
-    return Tracer.makeExternalSpan({
-      traceId: spanContext.traceId,
-      spanId: spanContext.spanId,
-      traceFlags: spanContext.traceFlags,
-      traceState: spanContext.traceState?.serialize()
-    });
-  }
-);
-var runWithOtelContext = (effect) => {
-  return Effect.flatMap(
-    Tracer.currentOtelSpan,
-    (otelSpan) => Effect.async((resume) => {
-      context.with(trace.setSpan(context.active(), otelSpan), () => {
-        Effect.runPromiseExit(effect).then((exit) => {
-          if (exit._tag === "Success") {
-            resume(Effect.succeed(exit.value));
-          } else {
-            resume(Effect.failCause(exit.cause));
-          }
-        });
-      });
-    })
-  ).pipe(
-    // If no OTel span is available, just run the effect normally
-    Effect.catchAll(() => effect)
-  );
-};
-var withFullOtelBridging = (effect) => {
-  return withOtelParentSpan(effect);
-};
 function annotateUser(userId, email, username) {
   const attributes = {
     "user.id": userId
@@ -907,6 +943,6 @@ var FiberSet = {
   runWithSpan
 };
 
-export { EffectInstrumentationLive, FiberSet, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, getCurrentOtelSpanContext, getOtelParentSpan, runIsolated, runWithOtelContext, runWithSpan, withAutoEnrichedSpan, withFullOtelBridging, withOtelParentSpan };
+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