@blaxel/telemetry 0.2.4-dev.73 → 0.2.4-dev2

package/dist/instrumentationMap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/instrumentationMap.js

@@ -0,0 +1,88 @@
+"use strict";
+// export type InstrumentationInfo = {
+//   modulePath: string;
+//   className: string;
+//   requiredPackages: string[]; // At least one package is required
+//   ignoreIfPackages?: string[];
+//   init?: (instrumentor: any) => void;
+// };
+Object.defineProperty(exports, "__esModule", { value: true });
+// export const instrumentationMap: Record<string, InstrumentationInfo> = {
+//   express: {
+//     modulePath: "@opentelemetry/instrumentation-express",
+//     className: "ExpressInstrumentation",
+//     requiredPackages: ["express"],
+//     ignoreIfPackages: ["fastify"],
+//   },
+//   fastify: {
+//     modulePath: "@opentelemetry/instrumentation-fastify",
+//     className: "FastifyInstrumentation",
+//     requiredPackages: ["fastify"],
+//   },
+//   anthropic: {
+//     modulePath: "@traceloop/instrumentation-anthropic",
+//     className: "AnthropicInstrumentation",
+//     requiredPackages: ["anthropic-ai/sdk"],
+//   },
+//   azure: {
+//     modulePath: "@traceloop/instrumentation-azure",
+//     className: "AzureInstrumentation",
+//     requiredPackages: ["azure/openai"],
+//   },
+//   bedrock: {
+//     modulePath: "@traceloop/instrumentation-bedrock",
+//     className: "BedrockInstrumentation",
+//     requiredPackages: ["aws-sdk/client-bedrock-runtime"],
+//   },
+//   chromadb: {
+//     modulePath: "@traceloop/instrumentation-chromadb",
+//     className: "ChromaDBInstrumentation",
+//     requiredPackages: ["chromadb"],
+//   },
+//   cohere: {
+//     modulePath: "@traceloop/instrumentation-cohere",
+//     className: "CohereInstrumentation",
+//     requiredPackages: ["cohere-js"],
+//   },
+//   langchain: {
+//     modulePath: "@traceloop/instrumentation-langchain",
+//     className: "LangChainInstrumentation",
+//     requiredPackages: [
+//       "langchain",
+//       "@langchain/core",
+//       "@langchain/community",
+//       "@langchain/langgraph",
+//     ],
+//     init: (instrumentor: any) => {
+//       // eslint-disable-next-line @typescript-eslint/no-require-imports
+//       const module = require("./langchain.js") as { [key: string]: any };
+//       // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+//       module.langchain(instrumentor);
+//     },
+//   },
+//   llamaindex: {
+//     modulePath: "@traceloop/instrumentation-llamaindex",
+//     className: "LlamaIndexInstrumentation",
+//     requiredPackages: ["llamaindex"],
+//   },
+//   openai: {
+//     modulePath: "@traceloop/instrumentation-openai",
+//     className: "OpenAIInstrumentation",
+//     requiredPackages: ["openai"],
+//   },
+//   pinecone: {
+//     modulePath: "@traceloop/instrumentation-pinecone",
+//     className: "PineconeInstrumentation",
+//     requiredPackages: ["pinecone-database/pinecone"],
+//   },
+//   qdrant: {
+//     modulePath: "@traceloop/instrumentation-qdrant",
+//     className: "QdrantInstrumentation",
+//     requiredPackages: ["qdrant/js-client-rest"],
+//   },
+//   vertexai: {
+//     modulePath: "@traceloop/instrumentation-vertexai",
+//     className: "VertexAIInstrumentation",
+//     requiredPackages: ["google-cloud/aiplatform"],
+//   },
+// };

package/dist/intex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/intex.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry_1 = __importDefault(require("./telemetry"));
+telemetry_1.default.init();

package/dist/logger.d.ts

@@ -0,0 +1,15 @@
+export declare function overrideConsole(): 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;
+};
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+export declare function stringify<T>(obj: T, maxDepth?: number, depth?: number): string;

