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

package/dist/telemetry.d.ts

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

package/dist/telemetry.js

@@ -192,67 +192,72 @@ 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: 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,
+            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");
+                    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)({
             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,
@@ -267,10 +272,7 @@ 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,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.142",
+  "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.142"
+    "@blaxel/core": "0.2.18-dev.145"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",