@blaxel/telemetry 0.2.18-dev.141 → 0.2.18-dev.145

package/dist/telemetry.d.ts

@@ -34,7 +34,6 @@ declare class TelemetryManager {
     private configured;
     constructor();
     initialize(): void;
-    setupBasicTracerProvider(): void;
     setConfiguration(): Promise<void>;
     get tracer(): import("@opentelemetry/api").Tracer;
     get enabled(): boolean;

package/dist/telemetry.js

@@ -78,49 +78,13 @@ class TelemetryManager {
         if (!this.enabled || this.initialized) {
             return;
         }
-        // Setup basic TracerProvider first - this is critical for context propagation
-        this.setupBasicTracerProvider();
-        // Now setup instrumentation - it can now extract traceparent headers
         this.instrumentApp();
         this.setupSignalHandler();
         this.initialized = true;
-        // Add exporters later asynchronously
         this.setConfiguration().catch((error) => {
             core_1.logger.error("Error setting configuration:", error);
         });
     }
-    setupBasicTracerProvider() {
-        const resource = new BlaxelResource(this.resourceAttributes);
-        // Create TracerProvider with complete setup including exporters
-        // This ensures we don't need to recreate it later, preserving context
-        const 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 || "",
-            }),
-        ];
-        // Try to add exporters if authentication is available
-        try {
-            if (core_1.settings.authorization) {
-                const traceExporter = this.getTraceExporter();
-                spanProcessors.push(new sdk_trace_node_1.BatchSpanProcessor(traceExporter));
-                spanProcessors.push(new HasBeenProcessedSpanProcessor(traceExporter));
-                console.log("🚀 TracerProvider created with exporters from the start");
-            }
-        }
-        catch {
-            console.log("🚀 TracerProvider created without exporters - will be added later");
-        }
-        this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
-            resource,
-            sampler: new sdk_trace_node_1.AlwaysOnSampler(),
-            spanProcessors,
-        });
-        // Register immediately - this enables context propagation
-        this.nodeTracerProvider.register();
-        console.log("🚀 TracerProvider registered BEFORE instrumentation - context propagation enabled");
-    }
     async setConfiguration() {
         if (!this.enabled || this.configured) {
             return;
@@ -228,48 +192,58 @@ class TelemetryManager {
         });
     }
     instrumentApp() {
-        // Setup telemetry provider first
         core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
         const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
-            requireParentforOutgoingSpans: true, // Maintain parent-child relationships
-            requestHook: (span) => {
-                // Debug incoming trace headers
-                console.log("=== HTTP INSTRUMENTATION REQUEST HOOK ===");
-                // Check if TracerProvider is registered
-                const tracer = api_1.trace.getTracer("debug");
-                console.log("TracerProvider available:", !!tracer);
-                // Check active context
-                const activeContext = api_1.context.active();
-                const spanContext = api_1.trace.getSpanContext(activeContext);
-                console.log("Span context from active context:", spanContext
-                    ? {
-                        traceId: spanContext.traceId,
-                        spanId: spanContext.spanId,
-                        traceFlags: spanContext.traceFlags,
-                    }
-                    : "null");
-                // Check current span context after HTTP instrumentation processes headers
-                const activeSpan = api_1.trace.getActiveSpan();
-                if (activeSpan) {
-                    console.log("✅ Active span found in request hook:", {
-                        traceId: activeSpan.spanContext().traceId,
-                        spanId: activeSpan.spanContext().spanId,
-                        traceFlags: activeSpan.spanContext().traceFlags,
+            requireParentforOutgoingSpans: true,
+            // Add hooks to debug context propagation
+            startIncomingSpanHook: (request) => {
+                const headers = request.headers;
+                const traceparent = headers?.traceparent;
+                const tracestate = headers?.tracestate;
+                if (traceparent) {
+                    core_1.logger.debug("Incoming request with traceparent header", {
+                        traceparent,
+                        tracestate,
+                        url: request.url,
+                        method: request.method,
                     });
                 }
                 else {
-                    console.log("❌ No active span found in request hook");
-                    console.log("Possible causes:");
-                    console.log("1. TracerProvider not registered before HTTP instrumentation");
-                    console.log("2. Traceparent header not properly extracted");
-                    console.log("3. Context lost across async boundaries");
+                    core_1.logger.debug("Incoming request without traceparent header", {
+                        url: request.url,
+                        method: request.method,
+                        headers: Object.keys(headers || {}),
+                    });
                 }
-                console.log("Current span from hook parameter:", {
-                    traceId: span.spanContext().traceId,
-                    spanId: span.spanContext().spanId,
-                    traceFlags: span.spanContext().traceFlags,
+                // Return attributes object as expected by the hook
+                return {};
+            },
+            startOutgoingSpanHook: (request) => {
+                core_1.logger.debug("Starting outgoing request span", {
+                    path: request.path,
+                    method: request.method,
+                });
+                // Return attributes object as expected by the hook
+                return {};
+            },
+            // Add additional hooks for debugging
+            responseHook: (span, response) => {
+                const statusCode = "statusCode" in response ? response.statusCode : undefined;
+                const headers = "headers" in response ? response.headers : undefined;
+                core_1.logger.debug("HTTP response received", {
+                    statusCode,
+                    headers: headers ? Object.keys(headers) : [],
+                });
+            },
+            requestHook: (span, request) => {
+                const url = "url" in request ? request.url : undefined;
+                const method = "method" in request ? request.method : undefined;
+                const headers = "headers" in request ? request.headers : undefined;
+                core_1.logger.debug("HTTP request being made", {
+                    url,
+                    method,
+                    headers: headers ? Object.keys(headers) : [],
                 });
-                console.log("=== END HTTP INSTRUMENTATION REQUEST HOOK ===");
             },
         });
         (0, instrumentation_1.registerInstrumentations)({
@@ -278,46 +252,27 @@ class TelemetryManager {
     }
     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);
-        // Check if we need to add exporters to existing TracerProvider
-        if (this.nodeTracerProvider && !core_1.settings.authorization) {
-            // If we didn't have authorization before but we do now, recreate with exporters
-            // But only if we didn't already have them
-            try {
-                const traceExporter = this.getTraceExporter();
-                // Unfortunately, we need to recreate the TracerProvider to add exporters
-                // This is a limitation of OpenTelemetry SDK
-                const newTracerProvider = 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 || "",
-                        }),
-                        new sdk_trace_node_1.BatchSpanProcessor(traceExporter),
-                        new HasBeenProcessedSpanProcessor(traceExporter),
-                    ],
-                });
-                this.nodeTracerProvider = newTracerProvider;
-                this.nodeTracerProvider.register();
-                console.log("📡 TracerProvider updated with exporters");
-            }
-            catch {
-                console.log("📡 Could not add exporters to TracerProvider");
-            }
-        }
-        else {
-            console.log("📡 TracerProvider already has exporters or no changes needed");
-        }
-        // Setup metrics
+        const traceExporter = this.getTraceExporter();
+        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 || "",
+                }),
+                new sdk_trace_node_1.BatchSpanProcessor(traceExporter),
+                new HasBeenProcessedSpanProcessor(traceExporter),
+            ],
+        });
+        this.nodeTracerProvider.register();
         const metricExporter = this.getMetricExporter();
         this.meterProvider = new sdk_metrics_1.MeterProvider({
             resource,

package/dist/telemetry_provider.d.ts

@@ -1,5 +1,10 @@
 import { BlaxelSpan, BlaxelSpanOptions, BlaxelTelemetryProvider } from "@blaxel/core";
 export declare class OtelTelemetryProvider implements BlaxelTelemetryProvider {
     startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
+    /**
+     * Extract context from headers manually
+     * This can be used when automatic context propagation isn't working
+     */
+    extractContextFromHeaders(headers: Record<string, string | string[]>): unknown;
     flush(): Promise<void>;
 }

package/dist/telemetry_provider.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OtelTelemetryProvider = void 0;
+const core_1 = require("@blaxel/core");
 const api_1 = require("@opentelemetry/api");
 const telemetry_1 = require("./telemetry");
 class OtelSpan {
     span;
-    closed = false;
     constructor(span) {
         this.span = span;
     }
@@ -26,7 +26,6 @@ class OtelSpan {
         });
     }
     end() {
-        this.closed = true;
         this.span.end();
     }
     getContext() {
@@ -35,39 +34,127 @@ class OtelSpan {
 }
 class OtelTelemetryProvider {
     startSpan(name, options) {
+        // Use the tracer from the registered NodeTracerProvider
         const tracer = api_1.trace.getTracer("blaxel");
-        // Get the current active context - this will include any traceparent propagation
-        const activeContext = api_1.context.active();
+        // Get the current active context
+        let ctx = 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,
+        // Log context information for debugging
+        if (activeSpan) {
+            const spanContext = activeSpan.spanContext();
+            core_1.logger.debug("Creating span with active parent context", {
+                spanName: name,
+                parentTraceId: spanContext.traceId,
+                parentSpanId: spanContext.spanId,
+                isRoot: options?.isRoot,
+            });
+        }
+        else {
+            core_1.logger.debug("Creating span without active parent context", {
+                spanName: name,
+                isRoot: options?.isRoot,
+                contextProvided: !!options?.parentContext,
+            });
+            // Try to extract context from headers if available in the environment
+            // This is a fallback when HttpInstrumentation doesn't set the context properly
+            if (typeof globalThis !== "undefined" && globalThis.process?.env) {
+                const headers = {};
+                // Check if there are any trace headers in the environment
+                if (process.env.TRACEPARENT) {
+                    headers["traceparent"] = process.env.TRACEPARENT;
+                }
+                if (process.env.TRACESTATE) {
+                    headers["tracestate"] = process.env.TRACESTATE;
+                }
+                if (headers.traceparent) {
+                    core_1.logger.debug("Found traceparent in environment, attempting to extract context", {
+                        traceparent: headers.traceparent,
+                        tracestate: headers.tracestate,
+                    });
+                    try {
+                        const extractedContext = api_1.propagation.extract(api_1.context.active(), headers);
+                        const extractedSpan = api_1.trace.getSpan(extractedContext);
+                        if (extractedSpan) {
+                            ctx = extractedContext;
+                            core_1.logger.debug("Successfully extracted context from traceparent", {
+                                extractedTraceId: extractedSpan.spanContext().traceId,
+                                extractedSpanId: extractedSpan.spanContext().spanId,
+                            });
+                        }
+                    }
+                    catch (error) {
+                        core_1.logger.debug("Failed to extract context from traceparent", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
             }
-            : "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,
+        }
+        // Handle parent context if provided
+        if (options?.parentContext) {
+            ctx = options.parentContext;
+            core_1.logger.debug("Using provided parent context for span", {
+                spanName: name,
             });
         }
+        // Prepare OpenTelemetry span options
         const otelOptions = {
             attributes: options?.attributes,
             root: options?.isRoot,
         };
-        // 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;
+        // Start the span
+        const span = tracer.startSpan(name, otelOptions, ctx);
+        const spanContext = span.spanContext();
+        core_1.logger.debug("Span created successfully", {
+            spanName: name,
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            isRoot: options?.isRoot,
+        });
+        return new OtelSpan(span);
+    }
+    /**
+     * Extract context from headers manually
+     * This can be used when automatic context propagation isn't working
+     */
+    extractContextFromHeaders(headers) {
+        try {
+            // Normalize headers to string values
+            const normalizedHeaders = {};
+            Object.entries(headers).forEach(([key, value]) => {
+                if (Array.isArray(value)) {
+                    normalizedHeaders[key.toLowerCase()] = value[0] || "";
+                }
+                else if (typeof value === "string") {
+                    normalizedHeaders[key.toLowerCase()] = value;
+                }
+            });
+            core_1.logger.debug("Attempting to extract context from headers", {
+                headers: Object.keys(normalizedHeaders),
+                traceparent: normalizedHeaders.traceparent,
+                tracestate: normalizedHeaders.tracestate,
+            });
+            const extractedContext = api_1.propagation.extract(api_1.context.active(), normalizedHeaders);
+            const extractedSpan = api_1.trace.getSpan(extractedContext);
+            if (extractedSpan) {
+                const spanContext = extractedSpan.spanContext();
+                core_1.logger.debug("Successfully extracted context from headers", {
+                    traceId: spanContext.traceId,
+                    spanId: spanContext.spanId,
+                });
+                return extractedContext;
+            }
+            else {
+                core_1.logger.debug("No span found in extracted context");
+                return null;
+            }
+        }
+        catch (error) {
+            core_1.logger.debug("Failed to extract context from headers", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
     }
     async flush() {
         await telemetry_1.blaxelTelemetry.flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/telemetry",
-  "version": "0.2.18-dev.141",
+  "version": "0.2.18-dev.145",
   "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.141"
+    "@blaxel/core": "0.2.18-dev.145"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",