@atrim/instrument-node 0.5.0 → 0.5.1

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

@@ -34,6 +34,11 @@ 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);
@@ -70,7 +75,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(),
@@ -489,6 +507,7 @@ async function loadConfigWithOptions(options = {}) {
 }
 
 // src/integrations/effect/effect-tracer.ts
+var SDK_NAME = "@effect/opentelemetry-otlp";
 function createEffectInstrumentation(options = {}) {
   return effect.Layer.unwrapEffect(
     effect.Effect.gen(function* () {
@@ -522,7 +541,9 @@ function createEffectInstrumentation(options = {}) {
           attributes: {
             "platform.component": "effect",
             "effect.auto_metadata": autoExtractMetadata,
-            "effect.context_propagation": continueExistingTraces
+            "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
@@ -561,7 +582,9 @@ var EffectInstrumentationLive = effect.Effect.sync(() => {
       serviceName,
       serviceVersion,
       attributes: {
-        "platform.component": "effect"
+        "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
@@ -580,25 +603,144 @@ var EffectInstrumentationLive = effect.Effect.sync(() => {
     }
   }).pipe(effect.Layer.provide(platform.FetchHttpClient.layer));
 }).pipe(effect.Layer.unwrapEffect);
-
-// src/integrations/effect/effect-helpers.ts
-function annotateUser(_userId, _email) {
+function annotateUser(userId, email, username) {
+  const attributes = {
+    "user.id": userId
+  };
+  if (email) attributes["user.email"] = email;
+  if (username) attributes["user.name"] = username;
+  return effect.Effect.annotateCurrentSpan(attributes);
+}
+function annotateDataSize(bytes, items, compressionRatio) {
+  const attributes = {
+    "data.size.bytes": bytes,
+    "data.size.items": items
+  };
+  if (compressionRatio !== void 0) {
+    attributes["data.compression.ratio"] = compressionRatio;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateDataSize(_bytes, _count) {
+function annotateBatch(totalItems, batchSize, successCount, failureCount) {
+  const attributes = {
+    "batch.size": batchSize,
+    "batch.total_items": totalItems,
+    "batch.count": Math.ceil(totalItems / batchSize)
+  };
+  if (successCount !== void 0) {
+    attributes["batch.success_count"] = successCount;
+  }
+  if (failureCount !== void 0) {
+    attributes["batch.failure_count"] = failureCount;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateBatch(_size, _batchSize) {
+function annotateLLM(model, provider, tokens) {
+  const attributes = {
+    "llm.model": model,
+    "llm.provider": provider
+  };
+  if (tokens) {
+    if (tokens.prompt !== void 0) attributes["llm.tokens.prompt"] = tokens.prompt;
+    if (tokens.completion !== void 0) attributes["llm.tokens.completion"] = tokens.completion;
+    if (tokens.total !== void 0) attributes["llm.tokens.total"] = tokens.total;
+  }
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateLLM(_model, _operation, _inputTokens, _outputTokens) {
+function annotateQuery(query, duration, rowCount, database) {
+  const attributes = {
+    "db.statement": query.length > 1e3 ? query.substring(0, 1e3) + "..." : query
+  };
+  if (duration !== void 0) attributes["db.duration.ms"] = duration;
+  if (rowCount !== void 0) attributes["db.row_count"] = rowCount;
+  if (database) attributes["db.name"] = database;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateQuery(_query, _database) {
+function annotateHttpRequest(method, url, statusCode, contentLength) {
+  const attributes = {
+    "http.method": method,
+    "http.url": url
+  };
+  if (statusCode !== void 0) attributes["http.status_code"] = statusCode;
+  if (contentLength !== void 0) attributes["http.response.content_length"] = contentLength;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateHttpRequest(_method, _url, _statusCode) {
+function annotateError(error, recoverable, errorType) {
+  const errorMessage = typeof error === "string" ? error : error.message;
+  const errorStack = typeof error === "string" ? void 0 : error.stack;
+  const attributes = {
+    "error.message": errorMessage,
+    "error.recoverable": recoverable
+  };
+  if (errorType) attributes["error.type"] = errorType;
+  if (errorStack) attributes["error.stack"] = errorStack;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateError(_error, _context) {
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotatePriority(_priority) {
+function annotateCache(hit, key, ttl) {
+  const attributes = {
+    "cache.hit": hit,
+    "cache.key": key
+  };
+  if (ttl !== void 0) attributes["cache.ttl.seconds"] = ttl;
+  return effect.Effect.annotateCurrentSpan(attributes);
 }
-function annotateCache(_operation, _hit) {
+function extractEffectMetadata() {
+  return effect.Effect.gen(function* () {
+    const metadata = {};
+    const currentFiber = effect.Fiber.getCurrentFiber();
+    if (effect.Option.isSome(currentFiber)) {
+      const fiber = currentFiber.value;
+      const fiberId = fiber.id();
+      metadata["effect.fiber.id"] = effect.FiberId.threadName(fiberId);
+      const status = yield* effect.Fiber.status(fiber);
+      if (status._tag) {
+        metadata["effect.fiber.status"] = status._tag;
+      }
+    }
+    const parentSpanResult = yield* effect.Effect.currentSpan.pipe(
+      effect.Effect.option
+      // Convert NoSuchElementException to Option
+    );
+    if (effect.Option.isSome(parentSpanResult)) {
+      const parentSpan = parentSpanResult.value;
+      metadata["effect.operation.nested"] = true;
+      metadata["effect.operation.root"] = false;
+      if (parentSpan.spanId) {
+        metadata["effect.parent.span.id"] = parentSpan.spanId;
+      }
+      if (parentSpan.name) {
+        metadata["effect.parent.span.name"] = parentSpan.name;
+      }
+      if (parentSpan.traceId) {
+        metadata["effect.parent.trace.id"] = parentSpan.traceId;
+      }
+    } else {
+      metadata["effect.operation.nested"] = false;
+      metadata["effect.operation.root"] = true;
+    }
+    return metadata;
+  });
+}
+function autoEnrichSpan() {
+  return effect.Effect.gen(function* () {
+    const metadata = yield* extractEffectMetadata();
+    yield* effect.Effect.annotateCurrentSpan(metadata);
+  });
+}
+function withAutoEnrichedSpan(spanName, options) {
+  return (self) => {
+    return effect.Effect.gen(function* () {
+      yield* autoEnrichSpan();
+      return yield* self;
+    }).pipe(effect.Effect.withSpan(spanName, options));
+  };
 }
 var createLogicalParentLink = (parentSpan, useSpanLinks) => {
   if (!useSpanLinks) {
@@ -737,8 +879,11 @@ exports.annotatePriority = annotatePriority;
 exports.annotateQuery = annotateQuery;
 exports.annotateSpawnedTasks = annotateSpawnedTasks;
 exports.annotateUser = annotateUser;
+exports.autoEnrichSpan = autoEnrichSpan;
 exports.createEffectInstrumentation = createEffectInstrumentation;
+exports.extractEffectMetadata = extractEffectMetadata;
 exports.runIsolated = runIsolated;
 exports.runWithSpan = runWithSpan;
+exports.withAutoEnrichedSpan = withAutoEnrichedSpan;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map