@blaxel/telemetry 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/auth_refresh_exporters.js

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

package/dist/esm/index.js

@@ -0,0 +1,10 @@
+import { settings } from "@blaxel/core";
+import { setJsonLogger } from "./json_logger.js";
+import { blaxelTelemetry } from "./telemetry.js";
+blaxelTelemetry.initialize();
+if (settings.loggerType === "json") {
+    setJsonLogger();
+}
+export { AuthRefreshingMetricExporter, AuthRefreshingSpanExporter, createMetricExporter, createTraceExporter } from "./auth_refresh_exporters.js";
+export { setJsonLogger } from "./json_logger.js";
+export { blaxelTelemetry };

package/dist/esm/json_logger.js

@@ -0,0 +1,151 @@
+/* eslint-disable no-console */
+import { env, stringify } from '@blaxel/core';
+import { trace } from '@opentelemetry/api';
+export function setJsonLogger() {
+    console.debug = (message, ...args) => {
+        const msg = formatLogMessage("DEBUG", message, args);
+        originalLogger.log(msg);
+    };
+    console.log = (message, ...args) => {
+        const msg = formatLogMessage("INFO", message, args);
+        originalLogger.log(msg);
+    };
+    console.info = (message, ...args) => {
+        const msg = formatLogMessage("INFO", message, args);
+        originalLogger.log(msg);
+    };
+    console.warn = (message, ...args) => {
+        const msg = formatLogMessage("WARN", message, args);
+        originalLogger.log(msg);
+    };
+    console.error = (message, ...args) => {
+        const msg = formatLogMessage("ERROR", message, args);
+        originalLogger.log(msg);
+    };
+}
+export const originalLogger = {
+    info: console.info,
+    error: console.error,
+    warn: console.warn,
+    debug: console.debug,
+    log: console.log,
+};
+const traceIdName = env.BL_LOGGER_TRACE_ID || 'trace_id';
+const spanIdName = env.BL_LOGGER_SPAN_ID || 'span_id';
+const labelsName = env.BL_LOGGER_LABELS || 'labels';
+const traceIdPrefix = env.BL_LOGGER_TRACE_ID_PREFIX || '';
+const spanIdPrefix = env.BL_LOGGER_SPAN_ID_PREFIX || '';
+const taskIndex = env.BL_TASK_KEY || 'TASK_INDEX';
+const taskPrefix = env.BL_TASK_PREFIX || '';
+const executionKey = env.BL_EXECUTION_KEY || 'BL_EXECUTION_ID';
+const executionPrefix = env.BL_EXECUTION_PREFIX || '';
+// Validate environment variables to prevent issues
+function validateEnvVar(value, defaultValue, varName) {
+    if (!value || value.trim() === '') {
+        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' ? 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 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 msg = `${messageStr}${argsStr ? " " + argsStr : ""}`;
+    const logEntry = {
+        message: msg,
+        severity
+    };
+    logEntry[validatedLabelsName] = {};
+    const currentSpan = trace.getActiveSpan();
+    if (currentSpan) {
+        const { traceId, spanId } = currentSpan.spanContext();
+        logEntry[traceIdName] = `${traceIdPrefix}${traceId}`;
+        logEntry[spanIdName] = `${spanIdPrefix}${spanId}`;
+    }
+    const taskId = env[taskIndex] || null;
+    if (taskId) {
+        logEntry[validatedLabelsName]['blaxel-task'] = `${taskPrefix}${taskId}`;
+    }
+    const executionId = 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"}`;
+        }
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/telemetry.js

@@ -0,0 +1,274 @@
+import { authenticate, env, logger, settings, telemetryRegistry } from "@blaxel/core";
+import { metrics, trace } from "@opentelemetry/api";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { envDetector } from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { AlwaysOnSampler, BatchSpanProcessor, NodeTracerProvider, } from "@opentelemetry/sdk-trace-node";
+import { AuthRefreshingMetricExporter, AuthRefreshingSpanExporter, createMetricExporter, createTraceExporter } from "./auth_refresh_exporters.js";
+import { OtelTelemetryProvider } from "./telemetry_provider.js";
+export class BlaxelResource {
+    attributes;
+    constructor(attributes) {
+        this.attributes = attributes;
+    }
+    merge(other) {
+        if (other?.attributes) {
+            for (const [key, value] of Object.entries(other.attributes)) {
+                if (typeof value === "string") {
+                    this.attributes[key] = value;
+                }
+            }
+        }
+        return this;
+    }
+    getRawAttributes() {
+        return Object.entries(this.attributes).map(([key, value]) => [key, value]);
+    }
+}
+export class DefaultAttributesSpanProcessor {
+    defaultAttributes;
+    constructor(defaultAttributes) {
+        this.defaultAttributes = defaultAttributes;
+    }
+    onStart(span) {
+        Object.entries(this.defaultAttributes).forEach(([key, value]) => {
+            span.setAttribute(key, value);
+        });
+    }
+    onEnd() { }
+    shutdown() {
+        return Promise.resolve();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+}
+class HasBeenProcessedSpanProcessor extends BatchSpanProcessor {
+    constructor(exporter, config) {
+        super(exporter, config);
+    }
+    onEnd(span) {
+        super.onEnd(span);
+    }
+}
+class TelemetryManager {
+    nodeTracerProvider;
+    meterProvider;
+    initialized;
+    configured;
+    shuttingDown;
+    constructor() {
+        this.nodeTracerProvider = null;
+        this.meterProvider = 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) {
+            logger.debug(`[TelemetryManager] Initialize skipped - enabled: ${this.enabled}, initialized: ${this.initialized}`);
+            return;
+        }
+        logger.debug("[TelemetryManager] Starting telemetry initialization");
+        this.instrumentApp();
+        this.setupSignalHandler();
+        this.initialized = true;
+        logger.debug("[TelemetryManager] Telemetry initialized, setting configuration async");
+        this.setConfiguration().catch((error) => {
+            logger.error("[TelemetryManager] Error setting configuration:", error);
+        });
+    }
+    async setConfiguration() {
+        if (!this.enabled || this.configured) {
+            logger.debug(`[TelemetryManager] SetConfiguration skipped - enabled: ${this.enabled}, configured: ${this.configured}`);
+            return;
+        }
+        logger.debug("[TelemetryManager] Starting authentication for telemetry configuration");
+        await authenticate();
+        logger.debug("[TelemetryManager] Authentication completed, setting up exporters");
+        this.setExporters();
+        logger.debug("[TelemetryManager] Telemetry configuration complete");
+        this.configured = true;
+    }
+    get tracer() {
+        return trace.getTracer("blaxel");
+    }
+    get enabled() {
+        return env.BL_ENABLE_OPENTELEMETRY === "true";
+    }
+    get authHeaders() {
+        const headers = {};
+        if (settings.authorization) {
+            headers["x-blaxel-authorization"] = settings.authorization;
+        }
+        if (settings.workspace) {
+            headers["x-blaxel-workspace"] = settings.workspace;
+        }
+        return headers;
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async flush() {
+        if (this.nodeTracerProvider) {
+            await this.nodeTracerProvider.shutdown();
+        }
+        if (this.meterProvider) {
+            await this.meterProvider.shutdown();
+        }
+    }
+    setupSignalHandler() {
+        const forward = (sig) => {
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            this.shutdownApp()
+                .catch((error) => {
+                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) => {
+            logger.error("Uncaught exception:", err);
+            this.shutdownApp().catch((error) => {
+                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.
+     */
+    get resourceAttributes() {
+        const resource = envDetector.detect();
+        const attributes = resource.attributes || {};
+        if (settings.name) {
+            attributes["service.name"] = settings.name;
+            attributes["workload.id"] = settings.name;
+        }
+        if (settings.workspace) {
+            attributes["workspace"] = settings.workspace;
+        }
+        if (settings.type) {
+            attributes["workload.type"] = settings.type + "s";
+        }
+        // Only keep string values
+        const stringAttrs = {};
+        for (const [k, v] of Object.entries(attributes)) {
+            if (typeof v === "string")
+                stringAttrs[k] = v;
+        }
+        return stringAttrs;
+    }
+    /**
+     * Initialize and return the OTLP Metric Exporter.
+     */
+    getMetricExporter() {
+        return createMetricExporter();
+    }
+    /**
+     * Initialize and return the OTLP Trace Exporter.
+     */
+    getTraceExporter() {
+        return createTraceExporter();
+    }
+    instrumentApp() {
+        telemetryRegistry.registerProvider(new OtelTelemetryProvider());
+        const httpInstrumentation = new HttpInstrumentation({
+            requireParentforOutgoingSpans: true,
+        });
+        registerInstrumentations({
+            instrumentations: [httpInstrumentation],
+        });
+    }
+    setExporters() {
+        const resource = new BlaxelResource(this.resourceAttributes);
+        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
+        };
+        logger.debug("[TelemetryManager] Batch processor options:", batchProcessorOptions);
+        // Create auth-refreshing trace exporter
+        const traceExporter = new AuthRefreshingSpanExporter(() => this.getTraceExporter());
+        logger.debug("[TelemetryManager] Created AuthRefreshingSpanExporter");
+        this.nodeTracerProvider = new NodeTracerProvider({
+            resource,
+            sampler: new AlwaysOnSampler(),
+            spanProcessors: [
+                new DefaultAttributesSpanProcessor({
+                    "workload.id": settings.name || "",
+                    "workload.type": settings.type ? settings.type + "s" : "",
+                    workspace: settings.workspace || "",
+                }),
+                new BatchSpanProcessor(traceExporter, batchProcessorOptions),
+                new HasBeenProcessedSpanProcessor(traceExporter, batchProcessorOptions),
+            ],
+        });
+        this.nodeTracerProvider.register();
+        logger.debug("[TelemetryManager] Trace provider registered");
+        // Create auth-refreshing metric exporter
+        const metricExporter = new AuthRefreshingMetricExporter(() => this.getMetricExporter());
+        logger.debug("[TelemetryManager] Created AuthRefreshingMetricExporter");
+        this.meterProvider = new MeterProvider({
+            resource,
+            readers: [
+                new PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: 1000, // Changed from 60000 to 1000 (1 second)
+                }),
+            ],
+        });
+        metrics.setGlobalMeterProvider(this.meterProvider);
+        logger.debug("[TelemetryManager] Metric provider configured with 1-second export interval");
+    }
+    async shutdownApp() {
+        try {
+            const maxSleepTime = 5000;
+            const startTime = Date.now();
+            while (!this.configured && Date.now() - startTime < maxSleepTime) {
+                await this.sleep(100);
+            }
+            const shutdownPromises = [];
+            if (this.nodeTracerProvider) {
+                shutdownPromises.push(this.nodeTracerProvider
+                    .shutdown()
+                    .catch((error) => logger.debug("Error shutting down tracer provider:", error)));
+            }
+            if (this.meterProvider) {
+                shutdownPromises.push(this.meterProvider
+                    .shutdown()
+                    .catch((error) => logger.debug("Error shutting down meter 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
+            ]);
+            logger.debug("Instrumentation shutdown complete");
+        }
+        catch (error) {
+            logger.error("Error during shutdown:", error);
+        }
+    }
+}
+export const blaxelTelemetry = new TelemetryManager();

package/dist/esm/telemetry_provider.js

@@ -0,0 +1,58 @@
+import { context as otelContext, ROOT_CONTEXT, SpanStatusCode, trace } from "@opentelemetry/api";
+import { blaxelTelemetry } from "./telemetry.js";
+class OtelSpan {
+    span;
+    closed = false;
+    constructor(span) {
+        this.span = span;
+    }
+    setAttribute(key, value) {
+        this.span.setAttribute(key, value);
+    }
+    setAttributes(attributes) {
+        Object.entries(attributes).forEach(([k, v]) => this.span.setAttribute(k, v));
+    }
+    recordException(error) {
+        this.span.recordException(error);
+        this.span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+    }
+    setStatus(status, message) {
+        this.span.setStatus({
+            code: status === 'ok' ? SpanStatusCode.OK : SpanStatusCode.ERROR,
+            message,
+        });
+    }
+    end() {
+        this.closed = true;
+        this.span.end();
+    }
+    getContext() {
+        return this.span.spanContext();
+    }
+}
+export class OtelTelemetryProvider {
+    spans = [];
+    retrieveActiveSpanContext() {
+        for (let i = this.spans.length - 1; i >= 0; i--) {
+            const span = this.spans[i];
+            if (!span.closed) {
+                return trace.setSpanContext(ROOT_CONTEXT, span.getContext());
+            }
+        }
+        return otelContext.active();
+    }
+    startSpan(name, options) {
+        const tracer = trace.getTracer("blaxel");
+        const otelOptions = {
+            attributes: options?.attributes,
+            root: options?.isRoot,
+        };
+        const ctx = this.retrieveActiveSpanContext();
+        const span = new OtelSpan(tracer.startSpan(name, otelOptions, ctx));
+        this.spans.push(span);
+        return span;
+    }
+    async flush() {
+        await blaxelTelemetry.flush();
+    }
+}