@atrim/instrument-node 0.7.1-dev.14fdea7.20260109021705 → 0.7.1-dev.764c183.20260110203528

package/target/dist/integrations/effect/auto/index.cjs

@@ -4,14 +4,14 @@ var effect = require('effect');
 var opentelemetry = require('@effect/opentelemetry');
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var OtelApi = require('@opentelemetry/api');
 var FileSystem = require('@effect/platform/FileSystem');
 var HttpClient = require('@effect/platform/HttpClient');
 var HttpClientRequest = require('@effect/platform/HttpClientRequest');
 var yaml = require('yaml');
 var zod = require('zod');
-var OtelApi = require('@opentelemetry/api');
-var resources = require('@opentelemetry/resources');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
 var path = require('path');
 
 function _interopNamespace(e) {
@@ -32,9 +32,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var OtelApi__namespace = /*#__PURE__*/_interopNamespace(OtelApi);
 var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
 var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
-var OtelApi__namespace = /*#__PURE__*/_interopNamespace(OtelApi);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
 var __defProp = Object.defineProperty;
@@ -107,6 +107,25 @@ var AutoInstrumentationConfigSchema = zod.z.object({
     // Naming rules (first match wins)
     rules: zod.z.array(SpanNamingRuleSchema).default([])
   }).default({}),
+  // Span relationship configuration for forked fibers
+  // Controls how child fiber spans relate to their parent/forking context
+  span_relationships: zod.z.object({
+    // Relationship type between forked fiber spans and their parent context
+    // - 'parent-child': Use parent-child relationship (default, traditional tracing)
+    //   Parent span shows child as nested. Works well with most observability tools.
+    // - 'span-links': Use span links (semantically correct for async forks per OTel spec)
+    //   Fibers get independent traces linked to parent. Better for long-running fibers.
+    // - 'both': Create parent-child AND add span links
+    //   Maximum visibility but may create redundant data.
+    type: zod.z.enum(["parent-child", "span-links", "both"]).default("parent-child"),
+    // Custom attributes to add to span links (only used when type includes links)
+    link_attributes: zod.z.object({
+      // Link type identifier
+      "link.type": zod.z.string().default("fork"),
+      // Custom attributes (key-value pairs)
+      custom: zod.z.record(zod.z.string()).optional()
+    }).optional()
+  }).default({}),
   // Pattern-based filtering
   filter: zod.z.object({
     // Only trace spans matching these patterns (empty = trace all)
@@ -550,6 +569,9 @@ var defaultAutoTracingConfig = {
     infer_from_source: true,
     rules: []
   },
+  span_relationships: {
+    type: "parent-child"
+  },
   filter: {
     include: [],
     exclude: []
@@ -817,42 +839,85 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
     if (!this.shouldTrace(spanName)) {
       return;
     }
+    const relationshipType = this.config.span_relationships?.type ?? "parent-child";
+    const useParentChild = relationshipType === "parent-child" || relationshipType === "both";
+    const useSpanLinks = relationshipType === "span-links" || relationshipType === "both";
     let parentContext = OtelApi__namespace.ROOT_CONTEXT;
     let parentFiberId;
+    let spanLinks = [];
     const maybeEffectParentSpan = effect.Context.getOption(_context, effect.Tracer.ParentSpan);
     if (effect.Option.isSome(maybeEffectParentSpan)) {
       const effectSpan = maybeEffectParentSpan.value;
-      logger.log(`@atrim/auto-trace: Found ParentSpan - traceId=${effectSpan.traceId.slice(0, 8)}..., spanId=${effectSpan.spanId.slice(0, 8)}...`);
+      logger.log(
+        `@atrim/auto-trace: Found ParentSpan - traceId=${effectSpan.traceId.slice(0, 8)}..., spanId=${effectSpan.spanId.slice(0, 8)}...`
+      );
       const otelSpanContext = {
         traceId: effectSpan.traceId,
         spanId: effectSpan.spanId,
         traceFlags: effectSpan.sampled ? OtelApi__namespace.TraceFlags.SAMPLED : OtelApi__namespace.TraceFlags.NONE,
         isRemote: false
       };
-      const wrappedSpan = OtelApi__namespace.trace.wrapSpanContext(otelSpanContext);
-      parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, wrappedSpan);
+      if (useParentChild) {
+        const wrappedSpan = OtelApi__namespace.trace.wrapSpanContext(otelSpanContext);
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, wrappedSpan);
+      }
+      if (useSpanLinks) {
+        const linkAttributes = this.getLinkAttributes();
+        spanLinks.push({
+          context: otelSpanContext,
+          attributes: linkAttributes
+        });
+        logger.log(`@atrim/auto-trace: Added span link to parent (${relationshipType})`);
+      }
     } else if (effect.Option.isSome(parent)) {
       parentFiberId = parent.value.id().id;
       const parentSpan = this.fiberSpans.get(parent.value);
       if (parentSpan) {
-        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
+        if (useParentChild) {
+          parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
+        }
+        if (useSpanLinks) {
+          const linkAttributes = this.getLinkAttributes();
+          spanLinks.push({
+            context: parentSpan.spanContext(),
+            attributes: linkAttributes
+          });
+        }
       } else if (this._rootSpan) {
-        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+        if (useParentChild) {
+          parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+        }
+        if (useSpanLinks) {
+          const linkAttributes = this.getLinkAttributes();
+          spanLinks.push({
+            context: this._rootSpan.spanContext(),
+            attributes: linkAttributes
+          });
+        }
       }
     } else if (this._rootSpan) {
-      parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+      if (useParentChild) {
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
+      }
+      if (useSpanLinks) {
+        const linkAttributes = this.getLinkAttributes();
+        spanLinks.push({
+          context: this._rootSpan.spanContext(),
+          attributes: linkAttributes
+        });
+      }
     }
     if (effect.Option.isSome(parent)) {
       parentFiberId = parent.value.id().id;
     }
-    const span = this.tracer.startSpan(
-      spanName,
-      {
-        kind: OtelApi__namespace.SpanKind.INTERNAL,
-        attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
-      },
-      parentContext
-    );
+    const spanOptions = {
+      kind: OtelApi__namespace.SpanKind.INTERNAL,
+      attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
+    };
+    if (spanLinks.length > 0) {
+      spanOptions.links = spanLinks;
+    }
+    const span = this.tracer.startSpan(spanName, spanOptions, parentContext);
     logger.log(`@atrim/auto-trace: Created span "${spanName}" for fiber ${fiber.id().id}`);
     this.fiberSpans.set(fiber, span);
     this.fiberStartTimes.set(fiber, process.hrtime.bigint());
@@ -862,8 +927,12 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
    * Called when a fiber completes (success or failure)
    */
   onEnd(exit, fiber) {
+    logger.log(`@atrim/auto-trace: onEnd called for fiber ${fiber.id().id}`);
     const span = this.fiberSpans.get(fiber);
     if (!span) {
+      logger.log(
+        `@atrim/auto-trace: No span found for fiber ${fiber.id().id} (skipped or filtered)`
+      );
       return;
     }
     const startTime = this.fiberStartTimes.get(fiber);
@@ -887,10 +956,26 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
       span.setAttribute("effect.fiber.failed", true);
     }
     span.end();
+    logger.log(`@atrim/auto-trace: Ended span for fiber ${fiber.id().id}`);
     this.fiberSpans.delete(fiber);
     this.fiberStartTimes.delete(fiber);
     this.activeFiberCount--;
   }
+  /**
+   * Get attributes for span links from config
+   */
+  getLinkAttributes() {
+    const linkConfig = this.config.span_relationships?.link_attributes;
+    const attrs = {
+      "link.type": linkConfig?.["link.type"] ?? "fork"
+    };
+    if (linkConfig?.custom) {
+      for (const [key, value] of Object.entries(linkConfig.custom)) {
+        attrs[key] = value;
+      }
+    }
+    return attrs;
+  }
   /**
    * Check if a span name should be traced based on filter patterns
    */
@@ -1062,7 +1147,9 @@ var createExporterLayer = (exporterConfig, serviceName, serviceVersion) => {
     };
     if (config.headers) {
       exporterConfig2.headers = config.headers;
-      logger.log(`@atrim/auto-trace: Using custom headers: ${Object.keys(config.headers).join(", ")}`);
+      logger.log(
+        `@atrim/auto-trace: Using custom headers: ${Object.keys(config.headers).join(", ")}`
+      );
     }
     return new exporterTraceOtlpHttp.OTLPTraceExporter(exporterConfig2);
   };
