@atrim/instrument-node 0.7.0-b9eaf74-20260108193056 → 0.7.1-dev.14fdea7.20260108220010

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

@@ -2,6 +2,10 @@
 
 var effect = require('effect');
 var OtelApi = require('@opentelemetry/api');
+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 FileSystem = require('@effect/platform/FileSystem');
 var HttpClient = require('@effect/platform/HttpClient');
 var HttpClientRequest = require('@effect/platform/HttpClientRequest');
@@ -149,6 +153,27 @@ var HttpFilteringConfigSchema = zod.z.object({
     include_urls: zod.z.array(zod.z.string()).optional()
   }).optional()
 });
+var ExporterConfigSchema = zod.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: zod.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: zod.z.string().optional(),
+  // Span processor type
+  // - 'batch': Batch spans for export (production, lower overhead)
+  // - 'simple': Export immediately (development, no batching delay)
+  processor: zod.z.enum(["batch", "simple"]).default("batch"),
+  // Batch processor settings (for processor: batch)
+  batch: zod.z.object({
+    // Max time to wait before exporting (milliseconds)
+    scheduled_delay_millis: zod.z.number().default(1e3),
+    // Max batch size
+    max_export_batch_size: zod.z.number().default(100)
+  }).optional()
+});
 var InstrumentationConfigSchema = zod.z.object({
   version: zod.z.string(),
   instrumentation: zod.z.object({
@@ -162,10 +187,12 @@ var InstrumentationConfigSchema = zod.z.object({
     // Enable/disable Effect tracing entirely
     // When false, EffectInstrumentationLive returns Layer.empty
     enabled: zod.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: zod.z.enum(["unified", "standalone"]).default("unified"),
+    // Exporter configuration (for auto-instrumentation)
+    exporter_config: ExporterConfigSchema.optional(),
     auto_extract_metadata: zod.z.boolean(),
     auto_isolation: AutoIsolationConfigSchema.optional(),
     // Auto-instrumentation: automatic tracing of all Effect fibers
@@ -681,6 +708,20 @@ var loadAutoTracingConfigSync = () => {
 };
 var AutoTracingConfigLive = effect.Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
 var AutoTracingConfigLayer = (config) => effect.Layer.succeed(AutoTracingConfig, config);
+var loadFullConfig = (options) => effect.Effect.gen(function* () {
+  const config = yield* effect.Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => {
+      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+      return error;
+    }
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(null)));
+  if (!config) {
+    logger.log("@atrim/auto-trace: No config found, using defaults");
+    return defaultConfig;
+  }
+  return config;
+});
 
 // src/integrations/effect/auto/supervisor.ts
 var AutoTracingEnabled = effect.FiberRef.unsafeMake(true);
@@ -693,14 +734,15 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
     __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
     // WeakMap for fiber start times (for min_duration filtering)
     __publicField(this, "fiberStartTimes", /* @__PURE__ */ new WeakMap());
-    // OpenTelemetry tracer
-    __publicField(this, "tracer");
+    // OpenTelemetry tracer - lazily initialized
+    __publicField(this, "_tracer", null);
     // Compiled filter patterns
     __publicField(this, "includePatterns");
     __publicField(this, "excludePatterns");
     // Active fiber count (for max_concurrent limiting)
     __publicField(this, "activeFiberCount", 0);
-    this.tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
+    // Root span for parent context (set by withAutoTracing)
+    __publicField(this, "_rootSpan", null);
     this.includePatterns = (config.filter?.include || []).map((p) => new RegExp(p));
     this.excludePatterns = (config.filter?.exclude || []).map((p) => new RegExp(p));
     logger.log("@atrim/auto-trace: Supervisor initialized");
@@ -708,6 +750,21 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
     logger.log(`  Sampling rate: ${config.performance?.sampling_rate ?? 1}`);
     logger.log(`  Infer from source: ${config.span_naming?.infer_from_source ?? true}`);
   }
+  /**
+   * Set the root span for parent context propagation
+   */
+  setRootSpan(span) {
+    this._rootSpan = span;
+  }
+  /**
+   * Get the tracer lazily - this allows time for the NodeSdk layer to register the global provider
+   */
+  get tracer() {
+    if (!this._tracer) {
+      this._tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
+    }
+    return this._tracer;
+  }
   /**
    * Returns the current value (void for this supervisor)
    */
@@ -732,28 +789,34 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
       return;
     }
     const nameOverride = effect.FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
+    const sourceInfo = this.config.span_naming?.infer_from_source ? this.parseStackTrace() : void 0;
     let spanName;
     if (effect.Option.isSome(nameOverride)) {
       spanName = nameOverride.value;
     } else {
-      const sourceInfo = this.config.span_naming?.infer_from_source ? this.parseStackTrace() : void 0;
       spanName = inferSpanName(fiber.id().id, sourceInfo, this.config);
     }
     if (!this.shouldTrace(spanName)) {
       return;
     }
-    let parentContext = OtelApi__namespace.context.active();
+    let parentContext = OtelApi__namespace.ROOT_CONTEXT;
+    let parentFiberId;
     if (effect.Option.isSome(parent)) {
+      parentFiberId = parent.value.id().id;
       const parentSpan = this.fiberSpans.get(parent.value);
       if (parentSpan) {
-        parentContext = OtelApi__namespace.trace.setSpan(parentContext, parentSpan);
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
+      } else if (this._rootSpan) {
+        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
       }
+    } else if (this._rootSpan) {
+      parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
     }
     const span = this.tracer.startSpan(
       spanName,
       {
         kind: OtelApi__namespace.SpanKind.INTERNAL,
-        attributes: this.getInitialAttributes(fiber)
+        attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
       },
       parentContext
     );
@@ -816,13 +879,22 @@ var AutoTracingSupervisor = class extends effect.Supervisor.AbstractSupervisor {
   /**
    * Get initial span attributes for a fiber
    */
-  getInitialAttributes(fiber) {
+  getInitialAttributes(fiber, sourceInfo, parentFiberId) {
     const attrs = {
       "effect.auto_traced": true
     };
     if (this.config.metadata?.fiber_info !== false) {
       attrs["effect.fiber.id"] = fiber.id().id;
     }
+    if (this.config.metadata?.source_location !== false && sourceInfo) {
+      attrs["code.function"] = sourceInfo.function;
+      attrs["code.filepath"] = sourceInfo.file;
+      attrs["code.lineno"] = sourceInfo.line;
+      attrs["code.column"] = sourceInfo.column;
+    }
+    if (this.config.metadata?.parent_fiber !== false && parentFiberId !== void 0) {
+      attrs["effect.fiber.parent_id"] = parentFiberId;
+    }
     return attrs;
   }
   /**
@@ -891,9 +963,128 @@ var createAutoTracingLayer = (options) => {
     })
   );
 };
+var withAutoTracing = (effect$1, config, mainSpanName) => {
+  if (!config.enabled) {
+    logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
+    return effect$1;
+  }
+  const supervisor = createAutoTracingSupervisor(config);
+  const tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
+  const spanName = mainSpanName ?? inferSpanName(0, void 0, config);
+  const mainSpan = tracer.startSpan(spanName, {
+    kind: OtelApi__namespace.SpanKind.INTERNAL,
+    attributes: {
+      "effect.auto_traced": true,
+      "effect.fiber.id": 0,
+      // Main fiber
+      "effect.main_fiber": true
+    }
+  });
+  supervisor.setRootSpan(mainSpan);
+  return effect.Effect.acquireUseRelease(
+    // Acquire: return the span (already started)
+    effect.Effect.succeed(mainSpan),
+    // Use: run the supervised effect
+    () => effect.Effect.supervised(supervisor)(effect$1),
+    // Release: end the span
+    (span, exit) => effect.Effect.sync(() => {
+      if (effect.Exit.isSuccess(exit)) {
+        span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
+      } else {
+        span.setStatus({
+          code: OtelApi__namespace.SpanStatusCode.ERROR,
+          message: "Effect failed"
+        });
+      }
+      span.end();
+    })
+  );
+};
 var AutoTracingLive = createAutoTracingLayer();
 var withoutAutoTracing = (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingEnabled, false));
 var setSpanName = (name) => (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingSpanName, effect.Option.some(name)));
+var createExporterLayer = (exporterConfig, serviceName, serviceVersion) => {
+  const config = exporterConfig ?? {
+    type: "otlp",
+    processor: "batch",
+    batch: {
+      scheduled_delay_millis: 1e3,
+      max_export_batch_size: 100
+    }
+  };
+  if (config.type === "none") {
+    logger.log('@atrim/auto-trace: Exporter type is "none", no spans will be exported');
+    return effect.Layer.empty;
+  }
+  const createSpanExporter = () => {
+    if (config.type === "console") {
+      logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
+      return new sdkTraceBase.ConsoleSpanExporter();
+    }
+    const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+    logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
+    return new exporterTraceOtlpHttp.OTLPTraceExporter({
+      url: `${endpoint}/v1/traces`
+    });
+  };
+  const createSpanProcessor = () => {
+    const exporter = createSpanExporter();
+    if (config.processor === "simple" || config.type === "console") {
+      logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
+      return new sdkTraceBase.SimpleSpanProcessor(exporter);
+    }
+    const batchConfig = config.batch ?? {
+      scheduled_delay_millis: 1e3,
+      max_export_batch_size: 100
+    };
+    logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
+    return new sdkTraceBase.BatchSpanProcessor(exporter, {
+      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
+      maxExportBatchSize: batchConfig.max_export_batch_size
+    });
+  };
+  return 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 () => {
+        provider.shutdown().catch((err) => {
+          logger.log(`@atrim/auto-trace: Error shutting down provider: ${err}`);
+        });
+      };
+    })
+  );
+};
+var createFullAutoTracingLayer = () => {
+  return effect.Layer.unwrapEffect(
+    effect.Effect.gen(function* () {
+      const config = yield* loadFullConfig();
+      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = process.env.npm_package_version || "1.0.0";
+      const autoConfig = config.effect?.auto_instrumentation;
+      if (!autoConfig?.enabled) {
+        logger.log("@atrim/auto-trace: Auto-instrumentation disabled via config");
+        return effect.Layer.empty;
+      }
+      const exporterConfig = config.effect?.exporter_config;
+      logger.log("@atrim/auto-trace: Full auto-instrumentation enabled");
+      logger.log(`  Service: ${serviceName}`);
+      logger.log(`  Exporter: ${exporterConfig?.type ?? "otlp"}`);
+      const exporterLayer = createExporterLayer(exporterConfig, serviceName, serviceVersion);
+      const supervisor = createAutoTracingSupervisor(autoConfig);
+      const supervisorLayer = effect.Supervisor.addSupervisor(supervisor);
+      return effect.Layer.mergeAll(exporterLayer, supervisorLayer);
+    })
+  );
+};
+var FullAutoTracingLive = createFullAutoTracingLayer();
 
 exports.AutoTracingConfig = AutoTracingConfig;
 exports.AutoTracingConfigLayer = AutoTracingConfigLayer;
@@ -902,14 +1093,17 @@ exports.AutoTracingEnabled = AutoTracingEnabled;
 exports.AutoTracingLive = AutoTracingLive;
 exports.AutoTracingSpanName = AutoTracingSpanName;
 exports.AutoTracingSupervisor = AutoTracingSupervisor;
+exports.FullAutoTracingLive = FullAutoTracingLive;
 exports.createAutoTracingLayer = createAutoTracingLayer;
 exports.createAutoTracingSupervisor = createAutoTracingSupervisor;
+exports.createFullAutoTracingLayer = createFullAutoTracingLayer;
 exports.defaultAutoTracingConfig = defaultAutoTracingConfig;
 exports.inferSpanName = inferSpanName;
 exports.loadAutoTracingConfig = loadAutoTracingConfig;
 exports.loadAutoTracingConfigSync = loadAutoTracingConfigSync;
 exports.sanitizeSpanName = sanitizeSpanName;
 exports.setSpanName = setSpanName;
+exports.withAutoTracing = withAutoTracing;
 exports.withoutAutoTracing = withoutAutoTracing;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map