@blaxel/telemetry 0.2.70-preview.99 → 0.2.71-dev.101

package/dist/cjs/instrumentation/blaxel_core.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentBlaxelCore = instrumentBlaxelCore;
+const core_1 = require("@blaxel/core");
+/**
+ * Monkey-patches BlAgent.prototype.run to wrap with telemetry spans.
+ */
+function patchBlAgent() {
+    const origRun = core_1.BlAgent.prototype.run;
+    core_1.BlAgent.prototype.run = async function (input, headers = {}, params = {}) {
+        const span = (0, core_1.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 = core_1.BlJob.prototype.run;
+    core_1.BlJob.prototype.run = async function (tasks, options) {
+        const span = (0, core_1.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 = core_1.McpTool.prototype.listTools;
+    const origCall = core_1.McpTool.prototype.call;
+    core_1.McpTool.prototype.listTools = async function () {
+        const span = (0, core_1.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();
+        }
+    };
+    core_1.McpTool.prototype.call = async function (toolName, args) {
+        const span = (0, core_1.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(core_1.BlaxelMcpServerTransport.prototype, "onmessage");
+    if (origDescriptor?.set) {
+        const origSetter = origDescriptor.set;
+        Object.defineProperty(core_1.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 = (0, core_1.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 = core_1.BlaxelMcpServerTransport.prototype.send;
+    core_1.BlaxelMcpServerTransport.prototype.send = async function (msg) {
+        const span = (0, core_1.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.
+ */
+function instrumentBlaxelCore() {
+    patchBlAgent();
+    patchBlJob();
+    patchMcpTool();
+    patchMcpServer();
+}

package/dist/cjs/telemetry.js

@@ -9,6 +9,7 @@ const resources_1 = require("@opentelemetry/resources");
 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 blaxel_core_1 = require("./instrumentation/blaxel_core");
 const telemetry_provider_1 = require("./telemetry_provider");
 class BlaxelResource {
     attributes;
@@ -201,6 +202,8 @@ class TelemetryManager {
         (0, instrumentation_1.registerInstrumentations)({
             instrumentations: [httpInstrumentation],
         });
+        // Instrument @blaxel/core classes via monkey patching
+        (0, blaxel_core_1.instrumentBlaxelCore)();
     }
     setExporters() {
         const resource = new BlaxelResource(this.resourceAttributes);

package/dist/cjs/types/instrumentation/blaxel_core.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Instruments all @blaxel/core classes with telemetry via monkey patching.
+ * This should be called during telemetry initialization.
+ */
+export declare function instrumentBlaxelCore(): void;