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

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

@@ -1,4 +1,5 @@
 import { Layer, Supervisor, Effect, Context, Option, Fiber, Exit, FiberRef } from 'effect';
+import * as OtelApi from '@opentelemetry/api';
 import { AutoInstrumentationConfig, InstrumentationConfig } from '@atrim/instrument-core';
 export { AutoInstrumentationConfig } from '@atrim/instrument-core';
 
@@ -39,11 +40,20 @@ declare class AutoTracingSupervisor extends Supervisor.AbstractSupervisor<void>
     private readonly config;
     private readonly fiberSpans;
     private readonly fiberStartTimes;
-    private readonly tracer;
+    private _tracer;
     private readonly includePatterns;
     private readonly excludePatterns;
     private activeFiberCount;
+    private _rootSpan;
     constructor(config: AutoInstrumentationConfig);
+    /**
+     * Set the root span for parent context propagation
+     */
+    setRootSpan(span: OtelApi.Span): void;
+    /**
+     * Get the tracer lazily - this allows time for the NodeSdk layer to register the global provider
+     */
+    private get tracer();
     /**
      * Returns the current value (void for this supervisor)
      */
@@ -94,6 +104,23 @@ declare const createAutoTracingSupervisor: (config: AutoInstrumentationConfig) =
 declare const createAutoTracingLayer: (options?: {
     config?: AutoInstrumentationConfig;
 }) => Layer.Layer<never>;
+/**
+ * Wrap an Effect with auto-tracing supervision
+ *
+ * This creates a span for the main effect AND supervises all child fibers.
+ * Use this when you need to ensure all fibers in an effect are traced.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   yield* doWork()  // Automatically traced!
+ * })
+ *
+ * const tracedProgram = withAutoTracing(program, { enabled: true, ... })
+ * Effect.runPromise(tracedProgram)
+ * ```
+ */
+declare const withAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>, config: AutoInstrumentationConfig, mainSpanName?: string) => Effect.Effect<A, E, R>;
 /**
  * Zero-config auto-tracing layer
  *
@@ -133,6 +160,60 @@ declare const withoutAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => E
  * ```
  */
 declare const setSpanName: (name: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Create a fully YAML-driven auto-instrumentation layer
+ *
+ * This layer reads all configuration from instrumentation.yaml including:
+ * - Exporter configuration (type, endpoint, processor)
+ * - Auto-tracing configuration (naming rules, filters, performance)
+ * - Service metadata (name, version)
+ *
+ * @example
+ * ```typescript
+ * import { createFullAutoTracingLayer } from '@atrim/instrument-node/effect/auto'
+ *
+ * // Everything configured via instrumentation.yaml - no code config needed!
+ * const AppLive = createFullAutoTracingLayer()
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(AppLive)))
+ * ```
+ */
+declare const createFullAutoTracingLayer: () => Layer.Layer<never>;
+/**
+ * Fully YAML-driven auto-instrumentation layer
+ *
+ * This is the recommended way to use auto-instrumentation. All configuration
+ * comes from instrumentation.yaml - no code configuration needed.
+ *
+ * @example
+ * ```yaml
+ * # instrumentation.yaml
+ * effect:
+ *   auto_instrumentation:
+ *     enabled: true
+ *     span_naming:
+ *       default: "effect.{function}"
+ *       rules:
+ *         - match: { function: "internal.*" }
+ *           name: "internal.{function}"
+ *     filter:
+ *       exclude:
+ *         - "^internal\\."
+ *   exporter_config:
+ *     type: otlp              # or 'console' for dev
+ *     endpoint: http://localhost:4318
+ *     processor: batch        # or 'simple' for dev
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FullAutoTracingLive } from '@atrim/instrument-node/effect/auto'
+ *
+ * // Just provide the layer - everything else from YAML!
+ * Effect.runPromise(program.pipe(Effect.provide(FullAutoTracingLive)))
+ * ```
+ */
+declare const FullAutoTracingLive: Layer.Layer<never>;
 
 /**
  * Node.js configuration loader
@@ -275,4 +356,4 @@ declare function inferSpanName(fiberId: number, sourceInfo: SourceInfo | undefin
  */
 declare function sanitizeSpanName(name: string): string;
 
-export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, type SourceInfo, type TemplateVariables, createAutoTracingLayer, createAutoTracingSupervisor, defaultAutoTracingConfig, inferSpanName, loadAutoTracingConfig, loadAutoTracingConfigSync, sanitizeSpanName, setSpanName, withoutAutoTracing };
+export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, FullAutoTracingLive, type SourceInfo, type TemplateVariables, createAutoTracingLayer, createAutoTracingSupervisor, createFullAutoTracingLayer, defaultAutoTracingConfig, inferSpanName, loadAutoTracingConfig, loadAutoTracingConfigSync, sanitizeSpanName, setSpanName, withAutoTracing, withoutAutoTracing };

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

@@ -1,5 +1,9 @@
 import { Data, Context, Effect, Layer, FiberRef, Option, Supervisor, FiberRefs, Exit } from 'effect';
 import * as OtelApi from '@opentelemetry/api';
