@blaxel/telemetry 0.2.33 → 0.2.35-preview.78

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,
+    });
+}

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 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,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.blaxelTelemetry = void 0;
+exports.blaxelTelemetry = exports.setJsonLogger = exports.createTraceExporter = exports.createMetricExporter = exports.AuthRefreshingSpanExporter = exports.AuthRefreshingMetricExporter = 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 === "http") {
-    (0, legacy_logger_1.setLegacyLogger)();
-}
-else if (core_1.settings.loggerType === "json") {
+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,16 +43,83 @@ 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 : (0, core_1.stringify)(message, 2);
-    const argsStr = args.map(arg => typeof arg === "string" ? arg : (0, core_1.stringify)(arg, 2)).join(" ");
+    const messageStr = typeof message === "string" ? message : enhancedStringify(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : enhancedStringify(arg, 2)).join(" ");
     const msg = `${messageStr}${argsStr ? " " + argsStr : ""}`;
     const logEntry = {
         message: msg,
         severity
     };
-    logEntry[labelsName] = {};
+    logEntry[validatedLabelsName] = {};
     const currentSpan = api_1.trace.getActiveSpan();
     if (currentSpan) {
         const { traceId, spanId } = currentSpan.spanContext();
@@ -61,11 +128,28 @@ function formatLogMessage(severity, message, args) {
     }
     const taskId = core_1.env[taskIndex] || null;
     if (taskId) {
-        logEntry[labelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
+        logEntry[validatedLabelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
     }
     const executionId = core_1.env[executionKey] || null;
     if (executionId) {
-        logEntry[labelsName]['blaxel-execution'] = `${executionPrefix}${executionId.split('-').pop()}`;
+        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"}`;
+        }
     }
-    return JSON.stringify(logEntry);
 }

package/dist/telemetry.d.ts

@@ -1,8 +1,4 @@
 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 {
@@ -28,10 +24,9 @@ export type TelemetryOptions = {
 declare class TelemetryManager {
     private nodeTracerProvider;
     private meterProvider;
-    private loggerProvider;
-    private otelLogger;
     private initialized;
     private configured;
+    private shuttingDown;
     constructor();
     initialize(): void;
     setConfiguration(): Promise<void>;
@@ -40,7 +35,6 @@ 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.
@@ -49,15 +43,11 @@ declare class TelemetryManager {
     /**
      * Initialize and return the OTLP Metric Exporter.
      */
-    getMetricExporter(): OTLPMetricExporter;
+    getMetricExporter(): import("@opentelemetry/exporter-metrics-otlp-http").OTLPMetricExporter;
     /**
      * Initialize and return the OTLP Trace Exporter.
      */
-    getTraceExporter(): OTLPTraceExporter;
-    /**
-     * Initialize and return the OTLP Log Exporter.
-     */
-    getLogExporter(): OTLPLogExporter;
+    getTraceExporter(): import("@opentelemetry/exporter-trace-otlp-http").OTLPTraceExporter;
     instrumentApp(): void;
     setExporters(): void;
     shutdownApp(): Promise<void>;

package/dist/telemetry.js

@@ -3,16 +3,12 @@ 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;
@@ -54,6 +50,9 @@ class DefaultAttributesSpanProcessor {
 }
 exports.DefaultAttributesSpanProcessor = DefaultAttributesSpanProcessor;
 class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor {
+    constructor(exporter, config) {
+        super(exporter, config);
+    }
     onEnd(span) {
         super.onEnd(span);
     }
@@ -61,38 +60,41 @@ class HasBeenProcessedSpanProcessor extends sdk_trace_node_1.BatchSpanProcessor
 class TelemetryManager {
     nodeTracerProvider;
     meterProvider;
-    loggerProvider;
-    otelLogger;
     initialized;
     configured;
+    shuttingDown;
     constructor() {
         this.nodeTracerProvider = null;
         this.meterProvider = null;
-        this.loggerProvider = null;
-        this.otelLogger = null;
         this.initialized = false;
         this.configured = false;
+        this.shuttingDown = 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("Error setting configuration:", error);
+            core_1.logger.error("[TelemetryManager] 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();
-        this.otelLogger = api_logs_1.logs.getLogger("blaxel");
-        core_1.logger.debug("Telemetry ready");
+        core_1.logger.debug("[TelemetryManager] Telemetry configuration complete");
         this.configured = true;
     }
     get tracer() {
@@ -121,27 +123,39 @@ 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"];
-        for (const signal of signals) {
-            process.on(signal, () => {
-                this.shutdownApp().catch((error) => {
-                    core_1.logger.debug("Fatal error during shutdown:", error);
-                    process.exit(0);
+        const forward = (sig) => {
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            this.shutdownApp()
+                .catch((error) => {
+                core_1.logger.debug("Fatal error during shutdown:", error);
+            })
+                .finally(() => {
+                try {
+                    // Re-send the original signal to let the default handler terminate the process with the correct code
+                    process.kill(process.pid, sig);
+                }
+                catch {
+                    process.exit(1);
+                }
+            });
+        };
+        process.once("SIGINT", () => forward("SIGINT"));
+        process.once("SIGTERM", () => forward("SIGTERM"));
+        process.once("uncaughtException", (err) => {
+            core_1.logger.error("Uncaught exception:", err);
+            this.shutdownApp().catch((error) => {
+                core_1.logger.debug("Fatal error during shutdown:", error);
+            }).finally(() => {
+                // Re-throw on next tick so Node's default handler sets exit code and prints stack
+                setImmediate(() => {
+                    throw (err instanceof Error ? err : new Error(String(err)));
                 });
             });
-        }
+        });
     }
     /**
      * Get resource attributes for OpenTelemetry.
@@ -171,25 +185,13 @@ class TelemetryManager {
      * Initialize and return the OTLP Metric Exporter.
      */
     getMetricExporter() {
-        return new exporter_metrics_otlp_http_1.OTLPMetricExporter({
-            headers: this.authHeaders,
-        });
+        return (0, auth_refresh_exporters_1.createMetricExporter)();
     }
     /**
      * Initialize and return the OTLP Trace Exporter.
      */
     getTraceExporter() {
-        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,
-        });
+        return (0, auth_refresh_exporters_1.createTraceExporter)();
     }
     instrumentApp() {
         core_1.telemetryRegistry.registerProvider(new telemetry_provider_1.OtelTelemetryProvider());
@@ -202,13 +204,18 @@ class TelemetryManager {
     }
     setExporters() {
         const resource = new BlaxelResource(this.resourceAttributes);
-        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();
+        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");
         this.nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
             resource,
             sampler: new sdk_trace_node_1.AlwaysOnSampler(),
@@ -218,22 +225,26 @@ 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),
-                new HasBeenProcessedSpanProcessor(traceExporter),
+                new sdk_trace_node_1.BatchSpanProcessor(traceExporter, batchProcessorOptions),
+                new HasBeenProcessedSpanProcessor(traceExporter, batchProcessorOptions),
             ],
         });
         this.nodeTracerProvider.register();
-        const metricExporter = this.getMetricExporter();
+        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");
         this.meterProvider = new sdk_metrics_1.MeterProvider({
             resource,
             readers: [
                 new sdk_metrics_1.PeriodicExportingMetricReader({
                     exporter: metricExporter,
-                    exportIntervalMillis: 60000,
+                    exportIntervalMillis: 1000, // Changed from 60000 to 1000 (1 second)
                 }),
             ],
         });
         api_1.metrics.setGlobalMeterProvider(this.meterProvider);
+        core_1.logger.debug("[TelemetryManager] Metric provider configured with 1-second export interval");
     }
     async shutdownApp() {
         try {
@@ -253,22 +264,15 @@ 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),
                 new Promise((resolve) => setTimeout(resolve, 5000)), // 5 second timeout
             ]);
             core_1.logger.debug("Instrumentation shutdown complete");
-            process.exit(0);
         }
         catch (error) {
             core_1.logger.error("Error during shutdown:", error);
-            process.exit(1);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/telemetry",
-  "version": "0.2.33",
+  "version": "0.2.35-preview.78",
   "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.33"
+    "@blaxel/core": "0.2.35-preview.78"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",

package/dist/legacy_logger.d.ts

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

@@ -1,58 +0,0 @@
-"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(() => { });
-}