@atrim/instrument-node 0.4.1 → 0.5.0-c05e3a1-20251119131235

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atrim/instrument-node",
-  "version": "0.4.1",
+  "version": "0.5.0-c05e3a1-20251119131235",
   "description": "OpenTelemetry instrumentation for Node.js with centralized YAML configuration",
   "type": "module",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "tsx": "^4.7.0",
     "typescript": "^5.7.2",
     "vitest": "^4.0.8",
-    "@atrim/instrument-core": "0.4.1"
+    "@atrim/instrument-core": "0.5.0"
   },
   "peerDependencies": {
     "@effect/opentelemetry": ">=0.40.0",
@@ -122,10 +122,10 @@
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
     "clean": "rm -rf target",
-    "publish:dev:version": "npm version $(git describe --tags --abbrev=0 | sed 's/^.*@//' | sed 's/^v//')-$(git rev-parse --short HEAD)-$(date -u +%Y%m%d%H%M%S) --no-git-tag-version",
+    "publish:dev:version": "pnpm version $(node -p \"require('./package.json').version\")-$(git rev-parse --short HEAD)-$(date -u +%Y%m%d%H%M%S) --no-git-tag-version",
     "publish:dev:save": "node -p \"require('./package.json').version\" > .version",
     "publish:dev:publish": "pnpm build && pnpm publish --tag dev --access public --no-git-checks",
-    "publish:dev:reset": "npm version 1.0.0 --no-git-tag-version",
+    "publish:dev:reset": "pnpm version 0.5.0 --no-git-tag-version",
     "publish:dev": "pnpm publish:dev:version && pnpm publish:dev:save && pnpm publish:dev:publish && pnpm publish:dev:reset"
   }
 }

package/target/dist/index.cjs

@@ -82,7 +82,20 @@ var HttpFilteringConfigSchema = zod.z.object({
   // 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()
+  require_parent_for_outgoing_spans: zod.z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: zod.z.object({
+    // Strategy for trace propagation
+    // - "all": Propagate to all cross-origin requests (may cause CORS errors)
+    // - "none": Never propagate trace headers
+    // - "same-origin": Only propagate to same-origin requests (default, safe)
+    // - "patterns": Propagate based on include_urls patterns
+    strategy: zod.z.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
+    // URL patterns to include when strategy is "patterns"
+    // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
+    include_urls: zod.z.array(zod.z.string()).optional()
+  }).optional()
 });
 var InstrumentationConfigSchema = zod.z.object({
   version: zod.z.string(),
@@ -693,15 +706,6 @@ var getServiceInfoWithFallback = detectServiceInfo.pipe(
     })
   )
 );
-async function detectServiceInfoAsync() {
-  return effect.Effect.runPromise(getServiceInfoWithFallback);
-}
-async function getServiceNameAsync() {
-  return effect.Effect.runPromise(getServiceName);
-}
-async function getServiceVersionAsync() {
-  return effect.Effect.runPromise(getServiceVersion);
-}
 var NodeConfigLoaderLive = ConfigLoaderLive.pipe(
   effect.Layer.provide(effect.Layer.mergeAll(platformNode.NodeContext.layer, platform.FetchHttpClient.layer))
 );
