@blaxel/telemetry 0.2.70 → 0.2.71-dev.105

package/dist/esm/instrumentation/blaxel_core.js

@@ -0,0 +1,197 @@
+import { BlAgent, BlaxelMcpServerTransport, BlJob, McpTool, startSpan, } from "@blaxel/core";
+/**
+ * Monkey-patches BlAgent.prototype.run to wrap with telemetry spans.
+ */
+function patchBlAgent() {
+    const origRun = BlAgent.prototype.run;
+    BlAgent.prototype.run = async function (input, headers = {}, params = {}) {
+        const span = startSpan(this.agentName, {
+            attributes: {
+                "agent.name": this.agentName,
+                "agent.args": JSON.stringify(input),
+                "span.type": "agent.run",
+            },
+            isRoot: false,
+        });
+        try {
+            const result = await origRun.call(this, input, headers, params);
+            span.setAttribute("agent.run.result", result);
+            return result;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                span.setAttribute("agent.run.error", err.stack);
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    };
+}
+/**
+ * Monkey-patches BlJob.prototype.run to wrap with telemetry spans.
+ */
+function patchBlJob() {
+    const origRun = BlJob.prototype.run;
+    BlJob.prototype.run = async function (tasks, options) {
+        const span = startSpan(this.jobName, {
+            attributes: {
+                "job.name": this.jobName,
+                "span.type": "job.run",
+            },
+            isRoot: false,
+        });
+        try {
+            const result = await origRun.call(this, tasks, options);
+            return result;
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                span.setAttribute("job.run.error", err.stack);
+            }
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    };
+}
+/**
+ * Monkey-patches McpTool.prototype.listTools and McpTool.prototype.call
+ * to wrap with telemetry spans.
+ */
+function patchMcpTool() {
+    const origListTools = McpTool.prototype.listTools;
+    const origCall = McpTool.prototype.call;
+    McpTool.prototype.listTools = async function () {
+        const span = startSpan(this.name, {
+            attributes: {
+                "span.type": "tool.list",
+            },
+        });
+        try {
+            const result = await origListTools.call(this);
+            span.setAttribute("tool.list.result", JSON.stringify(result));
+            return result;
+        }
+        catch (err) {
+            span.setStatus("error");
+            span.recordException(err);
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    };
+    McpTool.prototype.call = async function (toolName, args) {
+        const span = startSpan(this.name + "." + toolName, {
+            attributes: {
+                "span.type": "tool.call",
+                "tool.name": toolName,
+                "tool.args": JSON.stringify(args),
+            },
+        });
+        try {
+            const result = await origCall.call(this, toolName, args);
+            span.setAttribute("tool.call.result", JSON.stringify(result));
+            return result;
+        }
+        catch (err) {
+            span.setStatus("error");
+            span.recordException(err);
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    };
+}
+/**
+ * Monkey-patches BlaxelMcpServerTransport to add telemetry spans
+ * for incoming messages (via onmessage setter) and outgoing messages (via send).
+ */
+function patchMcpServer() {
+    // Patch the onmessage setter to wrap the handler with span tracking
+    const origDescriptor = Object.getOwnPropertyDescriptor(BlaxelMcpServerTransport.prototype, "onmessage");
+    if (origDescriptor?.set) {
+        const origSetter = origDescriptor.set;
+        Object.defineProperty(BlaxelMcpServerTransport.prototype, "onmessage", {
+            ...origDescriptor,
+            set(handler) {
+                if (handler) {
+                    const tracedHandler = async (message) => {
+                        const messageId = message.id ? String(message.id) : "";
+                        const [clientId] = messageId.includes(":")
+                            ? messageId.split(":")
+                            : [undefined];
+                        const span = startSpan("mcp.message", {
+                            attributes: {
+                                "span.type": "mcp.message",
+                                ...(clientId ? { "mcp.client.id": clientId } : {}),
+                                ...(message.method
+                                    ? { "mcp.method": message.method }
+                                    : {}),
+                                ...(message.params?.name
+                                    ? {
+                                        "mcp.toolName": message.params.name,
+                                    }
+                                    : {}),
+                            },
+                            isRoot: false,
+                        });
+                        try {
+                            await Promise.resolve(handler(message));
+                        }
+                        catch (err) {
+                            span.setStatus("error");
+                            span.recordException(err);
+                            throw err;
+                        }
+                        finally {
+                            span.end();
+                        }
+                    };
+                    origSetter.call(this, tracedHandler);
+                }
+                else {
+                    origSetter.call(this, handler);
+                }
+            },
+        });
+    }
+    // Patch the send method to wrap with span tracking
+    const origSend = BlaxelMcpServerTransport.prototype.send;
+    BlaxelMcpServerTransport.prototype.send = async function (msg) {
+        const span = startSpan("mcp.send", {
+            attributes: {
+                "span.type": "mcp.send",
+            },
+            isRoot: false,
+        });
+        try {
+            await origSend.call(this, msg);
+            span.setAttributes({
+                "mcp.message.response_sent": true,
+            });
+        }
+        catch (err) {
+            span.setStatus("error");
+            span.recordException(err);
+            throw err;
+        }
+        finally {
+            span.end();
+        }
+    };
+}
+/**
+ * Instruments all @blaxel/core classes with telemetry via monkey patching.
+ * This should be called during telemetry initialization.
+ */
+export function instrumentBlaxelCore() {
+    patchBlAgent();
+    patchBlJob();
+    patchMcpTool();
+    patchMcpServer();
+}

package/dist/esm/telemetry.js

@@ -6,6 +6,7 @@ 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 { instrumentBlaxelCore } from "./instrumentation/blaxel_core.js";
 import { OtelTelemetryProvider } from "./telemetry_provider.js";
 export class BlaxelResource {
     attributes;
@@ -196,6 +197,8 @@ class TelemetryManager {
         registerInstrumentations({
             instrumentations: [httpInstrumentation],
         });
+        // Instrument @blaxel/core classes via monkey patching
+        instrumentBlaxelCore();
     }
     setExporters() {
         const resource = new BlaxelResource(this.resourceAttributes);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blaxel/telemetry",
-	"version": "0.2.70",
+	"version": "0.2.71-dev.105",
 	"description": "Blaxel SDK for TypeScript",
 	"license": "MIT",
 	"author": "Blaxel, INC (https://blaxel.ai)",
@@ -54,7 +54,7 @@
 		"@ai-sdk/google": "^2.0.25",
 		"@ai-sdk/groq": "^2.0.26",
 		"@ai-sdk/openai": "^2.0.57",
-		"@blaxel/core": "0.2.70",
+		"@blaxel/core": "0.2.71-dev.105",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.200.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.200.0",