@blaxel/telemetry 0.2.17-dev.131 → 0.2.17-dev.132

package/dist/telemetry.d.ts

@@ -42,10 +42,6 @@ declare class TelemetryManager {
     flush(): Promise<void>;
     getLogger(): Promise<Logger>;
     setupSignalHandler(): void;
-    /**
-     * Check if telemetry is properly initialized and active
-     */
-    get isActive(): boolean;
     /**
      * Get resource attributes for OpenTelemetry.
      */

package/dist/telemetry.js

@@ -142,22 +142,6 @@ class TelemetryManager {
                 });
             });
         }
-        // Handle uncaughtException differently - log but don't shutdown telemetry
-        process.on("uncaughtException", (error) => {
-            core_1.logger.error("Uncaught exception:", error);
-            // Don't shutdown telemetry for uncaught exceptions
-        });
-        // Don't listen to 'exit' event as it can be triggered by various things
-        // and we don't want to shutdown telemetry unless explicitly requested
-    }
-    /**
-     * Check if telemetry is properly initialized and active
-     */
-    get isActive() {
-        return (this.initialized &&
-            this.configured &&
-            this.nodeTracerProvider !== null &&
-            this.meterProvider !== null);
     }
     /**
      * Get resource attributes for OpenTelemetry.
@@ -208,119 +192,15 @@ class TelemetryManager {
         });
     }
     instrumentApp() {
-        core_1.logger.debug("Available propagation fields before setup:", api_1.propagation.fields());
         core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
         const httpInstrumentation = new instrumentation_http_1.HttpInstrumentation({
             requireParentforOutgoingSpans: true,
-            requireParentforIncomingSpans: false, // Allow root spans for incoming requests
-            ignoreIncomingRequestHook: () => false, // Don't ignore any requests
-            ignoreOutgoingRequestHook: () => false, // Don't ignore any requests
-            requestHook: (span, request) => {
-                core_1.logger.debug("Available propagation fields before setup:", api_1.propagation.fields());
-                // Log incoming headers for debugging
-                if ("headers" in request && request.headers) {
-                    // Specifically log trace context headers
-                    const headers = request.headers;
-                    const traceHeaders = {
-                        traceparent: headers.traceparent,
-                        tracestate: headers.tracestate,
-                        "x-blaxel-authorization": headers["x-blaxel-authorization"],
-                        "x-blaxel-workspace": headers["x-blaxel-workspace"],
-                    };
-                    core_1.logger.debug("Trace context headers:", JSON.stringify(traceHeaders));
-                    // Manual trace context extraction for debugging
-                    if (headers.traceparent) {
-                        const extractedContext = api_1.propagation.extract(api_1.context.active(), headers);
-                        core_1.logger.debug("Active context keys:", Object.keys(api_1.context.active()));
-                        core_1.logger.debug("Extracted context keys:", Object.keys(extractedContext));
-                        // const extractedSpan = trace.getSpan(extractedContext);
-                        // if (extractedSpan) {
-                        //   // Force set the extracted span as active
-                        //   context.with(
-                        //     trace.setSpan(context.active(), extractedSpan),
-                        //     () => {
-                        //       logger.debug("Forced context activation from traceparent");
-                        //     }
-                        //   );
-                        // }
-                        try {
-                            const traceparentValue = Array.isArray(headers.traceparent)
-                                ? headers.traceparent[0]
-                                : headers.traceparent;
-                            core_1.logger.debug("Manual traceparent parsing:", traceparentValue);
-                            // Try to manually parse the traceparent header
-                            const parts = traceparentValue.split("-");
-                            if (parts.length === 4) {
-                                core_1.logger.debug("Traceparent parts:", JSON.stringify({
-                                    version: parts[0],
-                                    traceId: parts[1],
-                                    spanId: parts[2],
-                                    flags: parts[3],
-                                }));
-                                // Check if this looks like a valid traceparent
-                                if (parts[1] !== "00000000000000000000000000000000" &&
-                                    parts[2] !== "0000000000000000") {
-                                    core_1.logger.debug("Traceparent appears valid - extraction should work");
-                                }
-                                else {
-                                    core_1.logger.debug("Traceparent contains invalid IDs");
-                                }
-                            }
-                            // // Extract trace context manually to see what should be extracted
-                            // const extractedContext = propagation.extract(
-                            //   context.active(),
-                            //   headers
-                            // );
-                            const extractedSpan = api_1.trace.getSpan(extractedContext);
-                            if (extractedSpan) {
-                                const extractedSpanContext = extractedSpan.spanContext();
-                                core_1.logger.debug("Manual context extraction result:", JSON.stringify({
-                                    traceId: extractedSpanContext.traceId,
-                                    spanId: extractedSpanContext.spanId,
-                                    traceFlags: extractedSpanContext.traceFlags,
-                                }));
-                            }
-                            else {
-                                core_1.logger.debug("Manual context extraction failed - no span found");
-                                core_1.logger.debug("Available propagation fields:", api_1.propagation.fields());
-                            }
-                        }
-                        catch (error) {
-                            core_1.logger.debug("Manual context extraction error:", error);
-                        }
-                    }
-                    // Safe logging of span information without circular references
-                    const spanContext = span.spanContext();
-                    core_1.logger.debug("Span created:", {
-                        spanId: spanContext.spanId,
-                        traceId: spanContext.traceId,
-                        traceFlags: spanContext.traceFlags,
-                    });
-                    core_1.logger.debug("Span context:", spanContext);
-                    // Log the span context that was created from the incoming request
-                    core_1.logger.debug("HTTP span context:", JSON.stringify({
-                        traceId: spanContext.traceId,
-                        spanId: spanContext.spanId,
-                        traceFlags: spanContext.traceFlags,
-                    }));
-                }
-            },
-            responseHook: (span) => {
-                const spanContext = span.spanContext();
-                core_1.logger.debug("HTTP response span context:", JSON.stringify({
-                    traceId: spanContext.traceId,
-                    spanId: spanContext.spanId,
-                    traceFlags: spanContext.traceFlags,
-                }));
-            },
         });
         (0, instrumentation_1.registerInstrumentations)({
             instrumentations: [httpInstrumentation],
         });
     }
     setExporters() {
-        // Log current propagators for debugging
-        core_1.logger.debug("Current propagators:", api_1.propagation.fields());
         const resource = new BlaxelResource(this.resourceAttributes);
         const logExporter = this.getLogExporter();
         this.loggerProvider = new sdk_logs_1.LoggerProvider({
@@ -343,8 +223,6 @@ class TelemetryManager {
             ],
         });
         this.nodeTracerProvider.register();
-        // Ensure W3C trace context propagation is working
-        core_1.logger.debug("Propagation fields after tracer registration:", api_1.propagation.fields());
         const metricExporter = this.getMetricExporter();
         this.meterProvider = new sdk_metrics_1.MeterProvider({
             resource,

package/dist/telemetry_provider.d.ts

@@ -1,5 +1,7 @@
 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

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OtelTelemetryProvider = void 0;
 const api_1 = require("@opentelemetry/api");
 const telemetry_1 = require("./telemetry");
-const core_1 = require("@blaxel/core");
 class OtelSpan {
     span;
+    closed = false;
     constructor(span) {
         this.span = span;
     }
@@ -21,11 +21,12 @@ 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,
         });
     }
     end() {
+        this.closed = true;
         this.span.end();
     }
     getContext() {
@@ -33,79 +34,26 @@ class OtelSpan {
     }
 }
 class OtelTelemetryProvider {
-    startSpan(name, options) {
-        // Check if telemetry is active, reinitialize if needed
-        core_1.logger.debug("Telemetry is active:", telemetry_1.blaxelTelemetry.isActive);
-        if (!telemetry_1.blaxelTelemetry.isActive) {
-            core_1.logger.debug("Telemetry not active, reinitializing...");
-            // Synchronous reinitialize - just call initialize, setConfiguration will happen async
-            telemetry_1.blaxelTelemetry.initialize();
+    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());
+            }
         }
-        // Use the tracer from the registered NodeTracerProvider
+        return api_1.context.active();
+    }
+    startSpan(name, options) {
         const tracer = api_1.trace.getTracer("blaxel");
-        // Prepare OpenTelemetry span options
         const otelOptions = {
             attributes: options?.attributes,
             root: options?.isRoot,
         };
-        core_1.logger.debug("Options:", options
-            ? {
-                attributes: options.attributes,
-                isRoot: options.isRoot,
-                hasParentContext: !!options.parentContext,
-            }
-            : null);
-        core_1.logger.debug("OTel span options:", otelOptions);
-        // Handle parent context properly with debugging
-        let ctx = api_1.context.active();
-        const activeSpan = api_1.trace.getActiveSpan();
-        core_1.logger.debug("Active context keys:", Object.keys(ctx));
-        core_1.logger.debug("Active span:", activeSpan
-            ? {
-                spanId: activeSpan.spanContext().spanId,
-                traceId: activeSpan.spanContext().traceId,
-            }
-            : null);
-        core_1.logger.debug("Active span context:", activeSpan ? activeSpan.spanContext() : null);
-        // Debug logging for context issues
-        core_1.logger.info(`Creating span "${name}":`, {
-            hasActiveSpan: !!activeSpan,
-            activeSpanId: activeSpan?.spanContext().spanId,
-            isRoot: options?.isRoot,
-            hasParentContext: !!options?.parentContext,
-            parentContext: options?.parentContext,
-            contextKeys: Object.keys(ctx),
-            telemetryActive: telemetry_1.blaxelTelemetry.isActive,
-            activeTraceId: activeSpan?.spanContext().traceId,
-            otelOptions: otelOptions,
-        });
-        if (options?.parentContext) {
-            // If explicit parent context is provided, use it
-            ctx = api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, options.parentContext);
-        }
-        else if (options?.isRoot) {
-            // If explicitly marked as root, use ROOT_CONTEXT
-            ctx = api_1.ROOT_CONTEXT;
-        }
-        // Otherwise, use the active context (default behavior)
-        // Start the span with proper context
-        const span = tracer.startSpan(name, otelOptions, ctx);
-        const otelSpan = new OtelSpan(span);
-        // Safe logging of span information without circular references
-        const spanContext = span.spanContext();
-        core_1.logger.debug("Span created:", {
-            spanId: spanContext.spanId,
-            traceId: spanContext.traceId,
-            traceFlags: spanContext.traceFlags,
-        });
-        core_1.logger.debug("Span context:", spanContext);
-        // Additional debugging
-        core_1.logger.info(`Created span "${name}":`, {
-            spanId: spanContext.spanId,
-            traceId: spanContext.traceId,
-            parentSpanId: activeSpan?.spanContext().spanId || "none",
-        });
-        return otelSpan;
+        const ctx = this.retrieveActiveSpanContext();
+        const span = new OtelSpan(tracer.startSpan(name, otelOptions, ctx));
+        this.spans.push(span);
+        return span;
     }
     async flush() {
         await telemetry_1.blaxelTelemetry.flush();

package/package.json

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