@atrim/instrument-node 0.4.0-c3ef89c-20251118193817 → 0.4.1

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

@@ -4,7 +4,11 @@ var effect = require('effect');
 var Otlp = require('@effect/opentelemetry/Otlp');
 var platform = require('@effect/platform');
 var api = require('@opentelemetry/api');
-var instrumentCore = require('@atrim/instrument-core');
+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) {
@@ -26,9 +30,389 @@ function _interopNamespace(e) {
 }
 
 var Otlp__namespace = /*#__PURE__*/_interopNamespace(Otlp);
+var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
+var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
 
 // src/integrations/effect/effect-tracer.ts
-var NodeConfigLoaderLive = instrumentCore.ConfigLoaderLive.pipe(
+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);
+var PatternConfigSchema = zod.z.object({
+  pattern: zod.z.string(),
+  enabled: zod.z.boolean().optional(),
+  description: zod.z.string().optional()
+});
+var AutoIsolationConfigSchema = zod.z.object({
+  // Global enable/disable for auto-isolation
+  enabled: zod.z.boolean().default(false),
+  // Which operators to auto-isolate
+  operators: zod.z.object({
+    fiberset_run: zod.z.boolean().default(true),
+    effect_fork: zod.z.boolean().default(true),
+    effect_fork_daemon: zod.z.boolean().default(true),
+    effect_fork_in: zod.z.boolean().default(false)
+  }).default({}),
+  // Virtual parent tracking configuration
+  tracking: zod.z.object({
+    use_span_links: zod.z.boolean().default(true),
+    use_attributes: zod.z.boolean().default(true),
+    capture_logical_parent: zod.z.boolean().default(true)
+  }).default({}),
+  // Span categorization
+  attributes: zod.z.object({
+    category: zod.z.string().default("background_task"),
+    add_metadata: 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(),
+  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+  ignore_incoming_paths: zod.z.array(zod.z.string()).optional(),
+  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+  require_parent_for_outgoing_spans: zod.z.boolean().optional()
+});
+var InstrumentationConfigSchema = zod.z.object({
+  version: zod.z.string(),
+  instrumentation: zod.z.object({
+    enabled: zod.z.boolean(),
+    description: zod.z.string().optional(),
+    logging: zod.z.enum(["on", "off", "minimal"]).optional().default("on"),
+    instrument_patterns: zod.z.array(PatternConfigSchema),
+    ignore_patterns: zod.z.array(PatternConfigSchema)
+  }),
+  effect: zod.z.object({
+    auto_extract_metadata: zod.z.boolean(),
+    auto_isolation: AutoIsolationConfigSchema.optional()
+  }).optional(),
+  http: HttpFilteringConfigSchema.optional()
+});
+(class extends effect.Data.TaggedError("ConfigError") {
+  get message() {
+    return this.reason;
+  }
+});
+var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
+};
+(class extends effect.Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends effect.Data.TaggedError("ShutdownError") {
+  get message() {
+    return this.reason;
+  }
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3
+  // 5 seconds
+};
+var ConfigLoader = class extends effect.Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => effect.Effect.gen(function* () {
+  const parsed = yield* effect.Effect.try({
+    try: () => yaml.parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* effect.Effect.try({
+    try: () => InstrumentationConfigSchema.parse(parsed),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
+      cause: error
+    })
+  });
+});
+var loadFromFileWithFs = (fs, path, uri) => effect.Effect.gen(function* () {
+  const content = yield* fs.readFileString(path).pipe(
+    effect.Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* effect.Effect.fail(
+      new ConfigFileError({
+        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+      })
+    );
+  }
+  return yield* parseYamlContent(content, uri);
+});
+var loadFromHttpWithClient = (client, url) => effect.Effect.scoped(
+  effect.Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest__namespace.get(url).pipe(
+      HttpClientRequest__namespace.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
+      })
+    );
+    const response = yield* client.execute(request).pipe(
+      effect.Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      effect.Effect.mapError((error) => {
+        if (error._tag === "TimeoutException") {
+          return new ConfigUrlError({
+            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms from ${url}`
+          });
+        }
+        return new ConfigUrlError({
+          reason: `Failed to load config from URL: ${url}`,
+          cause: error
+        });
+      })
+    );
+    if (response.status >= 400) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      effect.Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          cause: error
+        })
+      )
+    );
+    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+      return yield* effect.Effect.fail(
+        new ConfigUrlError({
+          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = effect.Effect.gen(function* () {
+  const fs = yield* effect.Effect.serviceOption(FileSystem.FileSystem);
+  const http = yield* HttpClient__namespace.HttpClient;
+  const loadFromUriUncached = (uri) => effect.Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* effect.Effect.fail(
+          new ConfigFileError({
+            reason: "FileSystem not available (browser environment?)",
+            cause: { uri }
+          })
+        );
+      }
+      return yield* loadFromFileWithFs(fs.value, path, uri);
+    }
+    if (uri.startsWith("http://") || uri.startsWith("https://")) {
+      return yield* loadFromHttpWithClient(http, uri);
+    }
+    if (fs._tag === "Some") {
+      return yield* loadFromFileWithFs(fs.value, uri, uri);
+    } else {
+      return yield* loadFromHttpWithClient(http, uri);
+    }
+  });
+  const loadFromUriCached = yield* effect.Effect.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => effect.Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* effect.Effect.try({
+        try: () => InstrumentationConfigSchema.parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: "Invalid configuration schema",
+          cause: error
+        })
+      });
+    })
+  });
+});
+var ConfigLoaderLive = effect.Layer.effect(ConfigLoader, makeConfigLoader);
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField(this, "ignorePatterns", []);
+    __publicField(this, "instrumentPatterns", []);
+    __publicField(this, "enabled", true);
+    this.enabled = config.instrumentation.enabled;
+    this.ignorePatterns = config.instrumentation.ignore_patterns.map((p) => this.compilePattern(p));
+    this.instrumentPatterns = config.instrumentation.instrument_patterns.filter((p) => p.enabled !== false).map((p) => this.compilePattern(p));
+  }
+  /**
+   * Compile a pattern configuration into a RegExp
+   */
+  compilePattern(pattern) {
+    try {
+      const compiled = {
+        regex: new RegExp(pattern.pattern),
+        enabled: pattern.enabled !== false
+      };
+      if (pattern.description !== void 0) {
+        compiled.description = pattern.description;
+      }
+      return compiled;
+    } catch (error) {
+      throw new Error(
+        `Failed to compile pattern "${pattern.pattern}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if a span should be instrumented
+   *
+   * Returns true if the span should be created, false otherwise.
+   *
+   * Logic:
+   * 1. If instrumentation disabled globally, return false
+   * 2. Check ignore patterns - if any match, return false
+   * 3. Check instrument patterns - if any match, return true
+   * 4. Default: return true (fail-open - create span if no patterns match)
+   */
+  shouldInstrument(spanName) {
+    if (!this.enabled) {
+      return false;
+    }
+    for (const pattern of this.ignorePatterns) {
+      if (pattern.regex.test(spanName)) {
+        return false;
+      }
+    }
+    for (const pattern of this.instrumentPatterns) {
+      if (pattern.enabled && pattern.regex.test(spanName)) {
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get statistics about pattern matching (for debugging/monitoring)
+   */
+  getStats() {
+    return {
+      enabled: this.enabled,
+      ignorePatternCount: this.ignorePatterns.length,
+      instrumentPatternCount: this.instrumentPatterns.filter((p) => p.enabled).length
+    };
+  }
+};
+function initializePatternMatcher(config) {
+  new PatternMatcher(config);
+}
+var Logger = class {
+  constructor() {
+    __publicField(this, "level", "on");
+    __publicField(this, "hasLoggedMinimal", false);
+  }
+  /**
+   * Set the logging level
+   */
+  setLevel(level) {
+    this.level = level;
+    this.hasLoggedMinimal = false;
+  }
+  /**
+   * Get the current logging level
+   */
+  getLevel() {
+    return this.level;
+  }
+  /**
+   * Log a minimal initialization message (only shown once in minimal mode)
+   */
+  minimal(message) {
+    if (this.level === "off") {
+      return;
+    }
+    if (this.level === "minimal" && !this.hasLoggedMinimal) {
+      console.log(message);
+      this.hasLoggedMinimal = true;
+      return;
+    }
+    if (this.level === "on") {
+      console.log(message);
+    }
+  }
+  /**
+   * Log an informational message
+   */
+  log(...args) {
+    if (this.level === "on") {
+      console.log(...args);
+    }
+  }
+  /**
+   * Log a warning message (shown in minimal mode)
+   */
+  warn(...args) {
+    if (this.level !== "off") {
+      console.warn(...args);
+    }
+  }
+  /**
+   * Log an error message (shown in minimal mode)
+   */
+  error(...args) {
+    if (this.level !== "off") {
+      console.error(...args);
+    }
+  }
+  /**
+   * Check if full logging is enabled
+   */
+  isEnabled() {
+    return this.level === "on";
+  }
+  /**
+   * Check if minimal logging is enabled
+   */
+  isMinimal() {
+    return this.level === "minimal";
+  }
+  /**
+   * Check if logging is completely disabled
+   */
+  isDisabled() {
+    return this.level === "off";
+  }
+};
+var logger = new Logger();
+var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
   effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
 );
 var cachedLoaderPromise = null;
@@ -36,7 +420,7 @@ function getCachedLoader() {
   if (!cachedLoaderPromise) {
     cachedLoaderPromise = effect.Effect.runPromise(
       effect.Effect.gen(function* () {
-        return yield* instrumentCore.ConfigLoader;
+        return yield* ConfigLoader;
       }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
     );
   }
@@ -45,7 +429,7 @@ function getCachedLoader() {
 async function loadConfig(uri, options) {
   if (options?.cacheTimeout === 0) {
     const program = effect.Effect.gen(function* () {
-      const loader2 = yield* instrumentCore.ConfigLoader;
+      const loader2 = yield* ConfigLoader;
       return yield* loader2.loadFromUri(uri);
     });
     return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
@@ -117,19 +501,19 @@ function createEffectInstrumentation(options = {}) {
       });
       yield* effect.Effect.sync(() => {
         const loggingLevel = config.instrumentation.logging || "on";
-        instrumentCore.logger.setLevel(loggingLevel);
+        logger.setLevel(loggingLevel);
       });
-      yield* effect.Effect.sync(() => instrumentCore.initializePatternMatcher(config));
+      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;
-      instrumentCore.logger.log("\u{1F50D} Effect OpenTelemetry instrumentation");
-      instrumentCore.logger.log(`   \u{1F4E1} Endpoint: ${otlpEndpoint}`);
-      instrumentCore.logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
-      instrumentCore.logger.log(`   \u2705 Auto metadata extraction: ${autoExtractMetadata}`);
-      instrumentCore.logger.log(`   \u2705 Continue existing traces: ${continueExistingTraces}`);
+      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: {
@@ -167,10 +551,10 @@ 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";
-  instrumentCore.logger.minimal(`@atrim/instrumentation/effect: Effect tracing enabled (${serviceName})`);
-  instrumentCore.logger.log("\u{1F50D} Effect OpenTelemetry tracer");
-  instrumentCore.logger.log(`   \u{1F4E1} Endpoint: ${endpoint}`);
-  instrumentCore.logger.log(`   \u{1F3F7}\uFE0F  Service: ${serviceName}`);
+  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: {