@blaxel/telemetry 0.2.49-dev.214 → 0.2.49-dev1

package/dist/auth_refresh_exporters.d.ts

@@ -0,0 +1,44 @@
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-node";
+/**
+ * SpanExporter that refreshes authentication before each export.
+ * This is necessary for long-running containers where tokens may expire.
+ */
+export declare class AuthRefreshingSpanExporter implements SpanExporter {
+    private createExporter;
+    constructor(createExporter: () => SpanExporter);
+    private currentExporter;
+    export(spans: ReadableSpan[], resultCallback: (result: {
+        code: number;
+        error?: Error;
+    }) => void): void;
+    private doExport;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+/**
+ * MetricExporter that refreshes authentication before each export.
+ * This is necessary for long-running containers where tokens may expire.
+ */
+export declare class AuthRefreshingMetricExporter {
+    private createExporter;
+    constructor(createExporter: () => OTLPMetricExporter);
+    private currentExporter;
+    export(metrics: ResourceMetrics, resultCallback: (result: {
+        code: number;
+        error?: Error;
+    }) => void): void;
+    private doExport;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+/**
+ * Creates an OTLP Trace Exporter with the current auth headers
+ */
+export declare function createTraceExporter(): OTLPTraceExporter;
+/**
+ * Creates an OTLP Metric Exporter with the current auth headers
+ */
+export declare function createMetricExporter(): OTLPMetricExporter;

package/dist/auth_refresh_exporters.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthRefreshingMetricExporter = exports.AuthRefreshingSpanExporter = void 0;
+exports.createTraceExporter = createTraceExporter;
+exports.createMetricExporter = createMetricExporter;
+const core_1 = require("@blaxel/core");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+/**
+ * SpanExporter that refreshes authentication before each export.
+ * This is necessary for long-running containers where tokens may expire.
+ */
+class AuthRefreshingSpanExporter {
+    createExporter;
+    constructor(createExporter) {
+        this.createExporter = createExporter;
+        core_1.logger.debug("[AuthRefreshingSpanExporter] Initialized");
+    }
+    currentExporter = null;
+    export(spans, resultCallback) {
+        core_1.logger.debug(`[AuthRefreshingSpanExporter] Exporting ${spans.length} spans`);
+        // Execute async operations but return void as required by interface
+        this.doExport(spans, resultCallback).catch(error => {
+            core_1.logger.error("[AuthRefreshingSpanExporter] Fatal error in export:", error);
+            resultCallback({ code: 1, error: error });
+        });
+    }
+    async doExport(spans, resultCallback) {
+        try {
+            core_1.logger.debug("[AuthRefreshingSpanExporter] Starting authentication refresh");
+            const startTime = Date.now();
+            // Always refresh auth before export
+            await (0, core_1.authenticate)();
+            const authTime = Date.now() - startTime;
+            core_1.logger.debug(`[AuthRefreshingSpanExporter] Authentication completed in ${authTime}ms`);
+            // Log current auth status
+            if (core_1.settings.authorization) {
+                core_1.logger.debug("[AuthRefreshingSpanExporter] Authorization token is present");
+            }
+            else {
+                core_1.logger.warn("[AuthRefreshingSpanExporter] No authorization token after authentication!");
+            }
+            core_1.logger.debug("[AuthRefreshingSpanExporter] Creating new exporter");
+            // Create new exporter with fresh headers
+            this.currentExporter = this.createExporter();
+            core_1.logger.debug("[AuthRefreshingSpanExporter] New exporter created with fresh auth headers");
+            // Export using the fresh exporter
+            if (this.currentExporter && this.currentExporter.export) {
+                core_1.logger.debug("[AuthRefreshingSpanExporter] Calling export on fresh exporter");
+                this.currentExporter.export(spans, resultCallback);
+            }
+            else {
+                const error = new Error('Exporter not initialized');
+                core_1.logger.error("[AuthRefreshingSpanExporter] Exporter not properly initialized", error);
+                resultCallback({ code: 1, error });
+            }
+        }
+        catch (error) {
+            core_1.logger.error("[AuthRefreshingSpanExporter] Error during authentication or export:", error);
+            core_1.logger.error("[AuthRefreshingSpanExporter] Error details:", {
+                message: error.message,
+                stack: error.stack
+            });
+            resultCallback({ code: 1, error: error });
+        }
+    }
+    async shutdown() {
+        core_1.logger.debug("[AuthRefreshingSpanExporter] Shutting down");
+        if (this.currentExporter) {
+            return this.currentExporter.shutdown();
+        }
+    }
+    async forceFlush() {
+        core_1.logger.debug("[AuthRefreshingSpanExporter] Force flushing");
+        if (this.currentExporter && this.currentExporter.forceFlush) {
+            return this.currentExporter.forceFlush();
+        }
+    }
+}
+exports.AuthRefreshingSpanExporter = AuthRefreshingSpanExporter;
+/**
+ * MetricExporter that refreshes authentication before each export.
+ * This is necessary for long-running containers where tokens may expire.
+ */
+class AuthRefreshingMetricExporter {
+    createExporter;
+    constructor(createExporter) {
+        this.createExporter = createExporter;
+        core_1.logger.debug("[AuthRefreshingMetricExporter] Initialized");
+    }
+    currentExporter = null;
+    export(metrics, resultCallback) {
+        core_1.logger.debug("[AuthRefreshingMetricExporter] Exporting metrics");
+        // Execute async operations but return void
+        this.doExport(metrics, resultCallback).catch(error => {
+            core_1.logger.error("[AuthRefreshingMetricExporter] Fatal error in export:", error);
+            resultCallback({ code: 1, error: error });
+        });
+    }
+    async doExport(metrics, resultCallback) {
+        try {
+            core_1.logger.debug("[AuthRefreshingMetricExporter] Starting authentication refresh");
+            const startTime = Date.now();
+            // Always refresh auth before export
+            await (0, core_1.authenticate)();
+            const authTime = Date.now() - startTime;
+            core_1.logger.debug(`[AuthRefreshingMetricExporter] Authentication completed in ${authTime}ms`);
+            // Log current auth status
+            if (core_1.settings.authorization) {
+                core_1.logger.debug("[AuthRefreshingMetricExporter] Authorization token is present");
+            }
+            else {
+                core_1.logger.warn("[AuthRefreshingMetricExporter] No authorization token after authentication!");
+            }
+            core_1.logger.debug("[AuthRefreshingMetricExporter] Creating new exporter");
+            // Create new exporter with fresh headers
+            this.currentExporter = this.createExporter();
+            core_1.logger.debug("[AuthRefreshingMetricExporter] New exporter created with fresh auth headers");
+            // Export using the fresh exporter
+            if (this.currentExporter && this.currentExporter.export) {
+                core_1.logger.debug("[AuthRefreshingMetricExporter] Calling export on fresh exporter");
+                this.currentExporter.export(metrics, resultCallback);
+            }
+            else {
+                const error = new Error('Exporter not initialized');
+                core_1.logger.error("[AuthRefreshingMetricExporter] Exporter not properly initialized", error);
+                resultCallback({ code: 1, error });
+            }
+        }
+        catch (error) {
+            core_1.logger.error("[AuthRefreshingMetricExporter] Error during authentication or export:", error);
+            core_1.logger.error("[AuthRefreshingMetricExporter] Error details:", {
+                message: error.message,
+                stack: error.stack
+            });
+            resultCallback({ code: 1, error: error });
+        }
+    }
+    async shutdown() {
+        core_1.logger.debug("[AuthRefreshingMetricExporter] Shutting down");
+        if (this.currentExporter) {
+            return this.currentExporter.shutdown();
+        }
+    }
+    async forceFlush() {
+        core_1.logger.debug("[AuthRefreshingMetricExporter] Force flushing");
+        if (this.currentExporter && this.currentExporter.forceFlush) {
+            return this.currentExporter.forceFlush();
+        }
+    }
+}
+exports.AuthRefreshingMetricExporter = AuthRefreshingMetricExporter;
+/**
+ * Creates an OTLP Trace Exporter with the current auth headers
+ */
+function createTraceExporter() {
+    const headers = {};
+    if (core_1.settings.authorization) {
+        headers["x-blaxel-authorization"] = core_1.settings.authorization;
+        core_1.logger.debug("[createTraceExporter] Added authorization header");
+    }
+    else {
+        core_1.logger.warn("[createTraceExporter] No authorization available");
+    }
+    if (core_1.settings.workspace) {
+        headers["x-blaxel-workspace"] = core_1.settings.workspace;
+        core_1.logger.debug(`[createTraceExporter] Added workspace header: ${core_1.settings.workspace}`);
+    }
+    else {
+        core_1.logger.warn("[createTraceExporter] No workspace available");
+    }
+    core_1.logger.debug("[createTraceExporter] Creating OTLPTraceExporter with headers:", Object.keys(headers));
+    return new exporter_trace_otlp_http_1.OTLPTraceExporter({
+        headers,
+    });
+}
+/**
+ * Creates an OTLP Metric Exporter with the current auth headers
+ */
+function createMetricExporter() {
+    const headers = {};
+    if (core_1.settings.authorization) {
+        headers["x-blaxel-authorization"] = core_1.settings.authorization;
+        core_1.logger.debug("[createMetricExporter] Added authorization header");
+    }
+    else {
+        core_1.logger.warn("[createMetricExporter] No authorization available");
+    }
+    if (core_1.settings.workspace) {
+        headers["x-blaxel-workspace"] = core_1.settings.workspace;
+        core_1.logger.debug(`[createMetricExporter] Added workspace header: ${core_1.settings.workspace}`);
+    }
+    else {
+        core_1.logger.warn("[createMetricExporter] No workspace available");
+    }
+    core_1.logger.debug("[createMetricExporter] Creating OTLPMetricExporter with headers:", Object.keys(headers));
+    return new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+        headers,
+    });
+}