@@ -783,7 +787,7 @@ async function loadConfigWithOptions(options = {}) {
 
 // src/core/sdk-initializer.ts
 var sdkInstance = null;
-var initializationPromise = null;
+var initializationDeferred = null;
 function buildHttpInstrumentationConfig(options, config, _otlpEndpoint) {
   const httpConfig = { enabled: true };
   const programmaticPatterns = options.http?.ignoreOutgoingUrls || [];
@@ -899,27 +903,38 @@ function isTracingAlreadyInitialized() {
     return false;
   }
 }
-async function initializeSdk(options = {}) {
+var initializeSdkEffect = (options = {}) => effect.Effect.gen(function* () {
   if (sdkInstance) {
     logger.warn("@atrim/instrumentation: SDK already initialized. Returning existing instance.");
     return sdkInstance;
   }
-  if (initializationPromise) {
+  if (initializationDeferred) {
     logger.log(
-      "@atrim/instrumentation: SDK already initialized, waiting for initialization to complete..."
+      "@atrim/instrumentation: SDK initialization in progress, waiting for completion..."
     );
-    return initializationPromise;
-  }
-  initializationPromise = performInitialization(options);
-  try {
-    const result = await initializationPromise;
-    return result;
-  } finally {
-    initializationPromise = null;
-  }
-}
-async function performInitialization(options) {
-  const config = await loadConfigWithOptions(options);
+    return yield* effect.Deferred.await(initializationDeferred);
+  }
+  const deferred = yield* effect.Deferred.make();
+  initializationDeferred = deferred;
+  const result = yield* performInitializationEffect(options).pipe(
+    effect.Effect.tap((sdk) => effect.Deferred.succeed(deferred, sdk)),
+    effect.Effect.tapError((error) => effect.Deferred.fail(deferred, error)),
+    effect.Effect.ensuring(
+      effect.Effect.sync(() => {
+        initializationDeferred = null;
+      })
+    )
+  );
+  return result;
+});
+var performInitializationEffect = (options) => effect.Effect.gen(function* () {
+  const config = yield* effect.Effect.tryPromise({
+    try: () => loadConfigWithOptions(options),
+    catch: (error) => new InitializationError2({
+      reason: "Failed to load configuration",
+      cause: error
+    })
+  });
   const loggingLevel = config.instrumentation.logging || "on";
   logger.setLevel(loggingLevel);
   const alreadyInitialized = isTracingAlreadyInitialized();
@@ -935,14 +950,25 @@ async function performInitialization(options) {
     logger.log("");
     return null;
   }
-  const serviceInfo = await detectServiceInfoAsync();
+  const serviceInfo = yield* detectServiceInfo.pipe(
+    effect.Effect.catchAll(
+      () => effect.Effect.succeed({
+        name: "unknown-service",
+        version: void 0
+      })
+    )
+  );
   const serviceName = options.serviceName || serviceInfo.name;
   const serviceVersion = options.serviceVersion || serviceInfo.version;
-  const rawExporter = createOtlpExporter(options.otlp);
-  const exporter = new SafeSpanExporter(rawExporter);
+  const rawExporter = yield* effect.Effect.sync(() => createOtlpExporter(options.otlp));
+  const exporter = yield* effect.Effect.sync(() => new SafeSpanExporter(rawExporter));
   const useSimpleProcessor = process.env.NODE_ENV === "test" || process.env.OTEL_USE_SIMPLE_PROCESSOR === "true";
-  const baseProcessor = useSimpleProcessor ? new sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.BatchSpanProcessor(exporter);
-  const patternProcessor = new PatternSpanProcessor(config, baseProcessor);
+  const baseProcessor = yield* effect.Effect.sync(
+    () => useSimpleProcessor ? new sdkTraceBase.SimpleSpanProcessor(exporter) : new sdkTraceBase.BatchSpanProcessor(exporter)
+  );
+  const patternProcessor = yield* effect.Effect.sync(
+    () => new PatternSpanProcessor(config, baseProcessor)
+  );
   const instrumentations = [];
   const hasWebFramework = hasWebFrameworkInstalled();
   const enableAutoInstrumentation = shouldEnableAutoInstrumentation(
@@ -955,15 +981,11 @@ async function performInitialization(options) {
     const undiciConfig = buildUndiciInstrumentationConfig(options, config);
     instrumentations.push(
       ...autoInstrumentationsNode.getNodeAutoInstrumentations({
-        // Enable HTTP instrumentation with filtering (for http/https modules)
         "@opentelemetry/instrumentation-http": httpConfig,
-        // Enable undici instrumentation with filtering (for fetch API)
         "@opentelemetry/instrumentation-undici": undiciConfig,
-        // Enable web framework instrumentations
         "@opentelemetry/instrumentation-express": { enabled: true },
         "@opentelemetry/instrumentation-fastify": { enabled: true },
         "@opentelemetry/instrumentation-koa": { enabled: true },
-        // Disable noisy instrumentations by default
         "@opentelemetry/instrumentation-fs": { enabled: false },
         "@opentelemetry/instrumentation-dns": { enabled: false }
       })
@@ -991,18 +1013,20 @@ async function performInitialization(options) {
     serviceName,
     ...serviceVersion && { serviceVersion },
     instrumentations,
-    // Allow advanced overrides
     ...options.sdk
   };
-  const sdk = new sdkNode.NodeSDK(sdkConfig);
-  sdk.start();
+  const sdk = yield* effect.Effect.sync(() => {
+    const s = new sdkNode.NodeSDK(sdkConfig);
+    s.start();
+    return s;
+  });
   sdkInstance = sdk;
   if (!options.disableAutoShutdown) {
-    registerShutdownHandlers(sdk);
+    yield* effect.Effect.sync(() => registerShutdownHandlers(sdk));
   }
   logInitialization(config, serviceName, serviceVersion, options, enableAutoInstrumentation);
   return sdk;
-}
+});
 function getSdkInstance() {
   return sdkInstance;
 }
@@ -1015,7 +1039,7 @@ async function shutdownSdk() {
 }
 function resetSdk() {
   sdkInstance = null;
-  initializationPromise = null;
+  initializationDeferred = null;
 }
 function registerShutdownHandlers(sdk) {
   const shutdown = async (signal) => {
@@ -1072,30 +1096,8 @@ function logInitialization(config, serviceName, serviceVersion, options, autoIns
 }
 
 // src/api.ts
-async function initializeInstrumentation(options = {}) {
-  const sdk = await initializeSdk(options);
-  if (sdk) {
-    const config = await loadConfigWithOptions(options);
-    initializePatternMatcher(config);
-  }
-  return sdk;
-}
-async function initializePatternMatchingOnly(options = {}) {
-  const config = await loadConfigWithOptions(options);
-  initializePatternMatcher(config);
-  logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
-  logger.log(
-    "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
-  );
-}
-var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(function* () {
-  const sdk = yield* effect.Effect.tryPromise({
-    try: () => initializeSdk(options),
-    catch: (error) => new InitializationError2({
-      reason: "SDK initialization failed",
-      cause: error
-    })
-  });
+var initializeInstrumentation = (options = {}) => effect.Effect.gen(function* () {
+  const sdk = yield* initializeSdkEffect(options);
   if (sdk) {
     yield* effect.Effect.tryPromise({
       try: () => loadConfigWithOptions(options),
@@ -1113,7 +1115,7 @@ var initializeInstrumentationEffect = (options = {}) => effect.Effect.gen(functi
   }
   return sdk;
 });
-var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(function* () {
+var initializePatternMatchingOnly = (options = {}) => effect.Effect.gen(function* () {
   const config = yield* effect.Effect.tryPromise({
     try: () => loadConfigWithOptions(options),
     catch: (error) => new ConfigError2({
@@ -1123,7 +1125,7 @@ var initializePatternMatchingOnlyEffect = (options = {}) => effect.Effect.gen(fu
   });
   yield* effect.Effect.sync(() => {
     initializePatternMatcher(config);
-    logger.log("@atrim/instrumentation: Pattern matching initialized (legacy mode)");
+    logger.log("@atrim/instrumentation: Pattern matching initialized (pattern-only mode)");
     logger.log(
       "  Note: NodeSDK is not initialized. Use initializeInstrumentation() for complete setup."
     );
@@ -1239,20 +1241,15 @@ exports.annotateDbQuery = annotateDbQuery;
 exports.annotateHttpRequest = annotateHttpRequest;
 exports.clearConfigCache = _resetConfigLoaderCache;
 exports.createOtlpExporter = createOtlpExporter;
-exports.detectServiceInfo = detectServiceInfoAsync;
-exports.detectServiceInfoEffect = detectServiceInfo;
+exports.detectServiceInfo = detectServiceInfo;
 exports.getOtlpEndpoint = getOtlpEndpoint;
 exports.getPatternMatcher = getPatternMatcher;
 exports.getSdkInstance = getSdkInstance;
 exports.getServiceInfoWithFallback = getServiceInfoWithFallback;
-exports.getServiceName = getServiceNameAsync;
-exports.getServiceNameEffect = getServiceName;
-exports.getServiceVersion = getServiceVersionAsync;
-exports.getServiceVersionEffect = getServiceVersion;
+exports.getServiceName = getServiceName;
+exports.getServiceVersion = getServiceVersion;
 exports.initializeInstrumentation = initializeInstrumentation;
-exports.initializeInstrumentationEffect = initializeInstrumentationEffect;
 exports.initializePatternMatchingOnly = initializePatternMatchingOnly;
-exports.initializePatternMatchingOnlyEffect = initializePatternMatchingOnlyEffect;
 exports.loadConfig = loadConfig;
 exports.loadConfigFromInline = loadConfigFromInline;
 exports.loadConfigWithOptions = loadConfigWithOptions;