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

package/target/dist/index.js

@@ -1,10 +1,13 @@
-import { Data, Effect, Layer } from 'effect';
+import { Data, Context, Effect, Layer } from 'effect';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 import { trace } from '@opentelemetry/api';
-import { ConfigLoaderLive, PatternMatcher, ConfigLoader, initializePatternMatcher, logger } from '@atrim/instrument-core';
-export { PatternMatcher, getPatternMatcher, shouldInstrumentSpan } from '@atrim/instrument-core';
+import { FileSystem } from '@effect/platform/FileSystem';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import { parse } from 'yaml';
+import { z } from 'zod';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
@@ -20,6 +23,396 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var PatternConfigSchema = z.object({
+  pattern: z.string(),
+  enabled: z.boolean().optional(),
+  description: z.string().optional()
+});
+var AutoIsolationConfigSchema = z.object({
+  // Global enable/disable for auto-isolation
+  enabled: z.boolean().default(false),
+  // Which operators to auto-isolate
+  operators: z.object({
+    fiberset_run: z.boolean().default(true),
+    effect_fork: z.boolean().default(true),
+    effect_fork_daemon: z.boolean().default(true),
+    effect_fork_in: z.boolean().default(false)
+  }).default({}),
+  // Virtual parent tracking configuration
+  tracking: z.object({
+    use_span_links: z.boolean().default(true),
+    use_attributes: z.boolean().default(true),
+    capture_logical_parent: z.boolean().default(true)
+  }).default({}),
+  // Span categorization
+  attributes: z.object({
+    category: z.string().default("background_task"),
+    add_metadata: z.boolean().default(true)
+  }).default({})
+});
+var HttpFilteringConfigSchema = z.object({
+  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
+  ignore_outgoing_urls: z.array(z.string()).optional(),
+  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+  ignore_incoming_paths: z.array(z.string()).optional(),
+  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+  require_parent_for_outgoing_spans: z.boolean().optional()
+});
+var InstrumentationConfigSchema = z.object({
+  version: z.string(),
+  instrumentation: z.object({
+    enabled: z.boolean(),
+    description: z.string().optional(),
+    logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
+    instrument_patterns: z.array(PatternConfigSchema),
+    ignore_patterns: z.array(PatternConfigSchema)
+  }),
+  effect: z.object({
+    auto_extract_metadata: z.boolean(),
+    auto_isolation: AutoIsolationConfigSchema.optional()
+  }).optional(),
+  http: HttpFilteringConfigSchema.optional()
+});
+(class extends Data.TaggedError("ConfigError") {
+  get message() {
+    return this.reason;
+  }
+});
+var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+  get message() {
+    return this.reason;
+  }
+};
+var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+  get message() {
+    return this.reason;
+  }
+};
+(class extends Data.TaggedError("ServiceDetectionError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("InitializationError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("ExportError") {
+  get message() {
+    return this.reason;
+  }
+});
+(class extends Data.TaggedError("ShutdownError") {
+  get message() {
+    return this.reason;
+  }
+});
+var SECURITY_DEFAULTS = {
+  maxConfigSize: 1e6,
+  // 1MB
+  requestTimeout: 5e3
+  // 5 seconds
+};
+var ConfigLoader = class extends Context.Tag("ConfigLoader")() {
+};
+var parseYamlContent = (content, uri) => Effect.gen(function* () {
+  const parsed = yield* Effect.try({
+    try: () => parse(content),
+    catch: (error) => new ConfigValidationError({
+      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
+      cause: error
+    })
+  });
+  return yield* 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.gen(function* () {
+  const content = yield* fs.readFileString(path).pipe(
+    Effect.mapError(
+      (error) => new ConfigFileError({
+        reason: `Failed to read config file at ${uri}`,
+        cause: error
+      })
+    )
+  );
+  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
+    return yield* 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.scoped(
+  Effect.gen(function* () {
+    if (url.startsWith("http://")) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: "Insecure protocol: only HTTPS URLs are allowed"
+        })
+      );
+    }
+    const request = HttpClientRequest.get(url).pipe(
+      HttpClientRequest.setHeaders({
+        Accept: "application/yaml, text/yaml, application/x-yaml"
+      })
+    );
+    const response = yield* client.execute(request).pipe(
+      Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+      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.fail(
+        new ConfigUrlError({
+          reason: `HTTP ${response.status} from ${url}`
+        })
+      );
+    }
+    const text = yield* response.text.pipe(
+      Effect.mapError(
+        (error) => new ConfigUrlError({
+          reason: `Failed to read response body from ${url}`,
+          cause: error
+        })
+      )
+    );
+    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+      return yield* Effect.fail(
+        new ConfigUrlError({
+          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+        })
+      );
+    }
+    return yield* parseYamlContent(text, url);
+  })
+);
+var makeConfigLoader = Effect.gen(function* () {
+  const fs = yield* Effect.serviceOption(FileSystem);
+  const http = yield* HttpClient.HttpClient;
+  const loadFromUriUncached = (uri) => Effect.gen(function* () {
+    if (uri.startsWith("file://")) {
+      const path = uri.slice(7);
+      if (fs._tag === "None") {
+        return yield* 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.cachedFunction(loadFromUriUncached);
+  return ConfigLoader.of({
+    loadFromUri: loadFromUriCached,
+    loadFromInline: (content) => Effect.gen(function* () {
+      if (typeof content === "string") {
+        return yield* parseYamlContent(content);
+      }
+      return yield* Effect.try({
+        try: () => InstrumentationConfigSchema.parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: "Invalid configuration schema",
+          cause: error
+        })
+      });
+    })
+  });
+});
+var ConfigLoaderLive = Layer.effect(ConfigLoader, makeConfigLoader);
+var PatternMatcher = class {
+  constructor(config) {
+    __publicField2(this, "ignorePatterns", []);
+    __publicField2(this, "instrumentPatterns", []);
+    __publicField2(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
+    };
+  }
+};
+var globalMatcher = null;
+function initializePatternMatcher(config) {
+  globalMatcher = new PatternMatcher(config);
+}
+function shouldInstrumentSpan(spanName) {
+  if (!globalMatcher) {
+    return true;
+  }
+  return globalMatcher.shouldInstrument(spanName);
+}
+function getPatternMatcher() {
+  return globalMatcher;
+}
+var Logger = class {
+  constructor() {
+    __publicField2(this, "level", "on");
+    __publicField2(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();
+
+// src/core/span-processor.ts
 var PatternSpanProcessor = class {
   constructor(config, wrappedProcessor) {
     __publicField(this, "matcher");
@@ -97,6 +490,8 @@ function getOtlpEndpoint(options = {}) {
   const endpoint = options.endpoint || process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || DEFAULT_OTLP_ENDPOINT;
   return normalizeEndpoint(endpoint);
 }
+
+// src/core/safe-exporter.ts
 var SafeSpanExporter = class {
   // Log errors max once per minute
   constructor(exporter) {
@@ -196,21 +591,21 @@ var SafeSpanExporter = class {
     return false;
   }
 };
-var ConfigError = class extends Data.TaggedError("ConfigError") {
+var ConfigError2 = class extends Data.TaggedError("ConfigError") {
 };
-var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+var ConfigUrlError2 = class extends Data.TaggedError("ConfigUrlError") {
 };
-var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+var ConfigValidationError2 = class extends Data.TaggedError("ConfigValidationError") {
 };
-var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+var ConfigFileError2 = class extends Data.TaggedError("ConfigFileError") {
 };
-var ServiceDetectionError = class extends Data.TaggedError("ServiceDetectionError") {
+var ServiceDetectionError2 = class extends Data.TaggedError("ServiceDetectionError") {
 };
-var InitializationError = class extends Data.TaggedError("InitializationError") {
+var InitializationError2 = class extends Data.TaggedError("InitializationError") {
 };
-var ExportError = class extends Data.TaggedError("ExportError") {
+var ExportError2 = class extends Data.TaggedError("ExportError") {
 };
-var ShutdownError = class extends Data.TaggedError("ShutdownError") {
+var ShutdownError2 = class extends Data.TaggedError("ShutdownError") {
 };
 
 // src/core/service-detector.ts
@@ -227,7 +622,7 @@ var detectServiceInfo = Effect.gen(
     const packageJsonPath = join(process.cwd(), "package.json");
     const packageJsonContent = yield* Effect.tryPromise({
       try: () => readFile(packageJsonPath, "utf-8"),
-      catch: (error) => new ServiceDetectionError({
+      catch: (error) => new ServiceDetectionError2({
         reason: `Failed to read package.json at ${packageJsonPath}`,
         cause: error
       })
@@ -237,7 +632,7 @@ var detectServiceInfo = Effect.gen(
       parsed = JSON.parse(packageJsonContent);
     } catch (error) {
       yield* Effect.fail(
-        new ServiceDetectionError({
+        new ServiceDetectionError2({
           reason: "Invalid JSON in package.json",
           cause: error
         })
@@ -253,7 +648,7 @@ var detectServiceInfo = Effect.gen(
       }
     }
     return yield* Effect.fail(
-      new ServiceDetectionError({
+      new ServiceDetectionError2({
         reason: 'package.json exists but has no "name" field'
       })
     );
@@ -652,6 +1047,8 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
   logger.log(`  - OTLP endpoint: ${endpoint}`);
   logger.log("");
 }
+
+// src/api.ts
 async function initializeInstrumentation(options = {}) {
   const sdk = await initializeSdk(options);
   if (sdk) {
@@ -671,7 +1068,7 @@ async function initializePatternMatchingOnly(options = {}) {
 var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* () {
   const sdk = yield* Effect.tryPromise({
     try: () => initializeSdk(options),
-    catch: (error) => new InitializationError({
+    catch: (error) => new InitializationError2({
       reason: "SDK initialization failed",
       cause: error
     })
@@ -679,7 +1076,7 @@ var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* ()
   if (sdk) {
     yield* Effect.tryPromise({
       try: () => loadConfigWithOptions(options),
-      catch: (error) => new ConfigError({
+      catch: (error) => new ConfigError2({
         reason: "Failed to load config for pattern matcher",
         cause: error
       })
@@ -696,7 +1093,7 @@ var initializeInstrumentationEffect = (options = {}) => Effect.gen(function* ()
 var initializePatternMatchingOnlyEffect = (options = {}) => Effect.gen(function* () {
   const config = yield* Effect.tryPromise({
     try: () => loadConfigWithOptions(options),
-    catch: (error) => new ConfigError({
+    catch: (error) => new ConfigError2({
       reason: "Failed to load configuration",
       cause: error
     })
@@ -804,6 +1201,6 @@ function suppressShutdownErrors() {
   });
 }
 
-export { ConfigError, ConfigFileError, ConfigUrlError, ConfigValidationError, ExportError, InitializationError, PatternSpanProcessor, ServiceDetectionError, ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shutdownSdk, suppressShutdownErrors };
+export { ConfigError2 as ConfigError, ConfigFileError2 as ConfigFileError, ConfigUrlError2 as ConfigUrlError, ConfigValidationError2 as ConfigValidationError, ExportError2 as ExportError, InitializationError2 as InitializationError, PatternMatcher, PatternSpanProcessor, ServiceDetectionError2 as ServiceDetectionError, ShutdownError2 as ShutdownError, annotateCacheOperation, annotateDbQuery, annotateHttpRequest, _resetConfigLoaderCache as clearConfigCache, createOtlpExporter, detectServiceInfoAsync as detectServiceInfo, detectServiceInfo as detectServiceInfoEffect, getOtlpEndpoint, getPatternMatcher, getSdkInstance, getServiceInfoWithFallback, getServiceNameAsync as getServiceName, getServiceName as getServiceNameEffect, getServiceVersionAsync as getServiceVersion, getServiceVersion as getServiceVersionEffect, initializeInstrumentation, initializeInstrumentationEffect, initializePatternMatchingOnly, initializePatternMatchingOnlyEffect, loadConfig, loadConfigFromInline, loadConfigWithOptions, markSpanError, markSpanSuccess, recordException, resetSdk, setSpanAttributes, shouldInstrumentSpan, shutdownSdk, suppressShutdownErrors };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map