@@ -1155,7 +1242,9 @@ var createEffectTracingLayer = () => {
         };
         if (exporterConfig.headers) {
           otlpConfig.headers = exporterConfig.headers;
-          logger.log(`@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`);
+          logger.log(
+            `@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`
+          );
         }
         const exporter = new exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
         if (exporterConfig.processor === "simple") {
@@ -1203,6 +1292,9 @@ var createCombinedTracingLayer = () => {
           infer_from_source: true,
           rules: []
         },
+        span_relationships: {
+          type: "parent-child"
+        },
         filter: { include: [], exclude: [] },
         performance: { sampling_rate: 1, min_duration: "0ms", max_concurrent: 0 },
         metadata: { fiber_info: true, source_location: true, parent_fiber: true }
@@ -1214,10 +1306,10 @@ var createCombinedTracingLayer = () => {
         logger.log('@atrim/auto-trace: Exporter type is "none", using empty layer');
         return effect.Layer.empty;
       }
-      const createSpanProcessor = () => {
+      const createSpanExporter = () => {
         if (exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter with SimpleSpanProcessor");
-          return new sdkTraceBase.SimpleSpanProcessor(new sdkTraceBase.ConsoleSpanExporter());
+          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
+          return new sdkTraceBase.ConsoleSpanExporter();
         }
         const endpoint = exporterConfig.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
         logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
@@ -1226,10 +1318,15 @@ var createCombinedTracingLayer = () => {
         };
         if (exporterConfig.headers) {
           otlpConfig.headers = exporterConfig.headers;
-          logger.log(`@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`);
+          logger.log(
+            `@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`
+          );
         }
-        const exporter = new exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
-        if (exporterConfig.processor === "simple") {
+        return new exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
+      };
+      const createSpanProcessor = () => {
+        const exporter = createSpanExporter();
+        if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
           logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
           return new sdkTraceBase.SimpleSpanProcessor(exporter);
         }
@@ -1243,34 +1340,31 @@ var createCombinedTracingLayer = () => {
           maxExportBatchSize: batchConfig.max_export_batch_size
         });
       };
-      const sdkLayer = opentelemetry.NodeSdk.layer(() => ({
-        resource: {
-          serviceName,
-          serviceVersion
-        },
-        spanProcessor: createSpanProcessor()
-      }));
-      const supervisorLayer = effect.Layer.unwrapScoped(
-        effect.Effect.gen(function* () {
-          const tracerProvider = yield* effect.Effect.serviceOption(opentelemetry.Tracer.OtelTracerProvider);
-          if (effect.Option.isSome(tracerProvider)) {
-            logger.log("@atrim/auto-trace: Got TracerProvider from NodeSdk layer");
-            const supervisor = createAutoTracingSupervisor(autoConfig, tracerProvider.value);
-            logger.log("@atrim/auto-trace: Combined layer created");
-            logger.log("  - HTTP requests: auto-traced via Effect platform");
-            logger.log("  - Forked fibers: auto-traced via Supervisor");
-            return effect.Supervisor.addSupervisor(supervisor);
-          } else {
-            logger.log("@atrim/auto-trace: WARNING: No TracerProvider found, creating supervisor without it");
-            const supervisor = createAutoTracingSupervisor(autoConfig);
-            logger.log("@atrim/auto-trace: Combined layer created (fallback)");
-            logger.log("  - HTTP requests: auto-traced via Effect platform");
-            logger.log("  - Forked fibers: auto-traced via Supervisor");
-            return effect.Supervisor.addSupervisor(supervisor);
-          }
+      const globalProviderLayer = effect.Layer.effectDiscard(
+        effect.Effect.sync(() => {
+          const provider = new sdkTraceBase.BasicTracerProvider({
+            resource: resources.resourceFromAttributes({
+              [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
+              [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
+            }),
+            spanProcessors: [createSpanProcessor()]
+          });
+          OtelApi__namespace.trace.setGlobalTracerProvider(provider);
+          logger.log("@atrim/auto-trace: Global TracerProvider registered");
         })
       );
-      return supervisorLayer.pipe(effect.Layer.provide(effect.Layer.discard(sdkLayer)));
+      const resourceLayer = opentelemetry.Resource.layer({
+        serviceName,
+        serviceVersion
+      });
+      const effectTracerLayer = opentelemetry.Tracer.layerGlobal;
+      const supervisor = createAutoTracingSupervisor(autoConfig);
+      const supervisorLayer = effect.Supervisor.addSupervisor(supervisor);
+      logger.log("@atrim/auto-trace: Combined layer created");
+      logger.log("  - HTTP requests: auto-traced via Effect platform (global provider)");
+      logger.log("  - Forked fibers: auto-traced via Supervisor (global provider)");
+      const tracerWithResource = effectTracerLayer.pipe(effect.Layer.provide(resourceLayer));
+      return effect.Layer.mergeAll(globalProviderLayer, effect.Layer.discard(tracerWithResource), supervisorLayer);
     })
   );
 };