@atrim/instrument-node 0.1.3-fea6398-20251118005809 → 0.4.0-08fae61-20251118193009

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

@@ -4,10 +4,8 @@ var effect = require('effect');
 var Otlp = require('@effect/opentelemetry/Otlp');
 var platform = require('@effect/platform');
 var api = require('@opentelemetry/api');
-var fs = require('fs');
-var path = require('path');
-var yaml = require('yaml');
-var zod = require('zod');
+var instrumentCore = require('@atrim/instrument-core');
+var platformNode = require('@effect/platform-node');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -30,84 +28,35 @@ function _interopNamespace(e) {
 var Otlp__namespace = /*#__PURE__*/_interopNamespace(Otlp);
 
 // src/integrations/effect/effect-tracer.ts
-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") {
-});
-var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
-};
-var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
-};
-var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
-};
-(class extends effect.Data.TaggedError("ServiceDetectionError") {
-});
-(class extends effect.Data.TaggedError("InitializationError") {
-});
-(class extends effect.Data.TaggedError("ExportError") {
-});
-(class extends effect.Data.TaggedError("ShutdownError") {
-});
-var SECURITY_DEFAULTS = {
-  maxConfigSize: 1e6,
-  // 1MB
-  requestTimeout: 5e3,
-  allowedProtocols: ["https:"],
-  // Only HTTPS for remote configs
-  cacheTimeout: 3e5
-  // 5 minutes
-};
+var NodeConfigLoaderLive = instrumentCore.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* instrumentCore.ConfigLoader;
+      }).pipe(effect.Effect.provide(NodeConfigLoaderLive))
+    );
+  }
+  return cachedLoaderPromise;
+}
+async function loadConfig(uri, options) {
+  if (options?.cacheTimeout === 0) {
+    const program = effect.Effect.gen(function* () {
+      const loader2 = yield* instrumentCore.ConfigLoader;
+      return yield* loader2.loadFromUri(uri);
+    });
+    return effect.Effect.runPromise(program.pipe(effect.Effect.provide(NodeConfigLoaderLive)));
+  }
+  const loader = await getCachedLoader();
+  return effect.Effect.runPromise(loader.loadFromUri(uri));
+}
+async function loadConfigFromInline(content) {
+  const loader = await getCachedLoader();
+  return effect.Effect.runPromise(loader.loadFromInline(content));
+}
 function getDefaultConfig() {
   return {
     version: "1.0",
@@ -131,340 +80,36 @@ function getDefaultConfig() {
     }
   };
 }
