Add bundle MCP timeline spans

LLagoon3 · LLagoon3 · commit f9ddbbe2d626 · 2026-05-14T19:20:37.000+09:00
diff --git a/src/agents/pi-bundle-mcp-runtime.test.ts b/src/agents/pi-bundle-mcp-runtime.test.ts
@@ -1,8 +1,13 @@
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { writeBundleProbeMcpServer } from "./bundle-mcp-shared.test-harness.js";
 import { createBundleMcpJsonSchemaValidator } from "./pi-bundle-mcp-runtime.js";
 import { cleanupBundleMcpHarness } from "./pi-bundle-mcp-test-harness.js";
 import {
   __testing,
+  createSessionMcpRuntime,
   getOrCreateSessionMcpRuntime,
   materializeBundleMcpToolsForRun,
   retireSessionMcpRuntime,
@@ -141,6 +146,64 @@ describe("session MCP runtime", () => {
     ]);
   });
 
+  it("emits diagnostics timeline spans for bundle MCP server catalog discovery", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "openclaw-bundle-mcp-timeline-"));
+    const serverScriptPath = join(dir, "bundle-probe-server.mjs");
+    const timelinePath = join(dir, "timeline.jsonl");
+    await writeBundleProbeMcpServer(serverScriptPath);
+    const previousDiagnostics = process.env.OPENCLAW_DIAGNOSTICS;
+    const previousTimelinePath = process.env.OPENCLAW_DIAGNOSTICS_TIMELINE_PATH;
+    process.env.OPENCLAW_DIAGNOSTICS = "timeline";
+    process.env.OPENCLAW_DIAGNOSTICS_TIMELINE_PATH = timelinePath;
+    try {
+      const runtime = createSessionMcpRuntime({
+        sessionId: "session-timeline",
+        workspaceDir: dir,
+        cfg: {
+          mcp: {
+            servers: {
+              bundleProbe: {
+                command: "node",
+                args: [serverScriptPath],
+              },
+            },
+          },
+        },
+      });
+      const materialized = await materializeBundleMcpToolsForRun({ runtime });
+      await materialized.dispose();
+      await runtime.dispose();
+
+      const events = (await readFile(timelinePath, "utf-8"))
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line) as { name: string; type: string; durationMs?: number });
+      expect(events).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "bundle-mcp.server", type: "span.end" }),
+          expect.objectContaining({ name: "bundle-mcp.connect", type: "span.end" }),
+          expect.objectContaining({ name: "bundle-mcp.tools-list", type: "span.end" }),
+        ]),
+      );
+      const toolsListSpan = events.find(
+        (event) => event.name === "bundle-mcp.tools-list" && event.type === "span.end",
+      );
+      expect(toolsListSpan?.durationMs).toEqual(expect.any(Number));
+    } finally {
+      if (previousDiagnostics === undefined) {
+        delete process.env.OPENCLAW_DIAGNOSTICS;
+      } else {
+        process.env.OPENCLAW_DIAGNOSTICS = previousDiagnostics;
+      }
+      if (previousTimelinePath === undefined) {
+        delete process.env.OPENCLAW_DIAGNOSTICS_TIMELINE_PATH;
+      } else {
+        process.env.OPENCLAW_DIAGNOSTICS_TIMELINE_PATH = previousTimelinePath;
+      }
+    }
+  });
+
   it("holds a runtime lease until the materialized tool runtime is disposed", async () => {
     let activeLeases = 0;
     const runtime = {
diff --git a/src/agents/pi-bundle-mcp-runtime.ts b/src/agents/pi-bundle-mcp-runtime.ts
@@ -12,6 +12,7 @@ import type {
 } from "@modelcontextprotocol/sdk/validation/types.js";
 import type { ErrorObject, ValidateFunction } from "ajv";
 import type { OpenClawConfig } from "../config/types.openclaw.js";
+import { measureDiagnosticsTimelineSpan } from "../infra/diagnostics-timeline.js";
 import { logWarn } from "../logger.js";
 import { resolveGlobalSingleton } from "../shared/global-singleton.js";
 import { redactSensitiveUrlLikeString } from "../shared/net/redact-sensitive-url.js";
@@ -257,31 +258,67 @@ export function createSessionMcpRuntime(params: {
           sessions.set(serverName, session);
 
           try {
-            failIfDisposed();
-            await connectWithTimeout(client, resolved.transport, resolved.connectionTimeoutMs);
-            failIfDisposed();
-            const listedTools = await listAllTools(client);
-            failIfDisposed();
-            servers[serverName] = {
-              serverName,
-              launchSummary: resolved.description,
-              toolCount: listedTools.length,
-            };
-            for (const tool of listedTools) {
-              const toolName = tool.name.trim();
-              if (!toolName) {
-                continue;
-              }
-              tools.push({
-                serverName,
-                safeServerName,
-                toolName,
-                title: tool.title,
-                description: normalizeOptionalString(tool.description),
-                inputSchema: tool.inputSchema,
-                fallbackDescription: `Provided by bundle MCP server "${serverName}" (${resolved.description}).`,
-              });
-            }
+            await measureDiagnosticsTimelineSpan(
+              "bundle-mcp.server",
+              async () => {
+                failIfDisposed();
+                await measureDiagnosticsTimelineSpan(
+                  "bundle-mcp.connect",
+                  () =>
+                    connectWithTimeout(client, resolved.transport, resolved.connectionTimeoutMs),
+                  {
+                    config: params.cfg,
+                    attributes: {
+                      serverName,
+                      safeServerName,
+                      transportType: resolved.transportType,
+                    },
+                  },
+                );
+                failIfDisposed();
+                const listedTools = await measureDiagnosticsTimelineSpan(
+                  "bundle-mcp.tools-list",
+                  () => listAllTools(client),
+                  {
+                    config: params.cfg,
+                    attributes: {
+                      serverName,
+                      safeServerName,
+                      transportType: resolved.transportType,
+                    },
+                  },
+                );
+                failIfDisposed();
+                servers[serverName] = {
+                  serverName,
+                  launchSummary: resolved.description,
+                  toolCount: listedTools.length,
+                };
+                for (const tool of listedTools) {
+                  const toolName = tool.name.trim();
+                  if (!toolName) {
+                    continue;
+                  }
+                  tools.push({
+                    serverName,
+                    safeServerName,
+                    toolName,
+                    title: tool.title,
+                    description: normalizeOptionalString(tool.description),
+                    inputSchema: tool.inputSchema,
+                    fallbackDescription: `Provided by bundle MCP server "${serverName}" (${resolved.description}).`,
+                  });
+                }
+              },
+              {
+                config: params.cfg,
+                attributes: {
+                  serverName,
+                  safeServerName,
+                  transportType: resolved.transportType,
+                },
+              },
+            );
           } catch (error) {
             if (!disposed) {
               logWarn(
