@blaxel/telemetry 0.2.18-dev.134 → 0.2.18-dev.137

package/dist/telemetry.d.ts

@@ -59,6 +59,7 @@ declare class TelemetryManager {
      */
     getLogExporter(): OTLPLogExporter;
     instrumentApp(): void;
+    setupProviders(): void;
     setExporters(): void;
     shutdownApp(): Promise<void>;
 }

package/dist/telemetry.js

@@ -192,22 +192,67 @@ class TelemetryManager {
         });
     }
     instrumentApp() {
+        // Setup telemetry provider first
         core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
+        // Setup TracerProvider and other providers BEFORE instrumentation
+        this.setupProviders();
         const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
-            requireParentforOutgoingSpans: true,
+            requireParentforOutgoingSpans: false, // Allow spans from incoming headers
+            requestHook: (span) => {
+                // Debug incoming trace headers
+                console.log("=== HTTP INSTRUMENTATION REQUEST HOOK ===");
+                // Check current span context after HTTP instrumentation processes headers
+                const activeSpan = api_1.trace.getActiveSpan();
+                if (activeSpan) {
+                    console.log("Active span in request hook:", {
+                        traceId: activeSpan.spanContext().traceId,
+                        spanId: activeSpan.spanContext().spanId,
+                        traceFlags: activeSpan.spanContext().traceFlags,
+                    });
+                }
+                else {
+                    console.log("No active span found in request hook");
+                }
+                console.log("Current span from hook parameter:", {
+                    traceId: span.spanContext().traceId,
+                    spanId: span.spanContext().spanId,
+                    traceFlags: span.spanContext().traceFlags,
+                });
+                console.log("=== END HTTP INSTRUMENTATION REQUEST HOOK ===");
+            },
         });
         (0, instrumentation_1.registerInstrumentations)({
             instrumentations: [httpInstrumentation],
         });
     }
+    setupProviders() {
+        const resource = new BlaxelResource(this.resourceAttributes);
+        // Setup TracerProvider first - this is critical for context propagation
+        this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            resource,
+            sampler: new sdk_trace_node_1.AlwaysOnSampler(),
+            spanProcessors: [
+                new DefaultAttributesSpanProcessor({
+                    "workload.id": core_1.settings.name || "",
+                    "workload.type": core_1.settings.type ? core_1.settings.type + "s" : "",
+                    workspace: core_1.settings.workspace || "",
+                }),
+            ],
+        });
+        // Register the tracer provider BEFORE any instrumentation
+        this.nodeTracerProvider.register();
+        console.log("TracerProvider registered - ready for context propagation");
+    }
     setExporters() {
         const resource = new BlaxelResource(this.resourceAttributes);
+        // Setup logging
         const logExporter = this.getLogExporter();
         this.loggerProvider = new sdk_logs_1.LoggerProvider({
             resource,
         });
         this.loggerProvider.addLogRecordProcessor(new sdk_logs_1.BatchLogRecordProcessor(logExporter));
         api_logs_1.logs.setGlobalLoggerProvider(this.loggerProvider);
+        // Recreate TracerProvider with exporters - this ensures proper initialization
         const traceExporter = this.getTraceExporter();
         this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
             resource,
@@ -222,7 +267,10 @@ class TelemetryManager {
                 new HasBeenProcessedSpanProcessor(traceExporter),
             ],
         });
+        // Re-register the tracer provider with exporters
         this.nodeTracerProvider.register();
+        console.log("TracerProvider re-registered with exporters");
+        // Setup metrics
         const metricExporter = this.getMetricExporter();
         this.meterProvider = new sdk_metrics_1.MeterProvider({
             resource,

package/dist/telemetry_provider.d.ts

@@ -1,7 +1,5 @@
 import { BlaxelSpan, BlaxelSpanOptions, BlaxelTelemetryProvider } from "@blaxel/core";
 export declare class OtelTelemetryProvider implements BlaxelTelemetryProvider {
-    private spans;
-    retrieveActiveSpanContext(): import("@opentelemetry/api").Context;
     startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
     flush(): Promise<void>;
 }

package/dist/telemetry_provider.js

@@ -21,7 +21,7 @@ class OtelSpan {
     }
     setStatus(status, message) {
         this.span.setStatus({
-            code: status === 'ok' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
+            code: status === "ok" ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
             message,
         });
     }
@@ -34,25 +34,39 @@ class OtelSpan {
     }
 }
 class OtelTelemetryProvider {
-    spans = [];
-    retrieveActiveSpanContext() {
-        for (let i = this.spans.length - 1; i >= 0; i--) {
-            const span = this.spans[i];
-            if (!span.closed) {
-                return api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, span.getContext());
-            }
-        }
-        return api_1.context.active();
-    }
     startSpan(name, options) {
         const tracer = api_1.trace.getTracer("blaxel");
+        // Get the current active context - this will include any traceparent propagation
+        const activeContext = api_1.context.active();
+        const activeSpan = api_1.trace.getActiveSpan();
+        // Debug logging to help understand context propagation
+        console.log("=== CREATING NEW SPAN ===");
+        console.log("Span name:", name);
+        console.log("Active context span:", activeSpan
+            ? {
+                traceId: activeSpan.spanContext().traceId,
+                spanId: activeSpan.spanContext().spanId,
+                traceFlags: activeSpan.spanContext().traceFlags,
+            }
+            : "null");
+        // Check if there's a span context in the active context (from traceparent headers)
+        const spanContext = api_1.trace.getSpanContext(activeContext);
+        if (spanContext) {
+            console.log("Span context from active context:", {
+                traceId: spanContext.traceId,
+                spanId: spanContext.spanId,
+                traceFlags: spanContext.traceFlags,
+            });
+        }
         const otelOptions = {
             attributes: options?.attributes,
             root: options?.isRoot,
         };
-        const ctx = this.retrieveActiveSpanContext();
-        const span = new OtelSpan(tracer.startSpan(name, otelOptions, ctx));
-        this.spans.push(span);
+        // Use the active context unless explicitly requesting a root span
+        const contextToUse = options?.isRoot ? api_1.ROOT_CONTEXT : activeContext;
+        const span = new OtelSpan(tracer.startSpan(name, otelOptions, contextToUse));
+        console.log("Created span context:", span.getContext());
+        console.log("=== END CREATING NEW SPAN ===");
         return span;
     }
     async flush() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/telemetry",
-  "version": "0.2.18-dev.134",
+  "version": "0.2.18-dev.137",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -71,7 +71,7 @@
     "@opentelemetry/sdk-trace-base": "^2.0.0",
     "@opentelemetry/sdk-trace-node": "^2.0.0",
     "ai": "^4.3.13",
-    "@blaxel/core": "0.2.18-dev.134"
+    "@blaxel/core": "0.2.18-dev.137"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",