@atrim/instrument-node 0.5.0 → 0.5.1

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

@@ -1,4 +1,4 @@
-import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, Tracer } from 'effect';
+import { Data, Context, Effect, Layer, FiberSet as FiberSet$1, Fiber, Option, FiberId, Tracer } from 'effect';
 import * as Otlp from '@effect/opentelemetry/Otlp';
 import { FetchHttpClient } from '@effect/platform';
 import { TraceFlags, trace, context } from '@opentelemetry/api';
@@ -10,6 +10,11 @@ import { z } from 'zod';
 import { NodeContext } from '@effect/platform-node';
 
 // 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);
@@ -46,7 +51,20 @@ var HttpFilteringConfigSchema = z.object({
   // 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()
+  require_parent_for_outgoing_spans: z.boolean().optional(),
+  // Trace context propagation configuration
+  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+  propagate_trace_context: 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: 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: z.array(z.string()).optional()
+  }).optional()
 });
 var InstrumentationConfigSchema = z.object({
   version: z.string(),
@@ -465,6 +483,7 @@ async function loadConfigWithOptions(options = {}) {
 }
 
 // src/integrations/effect/effect-tracer.ts
+var SDK_NAME = "@effect/opentelemetry-otlp";
 function createEffectInstrumentation(options = {}) {
   return Layer.unwrapEffect(
     Effect.gen(function* () {
@@ -498,7 +517,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
@@ -537,7 +558,9 @@ var EffectInstrumentationLive = 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
@@ -556,25 +579,144 @@ var EffectInstrumentationLive = Effect.sync(() => {
     }
   }).pipe(Layer.provide(FetchHttpClient.layer));
 }).pipe(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.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.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.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.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.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.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.annotateCurrentSpan(attributes);
 }
-function annotateError(_error, _context) {
+function annotatePriority(priority, reason) {
+  const attributes = {
+    "operation.priority": priority
+  };
+  if (reason) attributes["operation.priority.reason"] = reason;
+  return 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.annotateCurrentSpan(attributes);
 }
-function annotateCache(_operation, _hit) {
+function extractEffectMetadata() {
+  return Effect.gen(function* () {
+    const metadata = {};
+    const currentFiber = Fiber.getCurrentFiber();
+    if (Option.isSome(currentFiber)) {
+      const fiber = currentFiber.value;
+      const fiberId = fiber.id();
+      metadata["effect.fiber.id"] = FiberId.threadName(fiberId);
+      const status = yield* Fiber.status(fiber);
+      if (status._tag) {
+        metadata["effect.fiber.status"] = status._tag;
+      }
+    }
+    const parentSpanResult = yield* Effect.currentSpan.pipe(
+      Effect.option
+      // Convert NoSuchElementException to Option
+    );
+    if (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.gen(function* () {
+    const metadata = yield* extractEffectMetadata();
+    yield* Effect.annotateCurrentSpan(metadata);
+  });
+}
+function withAutoEnrichedSpan(spanName, options) {
+  return (self) => {
+    return Effect.gen(function* () {
+      yield* autoEnrichSpan();
+      return yield* self;
+    }).pipe(Effect.withSpan(spanName, options));
+  };
 }
 var createLogicalParentLink = (parentSpan, useSpanLinks) => {
   if (!useSpanLinks) {
@@ -701,6 +843,6 @@ var FiberSet = {
   runWithSpan
 };
 
-export { EffectInstrumentationLive, FiberSet, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, createEffectInstrumentation, runIsolated, runWithSpan };
+export { EffectInstrumentationLive, FiberSet, annotateBatch, annotateCache, annotateDataSize, annotateError, annotateHttpRequest, annotateLLM, annotatePriority, annotateQuery, annotateSpawnedTasks, annotateUser, autoEnrichSpan, createEffectInstrumentation, extractEffectMetadata, runIsolated, runWithSpan, withAutoEnrichedSpan };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map