-var validateConfigEffect = (rawConfig) => effect.Effect.try({
-  try: () => InstrumentationConfigSchema.parse(rawConfig),
-  catch: (error) => new ConfigValidationError({
-    reason: "Invalid configuration schema",
-    cause: error
-  })
-});
-var loadConfigFromFileEffect = (filePath) => effect.Effect.gen(function* () {
-  const fileContents = yield* effect.Effect.try({
-    try: () => fs.readFileSync(filePath, "utf8"),
-    catch: (error) => new ConfigFileError({
-      reason: `Failed to read config file at ${filePath}`,
-      cause: error
-    })
-  });
-  if (fileContents.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.Effect.fail(
-      new ConfigFileError({
-        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = yaml.parse(fileContents);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var fetchAndParseConfig = (url) => effect.Effect.gen(function* () {
-  let urlObj;
-  try {
-    urlObj = new URL(url);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Invalid URL: ${url}`,
-        cause: error
-      })
-    );
-  }
-  if (!SECURITY_DEFAULTS.allowedProtocols.includes(urlObj.protocol)) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Insecure protocol ${urlObj.protocol}. Only ${SECURITY_DEFAULTS.allowedProtocols.join(", ")} are allowed`
-      })
-    );
-  }
-  const response = yield* effect.Effect.tryPromise({
-    try: () => fetch(url, {
-      redirect: "follow",
-      headers: {
-        Accept: "application/yaml, text/yaml, text/x-yaml"
-      }
-    }),
-    catch: (error) => new ConfigUrlError({
-      reason: `Failed to load config from URL ${url}`,
-      cause: error
-    })
-  }).pipe(
-    effect.Effect.timeout(effect.Duration.millis(SECURITY_DEFAULTS.requestTimeout)),
-    effect.Effect.retry({
-      times: 3,
-      schedule: effect.Schedule.exponential(effect.Duration.millis(100))
-    }),
-    effect.Effect.catchAll((error) => {
-      if (error._tag === "TimeoutException") {
-        return effect.Effect.fail(
-          new ConfigUrlError({
-            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms`
-          })
-        );
-      }
-      return effect.Effect.fail(error);
-    })
-  );
-  if (!response.ok) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `HTTP ${response.status}: ${response.statusText}`
-      })
-    );
-  }
-  const contentLength = response.headers.get("content-length");
-  if (contentLength && parseInt(contentLength) > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.Effect.fail(
-      new ConfigUrlError({
-        reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  const text = yield* effect.Effect.tryPromise({
-    try: () => response.text(),
-    catch: (error) => new ConfigUrlError({
-      reason: "Failed to read response body",
-      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`
-      })
-    );
-  }
-  let rawConfig;
-  try {
-    rawConfig = yaml.parse(text);
-  } catch (error) {
-    return yield* effect.Effect.fail(
-      new ConfigValidationError({
-        reason: "Invalid YAML syntax",
-        cause: error
-      })
-    );
-  }
-  return yield* validateConfigEffect(rawConfig);
-});
-var makeConfigCache = () => effect.Cache.make({
-  capacity: 100,
-  timeToLive: effect.Duration.minutes(5),
-  lookup: (url) => fetchAndParseConfig(url)
-});
-var cacheInstance = null;
-var getCache = effect.Effect.gen(function* () {
-  if (!cacheInstance) {
-    cacheInstance = yield* makeConfigCache();
-  }
-  return cacheInstance;
-});
-var loadConfigFromUrlEffect = (url, cacheTimeout = SECURITY_DEFAULTS.cacheTimeout) => effect.Effect.gen(function* () {
-  if (cacheTimeout === 0) {
-    return yield* fetchAndParseConfig(url);
-  }
-  const cache = yield* getCache;
-  return yield* cache.get(url);
-});
-var loadConfigEffect = (options = {}) => effect.Effect.gen(function* () {
+async function loadConfigWithOptions(options = {}) {
+  const loadOptions = options.cacheTimeout !== void 0 ? { cacheTimeout: options.cacheTimeout } : void 0;
   if (options.config) {
-    return yield* validateConfigEffect(options.config);
+    return loadConfigFromInline(options.config);
   }
   const envConfigPath = process.env.ATRIM_INSTRUMENTATION_CONFIG;
   if (envConfigPath) {
-    if (envConfigPath.startsWith("http://") || envConfigPath.startsWith("https://")) {
-      return yield* loadConfigFromUrlEffect(envConfigPath, options.cacheTimeout);
-    }
-    return yield* loadConfigFromFileEffect(envConfigPath);
+    return loadConfig(envConfigPath, loadOptions);
   }
   if (options.configUrl) {
-    return yield* loadConfigFromUrlEffect(options.configUrl, options.cacheTimeout);
+    return loadConfig(options.configUrl, loadOptions);
   }
   if (options.configPath) {
-    return yield* loadConfigFromFileEffect(options.configPath);
+    return loadConfig(options.configPath, loadOptions);
   }
-  const defaultPath = path.join(process.cwd(), "instrumentation.yaml");
-  const exists = yield* effect.Effect.sync(() => fs.existsSync(defaultPath));
-  if (exists) {
-    return yield* loadConfigFromFileEffect(defaultPath);
+  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 getDefaultConfig();
-});
-async function loadConfig(options = {}) {
-  return effect.Effect.runPromise(
-    loadConfigEffect(options).pipe(
-      // Convert typed errors to regular Error with reason message for backward compatibility
-      effect.Effect.mapError((error) => {
-        const message = error.reason;
-        const newError = new Error(message);
-        newError.cause = error.cause;
-        return newError;
-      })
-    )
-  );
-}
-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();
 
 // src/integrations/effect/effect-tracer.ts
 function createEffectInstrumentation(options = {}) {
   return effect.Layer.unwrapEffect(
     effect.Effect.gen(function* () {
       const config = yield* effect.Effect.tryPromise({
-        try: () => loadConfig(options),
+        try: () => loadConfigWithOptions(options),
         catch: (error) => ({
           _tag: "ConfigError",
           message: error instanceof Error ? error.message : String(error)
@@ -472,19 +117,19 @@ function createEffectInstrumentation(options = {}) {
       });
       yield* effect.Effect.sync(() => {
         const loggingLevel = config.instrumentation.logging || "on";
-        logger.setLevel(loggingLevel);
+        instrumentCore.logger.setLevel(loggingLevel);
       });
-      yield* effect.Effect.sync(() => initializePatternMatcher(config));
+      yield* effect.Effect.sync(() => instrumentCore.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}`);
+      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}`);
       const otlpLayer = Otlp__namespace.layer({
         baseUrl: otlpEndpoint,
         resource: {
@@ -522,10 +167,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";
-  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}`);
+  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}`);
   return Otlp__namespace.layer({
     baseUrl: endpoint,
     resource: {