@atrim/instrument-node 0.5.2-dev.ac2fbfe.20251221205322 → 0.7.0-14fdea7-20260108225522

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

@@ -1,15 +1,17 @@
 'use strict';
 
 var effect = require('effect');
+var Tracer = require('@effect/opentelemetry/Tracer');
+var Resource = require('@effect/opentelemetry/Resource');
 var Otlp = require('@effect/opentelemetry/Otlp');
 var platform = require('@effect/platform');
 var api = require('@opentelemetry/api');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
 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 platformNode = require('@effect/platform-node');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -29,16 +31,13 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var Tracer__namespace = /*#__PURE__*/_interopNamespace(Tracer);
+var Resource__namespace = /*#__PURE__*/_interopNamespace(Resource);
 var Otlp__namespace = /*#__PURE__*/_interopNamespace(Otlp);
 var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
 var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
 
 // 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);
@@ -69,6 +68,69 @@ var AutoIsolationConfigSchema = zod.z.object({
     add_metadata: zod.z.boolean().default(true)
   }).default({})
 });
+var SpanNamingRuleSchema = zod.z.object({
+  // Match criteria (all specified criteria must match)
+  match: zod.z.object({
+    // Regex pattern to match file path
+    file: zod.z.string().optional(),
+    // Regex pattern to match function name
+    function: zod.z.string().optional(),
+    // Regex pattern to match module name
+    module: zod.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: zod.z.string()
+});
+var AutoInstrumentationConfigSchema = zod.z.object({
+  // Enable/disable auto-instrumentation
+  enabled: zod.z.boolean().default(false),
+  // Tracing granularity
+  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+  granularity: zod.z.enum(["fiber", "operator"]).default("fiber"),
+  // Smart span naming configuration
+  span_naming: zod.z.object({
+    // Default span name template when no rules match
+    default: zod.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: zod.z.boolean().default(true),
+    // Naming rules (first match wins)
+    rules: zod.z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern-based filtering
+  filter: zod.z.object({
+    // Only trace spans matching these patterns (empty = trace all)
+    include: zod.z.array(zod.z.string()).default([]),
+    // Never trace spans matching these patterns
+    exclude: zod.z.array(zod.z.string()).default([])
+  }).default({}),
+  // Performance controls
+  performance: zod.z.object({
+    // Sample rate (0.0 - 1.0)
+    sampling_rate: zod.z.number().min(0).max(1).default(1),
+    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+    min_duration: zod.z.string().default("0ms"),
+    // Maximum concurrent traced fibers (0 = unlimited)
+    max_concurrent: zod.z.number().default(0)
+  }).default({}),
+  // Automatic metadata extraction
+  metadata: zod.z.object({
+    // Extract Effect fiber information
+    fiber_info: zod.z.boolean().default(true),
+    // Extract source location (file:line)
+    source_location: zod.z.boolean().default(true),
+    // Extract parent fiber information
+    parent_fiber: zod.z.boolean().default(true)
+  }).default({})
+});
 var HttpFilteringConfigSchema = zod.z.object({
   // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
   ignore_outgoing_urls: zod.z.array(zod.z.string()).optional(),
@@ -90,6 +152,30 @@ 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(),
+  // Custom headers to send with OTLP requests (for type: otlp)
+  // Useful for authentication (x-api-key, Authorization, etc.)
+  headers: zod.z.record(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({
@@ -100,11 +186,54 @@ var InstrumentationConfigSchema = zod.z.object({
     ignore_patterns: zod.z.array(PatternConfigSchema)
   }),
   effect: zod.z.object({
+    // Enable/disable Effect tracing entirely
+    // When false, EffectInstrumentationLive returns Layer.empty
+    enabled: zod.z.boolean().default(true),
+    // 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_isolation: AutoIsolationConfigSchema.optional(),
+    // Auto-instrumentation: automatic tracing of all Effect fibers
+    auto_instrumentation: AutoInstrumentationConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });
+var defaultConfig = {
+  version: "1.0",
+  instrumentation: {
+    enabled: true,
+    logging: "on",
+    description: "Default instrumentation configuration",
+    instrument_patterns: [
+      { pattern: "^app\\.", enabled: true, description: "Application operations" },
+      { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
+      { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
+    ],
+    ignore_patterns: [
+      { pattern: "^test\\.", description: "Test utilities" },
+      { pattern: "^internal\\.", description: "Internal operations" },
+      { pattern: "^health\\.", description: "Health checks" }
+    ]
+  },
+  effect: {
+    enabled: true,
+    exporter: "unified",
+    auto_extract_metadata: true
+  }
+};
+function parseAndValidateConfig(content) {
+  let parsed;
+  if (typeof content === "string") {
+    parsed = yaml.parse(content);
+  } else {
+    parsed = content;
+  }
+  return InstrumentationConfigSchema.parse(parsed);
+}
 (class extends effect.Data.TaggedError("ConfigError") {
   get message() {
     return this.reason;
@@ -282,7 +411,7 @@ var makeConfigLoader = effect.Effect.gen(function* () {
     })
   });
 });
-var ConfigLoaderLive = effect.Layer.effect(ConfigLoader, makeConfigLoader);
+effect.Layer.effect(ConfigLoader, makeConfigLoader);
 var PatternMatcher = class {
   constructor(config) {
     __publicField(this, "ignorePatterns", []);
@@ -430,84 +559,58 @@ var Logger = class {
   }
 };
 var logger = new Logger();
-var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
-  effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
-);
-var cachedLoaderPromise = null;
-function getCachedLoader() {
-  if (!cachedLoaderPromise) {
-    cachedLoaderPromise = effect.Effect.runPromise(
-      effect.Effect.gen(function* () {
-        return yield* ConfigLoader;
-      }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
-    );
+async function loadFromFile(filePath) {
+  const { readFile } = await import('fs/promises');
+  const content = await readFile(filePath, "utf-8");
+  return parseAndValidateConfig(content);
+}
+async function loadFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch config from ${url}: ${response.statusText}`);
   }
-  return cachedLoaderPromise;
+  const content = await response.text();
+  return parseAndValidateConfig(content);
 }
-async function loadConfig(uri, options) {
-  if (options?.cacheTimeout === 0) {
-    const program = effect.Effect.gen(function* () {
-      const loader2 = yield* ConfigLoader;
-      return yield* loader2.loadFromUri(uri);
-    });
-    return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
+async function loadConfig(uri, _options) {
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return loadFromUrl(uri);
   }
-  const loader = await getCachedLoader();
-  return effect.Effect.runPromise(loader.loadFromUri(uri));
+  if (uri.startsWith("file://")) {
+    const filePath = uri.slice(7);
+    return loadFromFile(filePath);
+  }
+  return loadFromFile(uri);
 }
 async function loadConfigFromInline(content) {
-  const loader = await getCachedLoader();
-  return effect.Effect.runPromise(loader.loadFromInline(content));
-}
-function getDefaultConfig() {
-  return {
-    version: "1.0",
-    instrumentation: {
-      enabled: true,
-      logging: "on",
-      description: "Default instrumentation configuration",
-      instrument_patterns: [
-        { pattern: "^app\\.", enabled: true, description: "Application operations" },
-        { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
-        { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
-      ],
-      ignore_patterns: [
-        { pattern: "^test\\.", description: "Test utilities" },
-        { pattern: "^internal\\.", description: "Internal operations" },
-        { pattern: "^health\\.", description: "Health checks" }
-      ]
-    },
-    effect: {
-      auto_extract_metadata: true
-    }
-  };
+  return parseAndValidateConfig(content);
 }
 async function loadConfigWithOptions(options = {}) {
-  const loadOptions = options.cacheTimeout !== void 0 ? { cacheTimeout: options.cacheTimeout } : void 0;
   if (options.config) {
     return loadConfigFromInline(options.config);
   }
   const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
   if (envConfigPath) {
-    return loadConfig(envConfigPath, loadOptions);
+    return loadConfig(envConfigPath);
   }
   if (options.configUrl) {
-    return loadConfig(options.configUrl, loadOptions);
+    return loadConfig(options.configUrl);
   }
   if (options.configPath) {
-    return loadConfig(options.configPath, loadOptions);
+    return loadConfig(options.configPath);
   }
   const { existsSync } = await import('fs');
   const { join } = await import('path');
   const defaultPath = join(process.cwd(), "instrumentation.yaml");
   if (existsSync(defaultPath)) {
-    return loadConfig(defaultPath, loadOptions);
+    return loadConfig(defaultPath);
   }
-  return getDefaultConfig();
+  return defaultConfig;
 }
 
 // src/integrations/effect/effect-tracer.ts
-var SDK_NAME = "@effect/opentelemetry-otlp";
+var SDK_NAME = "@effect/opentelemetry";
+var ATTR_TELEMETRY_EXPORTER_MODE = "telemetry.exporter.mode";
 function createEffectInstrumentation(options = {}) {
   return effect.Layer.unwrapEffect(
     effect.Effect.gen(function* () {
@@ -518,90 +621,89 @@ function createEffectInstrumentation(options = {}) {
           message: error instanceof Error ? error.message : String(error)
         })
       });
+      const effectEnabled = process.env.OTEL_EFFECT_ENABLED !== "false" && (config.effect?.enabled ?? true);
+      if (!effectEnabled) {
+        logger.log("@atrim/instrumentation/effect: Effect tracing disabled via config");
+        return effect.Layer.empty;
+      }
       yield* effect.Effect.sync(() => {
         const loggingLevel = config.instrumentation.logging || "on";
         logger.setLevel(loggingLevel);
       });
       yield* effect.Effect.sync(() => initializePatternMatcher(config));
-      const otlpEndpoint = options.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
       const serviceName = options.serviceName || process.env.OTEL_SERVICE_NAME || "effect-service";
       const serviceVersion = options.serviceVersion || process.env.npm_package_version || "1.0.0";
-      const autoExtractMetadata = options.autoExtractMetadata ?? config.effect?.auto_extract_metadata ?? true;
-      const continueExistingTraces = options.continueExistingTraces ?? true;
-      logger.log("\u{1F50D} Effect OpenTelemetry instrumentation");
-      logger.log(`   \u{1F4E1} Endpoint: ${otlpEndpoint}`);
-      logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
-      logger.log(`   \u2705 Auto metadata extraction: ${autoExtractMetadata}`);
-      logger.log(`   \u2705 Continue existing traces: ${continueExistingTraces}`);
-      const otlpLayer = Otlp__namespace.layer({
-        baseUrl: otlpEndpoint,
-        resource: {
-          serviceName,
-          serviceVersion,
-          attributes: {
-            "platform.component": "effect",
-            "effect.auto_metadata": autoExtractMetadata,
-            "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
-        // This is essential for context propagation to work properly
-        tracerContext: (f, span) => {
-          if (span._tag !== "Span") {
-            return f();
+      const exporterMode = options.exporterMode ?? config.effect?.exporter ?? "unified";
+      const resourceAttributes = {
+        "platform.component": "effect",
+        [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: semanticConventions.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+        [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+        [ATTR_TELEMETRY_EXPORTER_MODE]: exporterMode
+      };
+      if (exporterMode === "standalone") {
+        const otlpEndpoint = options.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+        logger.log("Effect OpenTelemetry instrumentation (standalone)");
+        logger.log(`  Service: ${serviceName}`);
+        logger.log(`  Endpoint: ${otlpEndpoint}`);
+        logger.log("  WARNING: Standalone mode bypasses Node SDK filtering");
+        return Otlp__namespace.layer({
+          baseUrl: otlpEndpoint,
+          resource: {
+            serviceName,
+            serviceVersion,
+            attributes: resourceAttributes
+          },
+          // Bridge Effect context to OpenTelemetry global context
+          tracerContext: (f, span) => {
+            if (span._tag !== "Span") {
+              return f();
+            }
+            const spanContext = {
+              traceId: span.traceId,
+              spanId: span.spanId,
+              traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
+            };
+            const otelSpan = api.trace.wrapSpanContext(spanContext);
+            return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
           }
-          const spanContext = {
-            traceId: span.traceId,
-            spanId: span.spanId,
-            traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
-          };
-          const otelSpan = api.trace.wrapSpanContext(spanContext);
-          return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
-        }
-      }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
-      if (autoExtractMetadata) {
-        return otlpLayer;
+        }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+      } else {
+        logger.log("Effect OpenTelemetry instrumentation (unified)");
+        logger.log(`  Service: ${serviceName}`);
+        logger.log("  Using global TracerProvider for span export");
+        return Tracer__namespace.layerGlobal.pipe(
+          effect.Layer.provide(
+            Resource__namespace.layer({
+              serviceName,
+              serviceVersion,
+              attributes: resourceAttributes
+            })
+          )
+        );
       }
-      return otlpLayer;
     })
   ).pipe(effect.Layer.orDie);
 }
 var EffectInstrumentationLive = effect.Effect.sync(() => {
-  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
   const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
   const serviceVersion = process.env.npm_package_version || "1.0.0";
   logger.minimal(`@atrim/instrumentation/effect: Effect tracing enabled (${serviceName})`);
-  logger.log("\u{1F50D} Effect OpenTelemetry tracer");
-  logger.log(`   \u{1F4E1} Endpoint: ${endpoint}`);
-  logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
-  return Otlp__namespace.layer({
-    baseUrl: endpoint,
-    resource: {
-      serviceName,
-      serviceVersion,
-      attributes: {
-        "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
-    // This allows NodeSDK auto-instrumentation to see Effect spans as parent spans
-    tracerContext: (f, span) => {
-      if (span._tag !== "Span") {
-        return f();
-      }
-      const spanContext = {
-        traceId: span.traceId,
-        spanId: span.spanId,
-        traceFlags: span.sampled ? api.TraceFlags.SAMPLED : api.TraceFlags.NONE
-      };
-      const otelSpan = api.trace.wrapSpanContext(spanContext);
-      return api.context.with(api.trace.setSpan(api.context.active(), otelSpan), f);
-    }
-  }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
+  logger.log("Effect OpenTelemetry tracer (unified)");
+  logger.log(`  Service: ${serviceName}`);
+  return Tracer__namespace.layerGlobal.pipe(
+    effect.Layer.provide(
+      Resource__namespace.layer({
+        serviceName,
+        serviceVersion,
+        attributes: {
+          "platform.component": "effect",
+          [semanticConventions.ATTR_TELEMETRY_SDK_LANGUAGE]: semanticConventions.TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+          [semanticConventions.ATTR_TELEMETRY_SDK_NAME]: SDK_NAME,
+          [ATTR_TELEMETRY_EXPORTER_MODE]: "unified"
+        }
+      })
+    )
+  );
 }).pipe(effect.Layer.unwrapEffect);
 function annotateUser(userId, email, username) {
   const attributes = {