package/dist/logger.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.originalLogger = void 0;
+exports.overrideConsole = overrideConsole;
+exports.stringify = stringify;
+/* eslint-disable no-console */
+const api_logs_1 = require("@opentelemetry/api-logs");
+const telemetry_1 = require("./telemetry");
+function overrideConsole() {
+    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,
+};
+/**
+ * Stringify an object with a limited depth
+ * @param obj The object to stringify
+ * @param maxDepth Maximum depth (default: 1)
+ * @param depth Current depth (internal use)
+ */
+function stringify(obj, maxDepth = 1, depth = 0) {
+    if (obj instanceof Error)
+        return obj.stack || obj.message;
+    if (obj === null)
+        return 'null';
+    if (obj === undefined)
+        return 'undefined';
+    // If we've reached max depth or it's not an object
+    if (depth >= maxDepth || typeof obj !== 'object') {
+        return typeof obj === 'object' ? `[${Array.isArray(obj) ? 'Array' : 'object'}]` :
+            typeof obj === 'string' ? `"${obj}"` : String(obj);
+    }
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return `[${obj.map(item => stringify(item, maxDepth, depth + 1)).join(', ')}]`;
+    }
+    // Handle objects
+    const pairs = Object.entries(obj).map(([key, val]) => `"${key}": ${stringify(val, maxDepth, depth + 1)}`);
+    return `{${pairs.join(', ')}}`;
+}
+// Format a log message with appropriate color and prefix
+function formatLogMessage(message, args) {
+    const messageStr = typeof message === "string" ? message : stringify(message, 2);
+    const argsStr = args.map(arg => typeof arg === "string" ? arg : 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

@@ -38,7 +38,6 @@ declare class TelemetryManager {
     get enabled(): boolean;
     get authHeaders(): Record<string, string>;
     sleep(ms: number): Promise<unknown>;
-    flush(): Promise<void>;
     getLogger(): Promise<Logger>;
     setupSignalHandler(): void;
     /**

package/dist/telemetry.js

@@ -112,17 +112,6 @@ class TelemetryManager {
     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();
-        }
-        if (this.loggerProvider) {
-            await this.loggerProvider.shutdown();
-        }
-    }
     async getLogger() {
         if (!this.otelLogger) {
             await this.sleep(100);

package/dist/telemetry_provider.d.ts

@@ -1,7 +1,4 @@
 import { BlaxelSpan, BlaxelSpanOptions, BlaxelTelemetryProvider } from "@blaxel/core";
 export declare class OtelTelemetryProvider implements BlaxelTelemetryProvider {
-    private spans;
-    retrieveActiveSpanContext(): import("@opentelemetry/api").Context;
     startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
-    flush(): Promise<void>;
 }

package/dist/telemetry_provider.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OtelTelemetryProvider = void 0;
 const api_1 = require("@opentelemetry/api");
-const telemetry_1 = require("./telemetry");
 class OtelSpan {
     span;
-    closed = false;
     constructor(span) {
         this.span = span;
     }
@@ -26,7 +24,6 @@ class OtelSpan {
         });
     }
     end() {
-        this.closed = true;
         this.span.end();
     }
     getContext() {
@@ -34,29 +31,22 @@ class OtelSpan {
     }
 }
 class OtelTelemetryProvider {
-    spans = [];
-    retrieveActiveSpanContext() {
-        for (let i = this.spans.length - 1; i >= 0; i--) {
-            const span = this.spans[i];
-            if (!span.closed) {
-                return api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, span.getContext());
-            }
-        }
-        return api_1.context.active();
-    }
     startSpan(name, options) {
+        // Use the tracer from the registered NodeTracerProvider
         const tracer = api_1.trace.getTracer("blaxel");
+        // Prepare OpenTelemetry span options
         const otelOptions = {
             attributes: options?.attributes,
             root: options?.isRoot,
         };
-        let ctx = this.retrieveActiveSpanContext();
-        let span = new OtelSpan(tracer.startSpan(name, otelOptions, ctx));
-        this.spans.push(span);
-        return span;
-    }
-    async flush() {
-        await telemetry_1.blaxelTelemetry.flush();
+        // Handle parent context if provided
+        let ctx = api_1.context.active();
+        if (options?.parentContext) {
+            ctx = options.parentContext;
+        }
+        // Start the span
+        const span = tracer.startSpan(name, otelOptions, ctx);
+        return new OtelSpan(span);
     }
 }
 exports.OtelTelemetryProvider = OtelTelemetryProvider;

package/package.json

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