+import { BasicTracerProvider, SimpleSpanProcessor, BatchSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import { FileSystem } from '@effect/platform/FileSystem';
 import * as HttpClient from '@effect/platform/HttpClient';
 import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
@@ -124,6 +128,27 @@ 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(),
+  // 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({
@@ -137,10 +162,12 @@ 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_isolation: AutoIsolationConfigSchema.optional(),
     // Auto-instrumentation: automatic tracing of all Effect fibers
@@ -656,6 +683,20 @@ var loadAutoTracingConfigSync = () => {
 };
 var AutoTracingConfigLive = Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
 var AutoTracingConfigLayer = (config) => Layer.succeed(AutoTracingConfig, config);
+var loadFullConfig = (options) => Effect.gen(function* () {
+  const config = yield* Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => {
+      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+      return error;
+    }
+  }).pipe(Effect.catchAll(() => 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 = FiberRef.unsafeMake(true);
@@ -668,14 +709,15 @@ var AutoTracingSupervisor = class extends 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.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");
@@ -683,6 +725,21 @@ var AutoTracingSupervisor = class extends 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.trace.getTracer("@atrim/auto-trace", "1.0.0");
+    }
+    return this._tracer;
+  }
   /**
    * Returns the current value (void for this supervisor)
    */
@@ -707,28 +764,34 @@ var AutoTracingSupervisor = class extends Supervisor.AbstractSupervisor {
       return;
     }
     const nameOverride = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
+    const sourceInfo = this.config.span_naming?.infer_from_source ? this.parseStackTrace() : void 0;
     let spanName;
     if (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.context.active();
+    let parentContext = OtelApi.ROOT_CONTEXT;
+    let parentFiberId;
     if (Option.isSome(parent)) {
+      parentFiberId = parent.value.id().id;
       const parentSpan = this.fiberSpans.get(parent.value);
       if (parentSpan) {
-        parentContext = OtelApi.trace.setSpan(parentContext, parentSpan);
+        parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, parentSpan);
+      } else if (this._rootSpan) {
+        parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, this._rootSpan);
       }
+    } else if (this._rootSpan) {
+      parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, this._rootSpan);
     }
     const span = this.tracer.startSpan(
       spanName,
       {
         kind: OtelApi.SpanKind.INTERNAL,
-        attributes: this.getInitialAttributes(fiber)
+        attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
       },
       parentContext
     );
@@ -791,13 +854,22 @@ var AutoTracingSupervisor = class extends 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;
   }
   /**
@@ -866,10 +938,129 @@ var createAutoTracingLayer = (options) => {
     })
   );
 };
+var withAutoTracing = (effect, config, mainSpanName) => {
+  if (!config.enabled) {
+    logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
+    return effect;
+  }
+  const supervisor = createAutoTracingSupervisor(config);
+  const tracer = OtelApi.trace.getTracer("@atrim/auto-trace", "1.0.0");
+  const spanName = mainSpanName ?? inferSpanName(0, void 0, config);
+  const mainSpan = tracer.startSpan(spanName, {
+    kind: OtelApi.SpanKind.INTERNAL,
+    attributes: {
+      "effect.auto_traced": true,
+      "effect.fiber.id": 0,
+      // Main fiber
+      "effect.main_fiber": true
+    }
+  });
+  supervisor.setRootSpan(mainSpan);
+  return Effect.acquireUseRelease(
+    // Acquire: return the span (already started)
+    Effect.succeed(mainSpan),
+    // Use: run the supervised effect
+    () => Effect.supervised(supervisor)(effect),
+    // Release: end the span
+    (span, exit) => Effect.sync(() => {
+      if (Exit.isSuccess(exit)) {
+        span.setStatus({ code: OtelApi.SpanStatusCode.OK });
+      } else {
+        span.setStatus({
+          code: OtelApi.SpanStatusCode.ERROR,
+          message: "Effect failed"
+        });
+      }
+      span.end();
+    })
+  );
+};
 var AutoTracingLive = createAutoTracingLayer();
 var withoutAutoTracing = (effect) => effect.pipe(Effect.locally(AutoTracingEnabled, false));
 var setSpanName = (name) => (effect) => effect.pipe(Effect.locally(AutoTracingSpanName, 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 Layer.empty;
+  }
+  const createSpanExporter = () => {
+    if (config.type === "console") {
+      logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
+      return new ConsoleSpanExporter();
+    }
+    const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+    logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
+    return new 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 SimpleSpanProcessor(exporter);
+    }
+    const batchConfig = config.batch ?? {
+      scheduled_delay_millis: 1e3,
+      max_export_batch_size: 100
+    };
+    logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
+    return new BatchSpanProcessor(exporter, {
+      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
+      maxExportBatchSize: batchConfig.max_export_batch_size
+    });
+  };
+  return Layer.effectDiscard(
+    Effect.sync(() => {
+      const provider = new BasicTracerProvider({
+        resource: resourceFromAttributes({
+          [ATTR_SERVICE_NAME]: serviceName,
+          [ATTR_SERVICE_VERSION]: serviceVersion
+        }),
+        spanProcessors: [createSpanProcessor()]
+      });
+      OtelApi.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 Layer.unwrapEffect(
+    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 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 = Supervisor.addSupervisor(supervisor);
+      return Layer.mergeAll(exporterLayer, supervisorLayer);
+    })
+  );
+};
+var FullAutoTracingLive = createFullAutoTracingLayer();
 
-export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, createAutoTracingLayer, createAutoTracingSupervisor, defaultAutoTracingConfig, inferSpanName, loadAutoTracingConfig, loadAutoTracingConfigSync, sanitizeSpanName, setSpanName, withoutAutoTracing };
+export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, FullAutoTracingLive, createAutoTracingLayer, createAutoTracingSupervisor, createFullAutoTracingLayer, defaultAutoTracingConfig, inferSpanName, loadAutoTracingConfig, loadAutoTracingConfigSync, sanitizeSpanName, setSpanName, withAutoTracing, withoutAutoTracing };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map