@blaxel/telemetry 0.2.23-dev.174 → 0.2.23

package/dist/index.d.ts

@@ -1,4 +1,2 @@
 import { blaxelTelemetry } from "./telemetry";
-export { AuthRefreshingMetricExporter, AuthRefreshingSpanExporter, createMetricExporter, createTraceExporter } from "./auth_refresh_exporters";
-export { setJsonLogger } from "./json_logger";
 export { blaxelTelemetry };

package/dist/index.js

@@ -1,18 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.blaxelTelemetry = exports.setJsonLogger = exports.createTraceExporter = exports.createMetricExporter = exports.AuthRefreshingSpanExporter = exports.AuthRefreshingMetricExporter = void 0;
+exports.blaxelTelemetry = void 0;
 const core_1 = require("@blaxel/core");
 const json_logger_1 = require("./json_logger");
+const legacy_logger_1 = require("./legacy_logger");
 const telemetry_1 = require("./telemetry");
 Object.defineProperty(exports, "blaxelTelemetry", { enumerable: true, get: function () { return telemetry_1.blaxelTelemetry; } });
 telemetry_1.blaxelTelemetry.initialize();
-if (core_1.settings.loggerType === "json") {
+if (core_1.settings.loggerType === "http") {
+    (0, legacy_logger_1.setLegacyLogger)();
+}
+else if (core_1.settings.loggerType === "json") {
     (0, json_logger_1.setJsonLogger)();
 }
-var auth_refresh_exporters_1 = require("./auth_refresh_exporters");
-Object.defineProperty(exports, "AuthRefreshingMetricExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.AuthRefreshingMetricExporter; } });
-Object.defineProperty(exports, "AuthRefreshingSpanExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.AuthRefreshingSpanExporter; } });
-Object.defineProperty(exports, "createMetricExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.createMetricExporter; } });
-Object.defineProperty(exports, "createTraceExporter", { enumerable: true, get: function () { return auth_refresh_exporters_1.createTraceExporter; } });
-var json_logger_2 = require("./json_logger");
-Object.defineProperty(exports, "setJsonLogger", { enumerable: true, get: function () { return json_logger_2.setJsonLogger; } });

package/dist/json_logger.js

@@ -43,83 +43,16 @@ const taskIndex = core_1.env.BL_TASK_KEY || 'TASK_INDEX';
 const taskPrefix = core_1.env.BL_TASK_PREFIX || '';
 const executionKey = core_1.env.BL_EXECUTION_KEY || 'BL_EXECUTION_ID';
 const executionPrefix = core_1.env.BL_EXECUTION_PREFIX || '';
-// Validate environment variables to prevent issues
-function validateEnvVar(value, defaultValue, varName) {
-    if (!value || value.trim() === '') {
-        exports.originalLogger.warn(`Warning: ${varName} environment variable is empty, using default: ${defaultValue}`);
-        return defaultValue;
-    }
-    return value;
-}
-const validatedLabelsName = validateEnvVar(labelsName, 'labels', 'BL_LOGGER_LABELS');
-// Enhanced error serialization to capture all properties
-function serializeError(error) {
-    const serialized = {
-        message: error.message,
-        name: error.name,
-        stack: error.stack
-    };
-    // Capture any additional properties on the error object
-    for (const key of Object.keys(error)) {
-        if (!(key in serialized)) {
-            try {
-                const value = error[key];
-                // Avoid circular references by limiting depth
-                serialized[key] = typeof value === 'object' ? (0, core_1.stringify)(value, 2) : value;
-            }
-            catch {
-                serialized[key] = '[Unserializable]';
-            }
-        }
-    }
-    return serialized;
-}
-// Enhanced stringify function with better error handling
-function enhancedStringify(obj, maxDepth = 2) {
-    if (obj instanceof Error) {
-        return JSON.stringify(serializeError(obj));
-    }
-    // Handle circular references by using a simple set to track seen objects
-    const seen = new WeakSet();
-    const stringifyWithCircularCheck = (value, depth = 0) => {
-        if (value === null || value === undefined)
-            return value;
-        if (typeof value !== 'object')
-            return value;
-        if (seen.has(value)) {
-            return '[Circular Reference]';
-        }
-        if (depth >= maxDepth) {
-            return Array.isArray(value) ? '[Array]' : '[Object]';
-        }
-        seen.add(value);
-        if (Array.isArray(value)) {
-            return value.map(item => stringifyWithCircularCheck(item, depth + 1));
-        }
-        const result = {};
-        for (const [key, val] of Object.entries(value)) {
-            result[key] = stringifyWithCircularCheck(val, depth + 1);
-        }
-        return result;
-    };
-    try {
-        const processed = stringifyWithCircularCheck(obj);
-        return JSON.stringify(processed);
-    }
-    catch {
-        return (0, core_1.stringify)(obj, maxDepth);
-    }
-}
 // Format a log message with appropriate color and prefix
 function formatLogMessage(severity, message, args) {
-    const messageStr = typeof message === "string" ? message : enhancedStringify(message, 2);
-    const argsStr = args.map(arg => typeof arg === "string" ? arg : enhancedStringify(arg, 2)).join(" ");
+    const messageStr = typeof message === "string" ? message : (0, core_1.stringify)(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : (0, core_1.stringify)(arg, 2)).join(" ");
     const msg = `${messageStr}${argsStr ? " " + argsStr : ""}`;
     const logEntry = {
         message: msg,
         severity
     };
-    logEntry[validatedLabelsName] = {};
+    logEntry[labelsName] = {};
     const currentSpan = api_1.trace.getActiveSpan();
     if (currentSpan) {
         const { traceId, spanId } = currentSpan.spanContext();
@@ -128,28 +61,11 @@ function formatLogMessage(severity, message, args) {
     }
     const taskId = core_1.env[taskIndex] || null;
     if (taskId) {
-        logEntry[validatedLabelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
+        logEntry[labelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
     }
     const executionId = core_1.env[executionKey] || null;
     if (executionId) {
-        logEntry[validatedLabelsName]['blaxel-execution'] = `${executionPrefix}${executionId.split('-').pop()}`;
-    }
-    try {
-        return JSON.stringify(logEntry);
-    }
-    catch (error) {
-        // Fallback for serialization errors
-        const fallbackEntry = {
-            message: `JSON serialization failed: ${msg}`,
-            severity,
-            error: error instanceof Error ? error.message : String(error)
-        };
-        try {
-            return JSON.stringify(fallbackEntry);
-        }
-        catch {
-            // Last resort fallback
-            return `{"message":"${severity}: ${msg.replace(/"/g, '\\"')}","severity":"${severity}","error":"Failed to serialize log entry"}`;
-        }
+        logEntry[labelsName]['blaxel-execution'] = `${executionPrefix}${executionId.split('-').pop()}`;
     }
+    return JSON.stringify(logEntry);
 }

package/dist/legacy_logger.d.ts

@@ -0,0 +1,8 @@
+export declare function setLegacyLogger(): void;
+export declare const originalLogger: {
+    info: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    log: (message?: any, ...optionalParams: any[]) => void;
+};

package/dist/legacy_logger.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.originalLogger = void 0;
+exports.setLegacyLogger = setLegacyLogger;
+/* eslint-disable no-console */
+const core_1 = require("@blaxel/core");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const telemetry_1 = require("./telemetry");
+function setLegacyLogger() {
+    console.debug = (message, ...args) => {
+        const msg = formatLogMessage(message, args);
+        exports.originalLogger.log(msg);
+        emitLogSync(api_logs_1.SeverityNumber.DEBUG, msg);
+    };
+    console.log = (message, ...args) => {
+        const msg = formatLogMessage(message, args);
+        exports.originalLogger.log(msg);
+        emitLogSync(api_logs_1.SeverityNumber.INFO, msg);
+    };
+    console.info = (message, ...args) => {
+        const msg = formatLogMessage(message, args);
+        exports.originalLogger.log(msg);
+        emitLogSync(api_logs_1.SeverityNumber.INFO, msg);
+    };
+    console.error = (message, ...args) => {
+        const msg = formatLogMessage(message, args);
+        exports.originalLogger.log(msg);
+        emitLogSync(api_logs_1.SeverityNumber.ERROR, msg);
+    };
+    console.warn = (message, ...args) => {
+        const msg = formatLogMessage(message, args);
+        exports.originalLogger.log(msg);
+        emitLogSync(api_logs_1.SeverityNumber.WARN, msg);
+    };
+}
+exports.originalLogger = {
+    info: console.info,
+    error: console.error,
+    warn: console.warn,
+    debug: console.debug,
+    log: console.log,
+};
+// Format a log message with appropriate color and prefix
+function formatLogMessage(message, args) {
+    const messageStr = typeof message === "string" ? message : (0, core_1.stringify)(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : (0, core_1.stringify)(arg, 2)).join(" ");
+    return `${messageStr}${argsStr ? " " + argsStr : ""}`;
+}
+async function emitLog(severityNumber, message) {
+    const loggerInstance = await telemetry_1.blaxelTelemetry.getLogger();
+    loggerInstance.emit({
+        severityNumber: severityNumber,
+        body: message,
+    });
+}
+function emitLogSync(severityNumber, message) {
+    emitLog(severityNumber, message).catch(() => { });
+}

package/dist/telemetry.d.ts

@@ -1,4 +1,8 @@
 import { Span } from "@opentelemetry/api";
+import { Logger } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { RawResourceAttribute, Resource } from "@opentelemetry/resources";
 import { SpanProcessor } from "@opentelemetry/sdk-trace-node";
 export declare class BlaxelResource implements Resource {
@@ -24,6 +28,8 @@ export type TelemetryOptions = {
 declare class TelemetryManager {
     private nodeTracerProvider;
     private meterProvider;
+    private loggerProvider;
+    private otelLogger;
     private initialized;
     private configured;
     constructor();
@@ -34,6 +40,7 @@ declare class TelemetryManager {
     get authHeaders(): Record<string, string>;
     sleep(ms: number): Promise<unknown>;
     flush(): Promise<void>;
+    getLogger(): Promise<Logger>;
     setupSignalHandler(): void;
     /**
      * Get resource attributes for OpenTelemetry.
@@ -42,11 +49,15 @@ declare class TelemetryManager {
     /**
      * Initialize and return the OTLP Metric Exporter.
      */
-    getMetricExporter(): import("@opentelemetry/exporter-metrics-otlp-http").OTLPMetricExporter;
+    getMetricExporter(): OTLPMetricExporter;
     /**
      * Initialize and return the OTLP Trace Exporter.
      */
-    getTraceExporter(): import("@opentelemetry/exporter-trace-otlp-http").OTLPTraceExporter;
+    getTraceExporter(): OTLPTraceExporter;
+    /**
+     * Initialize and return the OTLP Log Exporter.
+     */
+    getLogExporter(): OTLPLogExporter;
     instrumentApp(): void;
     setExporters(): void;
     shutdownApp(): Promise<void>;

package/dist/telemetry.js

@@ -3,12 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.blaxelTelemetry = exports.DefaultAttributesSpanProcessor = exports.BlaxelResource = void 0;
 const core_1 = require("@blaxel/core");
 const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
 const instrumentation_1 = require("@opentelemetry/instrumentation");
 const instrumentation_http_1 = require("@opentelemetry/instrumentation-http");
 const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
 const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
 const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
-const auth_refresh_exporters_1 = require("./auth_refresh_exporters");
 const telemetry_provider_1 = require("./telemetry_provider");
 class BlaxelResource {
     attributes;
@@ -50,9 +54,6 @@ class DefaultAttributesSpanProcessor {
 }
 exports.DefaultAttributesSpanProcessor = DefaultAttributesSpanProcessor;
 class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor {
-    constructor(exporter, config) {
-        super(exporter, config);
-    }
     onEnd(span) {
         super.onEnd(span);
     }
@@ -60,39 +61,38 @@ class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor
 class TelemetryManager {
     nodeTracerProvider;
     meterProvider;
+    loggerProvider;
+    otelLogger;
     initialized;
     configured;
     constructor() {
         this.nodeTracerProvider = null;
         this.meterProvider = null;
+        this.loggerProvider = null;
+        this.otelLogger = null;
         this.initialized = false;
         this.configured = false;
     }
     // This method need to stay sync to avoid non booted instrumentations
     initialize() {
         if (!this.enabled || this.initialized) {
-            core_1.logger.debug(`[TelemetryManager] Initialize skipped - enabled: ${this.enabled}, initialized: ${this.initialized}`);
             return;
         }
-        core_1.logger.debug("[TelemetryManager] Starting telemetry initialization");
         this.instrumentApp();
         this.setupSignalHandler();
         this.initialized = true;
-        core_1.logger.debug("[TelemetryManager] Telemetry initialized, setting configuration async");
         this.setConfiguration().catch((error) => {
-            core_1.logger.error("[TelemetryManager] Error setting configuration:", error);
+            core_1.logger.error("Error setting configuration:", error);
         });
     }
     async setConfiguration() {
         if (!this.enabled || this.configured) {
-            core_1.logger.debug(`[TelemetryManager] SetConfiguration skipped - enabled: ${this.enabled}, configured: ${this.configured}`);
             return;
         }
-        core_1.logger.debug("[TelemetryManager] Starting authentication for telemetry configuration");
         await (0, core_1.authenticate)();
-        core_1.logger.debug("[TelemetryManager] Authentication completed, setting up exporters");
         this.setExporters();
-        core_1.logger.debug("[TelemetryManager] Telemetry configuration complete");
+        this.otelLogger = api_logs_1.logs.getLogger("blaxel");
+        core_1.logger.debug("Telemetry ready");
         this.configured = true;
     }
     get tracer() {
@@ -121,6 +121,16 @@ class TelemetryManager {
         if (this.meterProvider) {
             await this.meterProvider.shutdown();
         }
+        if (this.loggerProvider) {
+            await this.loggerProvider.shutdown();
+        }
+    }
+    async getLogger() {
+        if (!this.otelLogger) {
+            await this.sleep(100);
+            return this.getLogger();
+        }
+        return this.otelLogger;
     }
     setupSignalHandler() {
         const signals = ["SIGINT", "SIGTERM", "uncaughtException", "exit"];
@@ -161,13 +171,25 @@ class TelemetryManager {
      * Initialize and return the OTLP Metric Exporter.
      */
     getMetricExporter() {
-        return (0, auth_refresh_exporters_1.createMetricExporter)();
+        return new exporter_metrics_otlp_http_1.OTLPMetricExporter({
+            headers: this.authHeaders,
+        });
     }
     /**
      * Initialize and return the OTLP Trace Exporter.
      */
     getTraceExporter() {
-        return (0, auth_refresh_exporters_1.createTraceExporter)();
+        return new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            headers: this.authHeaders,
+        });
+    }
+    /**
+     * Initialize and return the OTLP Log Exporter.
+     */
+    getLogExporter() {
+        return new exporter_logs_otlp_http_1.OTLPLogExporter({
+            headers: this.authHeaders,
+        });
     }
     instrumentApp() {
         core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
@@ -180,18 +202,13 @@ class TelemetryManager {
     }
     setExporters() {
         const resource = new BlaxelResource(this.resourceAttributes);
-        core_1.logger.debug("[TelemetryManager] Setting up exporters with authentication refresh");
-        // Configure batch processor options with 1-second delay
-        const batchProcessorOptions = {
-            scheduledDelayMillis: 1000, // Export every 1 second
-            exportTimeoutMillis: 5000, // Timeout for export
-            maxExportBatchSize: 512, // Max batch size
-            maxQueueSize: 2048 // Max queue size
-        };
-        core_1.logger.debug("[TelemetryManager] Batch processor options:", batchProcessorOptions);
-        // Create auth-refreshing trace exporter
-        const traceExporter = new auth_refresh_exporters_1.AuthRefreshingSpanExporter(() => this.getTraceExporter());
-        core_1.logger.debug("[TelemetryManager] Created AuthRefreshingSpanExporter");
+        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);
+        const traceExporter = this.getTraceExporter();
         this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
             resource,
             sampler: new sdk_trace_node_1.AlwaysOnSampler(),
@@ -201,26 +218,22 @@ class TelemetryManager {
                     "workload.type": core_1.settings.type ? core_1.settings.type + "s" : "",
                     workspace: core_1.settings.workspace || "",
                 }),
-                new sdk_trace_node_1.BatchSpanProcessor(traceExporter, batchProcessorOptions),
-                new HasBeenProcessedSpanProcessor(traceExporter, batchProcessorOptions),
+                new sdk_trace_node_1.BatchSpanProcessor(traceExporter),
+                new HasBeenProcessedSpanProcessor(traceExporter),
             ],
         });
         this.nodeTracerProvider.register();
-        core_1.logger.debug("[TelemetryManager] Trace provider registered");
-        // Create auth-refreshing metric exporter
-        const metricExporter = new auth_refresh_exporters_1.AuthRefreshingMetricExporter(() => this.getMetricExporter());
-        core_1.logger.debug("[TelemetryManager] Created AuthRefreshingMetricExporter");
+        const metricExporter = this.getMetricExporter();
         this.meterProvider = new sdk_metrics_1.MeterProvider({
             resource,
             readers: [
                 new sdk_metrics_1.PeriodicExportingMetricReader({
                     exporter: metricExporter,
-                    exportIntervalMillis: 1000, // Changed from 60000 to 1000 (1 second)
+                    exportIntervalMillis: 60000,
                 }),
             ],
         });
         api_1.metrics.setGlobalMeterProvider(this.meterProvider);
-        core_1.logger.debug("[TelemetryManager] Metric provider configured with 1-second export interval");
     }
     async shutdownApp() {
         try {
@@ -240,6 +253,11 @@ class TelemetryManager {
                     .shutdown()
                     .catch((error) => core_1.logger.debug("Error shutting down meter provider:", error)));
             }
+            if (this.loggerProvider) {
+                shutdownPromises.push(this.loggerProvider
+                    .shutdown()
+                    .catch((error) => core_1.logger.debug("Error shutting down logger provider:", error)));
+            }
             // Wait for all providers to shutdown with a timeout
             await Promise.race([
                 Promise.all(shutdownPromises),

package/package.json

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

package/dist/auth_refresh_exporters.d.ts

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

@@ -1,200 +0,0 @@
-"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,
-    });
-}