@atrim/instrument-node 0.5.2-dev.ac2fbfe.20251221205322 → 0.6.0

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);
@@ -100,11 +99,50 @@ 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:
+    // - "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"),
     auto_extract_metadata: zod.z.boolean(),
     auto_isolation: AutoIsolationConfigSchema.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 +320,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 +468,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 +530,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 = {