@atrim/instrument-node 0.4.1 → 0.5.0-3a3dd2c-20251124202015

package/target/dist/index.js

@@ -53,13 +53,69 @@ var AutoIsolationConfigSchema = z.object({
     add_metadata: z.boolean().default(true)
   }).default({})
 });
+var SpanNamingRuleSchema = z.object({
+  // Match conditions (all specified conditions must match)
+  match: z.object({
+    // Match by file path pattern (regex)
+    file: z.string().optional(),
+    // Match by function name pattern (regex)
+    function: z.string().optional(),
+    // Match by operator type (gen, all, forEach, etc.)
+    operator: z.string().optional(),
+    // Match by call stack pattern (regex)
+    stack: z.string().optional(),
+    // Match by fiber annotation key
+    annotation: z.string().optional()
+  }),
+  // Name template with substitution variables
+  // Available: {operator}, {function}, {module}, {file}, {line}, {class}, {match:N}
+  name: z.string()
+});
+var AutoTracingConfigSchema = z.object({
+  // Global enable/disable for auto-tracing
+  enabled: z.boolean().default(true),
+  // Span naming configuration
+  span_naming: z.object({
+    // Default name template when no rules match
+    default: z.string().default("effect.{operator}"),
+    // Custom naming rules (applied in order, first match wins)
+    rules: z.array(SpanNamingRuleSchema).default([])
+  }).default({}),
+  // Pattern filtering
+  filter_patterns: z.object({
+    // Only trace spans matching these patterns
+    include: z.array(z.string()).default([]),
+    // Exclude spans matching these patterns (takes precedence)
+    exclude: z.array(z.string()).default([])
+  }).default({}),
+  // Sampling configuration
+  sampling: z.object({
+    // Sampling rate (0.0 to 1.0)
+    rate: z.number().min(0).max(1).default(1),
+    // Only trace effects with duration > this value
+    min_duration: z.string().default("0 millis")
+  }).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()
+  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(),
@@ -72,7 +128,8 @@ var InstrumentationConfigSchema = z.object({
   }),
   effect: z.object({
     auto_extract_metadata: z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional()
+    auto_isolation: AutoIsolationConfigSchema.optional(),
+    auto_tracing: AutoTracingConfigSchema.optional()
   }).optional(),
   http: HttpFilteringConfigSchema.optional()
 });