Add spans over execution stack assembly

Name the shared executor, plugin, engine, and MCP server assembly steps so the post-auth execution gap is visible in traces.

Rhys Sullivan committed 4 months ago

Commit 2c1687a1 parent c926a3f5 files · +35 −16Browse files

Unified · Split

5 files

apps/cloud/src/mcp/session-durable-object.ts +3 −1
packages/core/api/src/server/execution-stack-middleware.ts +5 −2
packages/core/api/src/server/execution-stack.ts +14 −8
packages/core/api/src/server/mcp-build.ts +2 −0
packages/core/api/src/server/scoped-executor.ts +11 −5

apps/cloud/src/mcp/session-durable-object.ts+3−1

       // Build the description here so `executor.connections.list()` stays under
       // the DO startup span and the MCP SDK receives a concrete string instead
       // of invoking `engine.getDescription` across its async boundary.
-      const description = yield* buildExecuteDescription(executor);
+      const description = yield* buildExecuteDescription(executor).pipe(
+        Effect.withSpan("mcp.execute.description.build"),
+      );
       const sessionElicitationMode = sessionMeta.elicitationMode ?? "model";
       const mcpServer = yield* createExecutorMcpServer({
         engine,

packages/core/api/src/server/execution-stack-middleware.ts+5−2

           // provider carried one. Absent slug -> the service stays unprovided and
           // the URL falls back to its bare, client-canonicalized form.
           const { executor, engine } = yield* resolved.organizationSlug !== undefined
-            ? stack.pipe(Effect.provideService(RequestOrgSlug, { slug: resolved.organizationSlug }))
+            ? stack.pipe(
-            : stack;
+                Effect.provideService(RequestOrgSlug, { slug: resolved.organizationSlug }),
+                Effect.withSpan("executor.stack.http.resolve"),
+              )
+            : stack.pipe(Effect.withSpan("executor.stack.http.resolve"));
           return yield* httpEffect.pipe(
             Effect.provideService(AuthContext, auth),
             Effect.provideService(ExecutorService, executor),

packages/core/api/src/server/execution-stack.ts+14−8

@@ -108,13 +108,19 @@ export const makeExecutionStack = < · 107 unmodified lines
108	organizationId,	108	organizationId,
109	organizationName,	109	organizationName,
110	{ plugins: { mcpResource: options?.mcpResource } },	110	{ plugins: { mcpResource: options?.mcpResource } },
		111	).pipe(Effect.withSpan("executor.stack.scoped_executor"));
		112	const codeExecutor = yield* CodeExecutorProvider.asEffect().pipe(
		113	Effect.withSpan("executor.stack.code_executor"),
111	);	114	);
112	const codeExecutor = yield* CodeExecutorProvider;	115	const { decorate } = yield* EngineDecorator.asEffect().pipe(
113	const { decorate } = yield* EngineDecorator;	116	Effect.withSpan("executor.stack.decorator"),
114	const engine = decorate(createExecutionEngine({ executor, codeExecutor }), {	117	);
115	accountId,	118	const engine = yield* Effect.sync(() =>
116	organizationId,	119	decorate(createExecutionEngine({ executor, codeExecutor }), {
117	organizationName,	120	accountId,
118	});	121	organizationId,
		122	organizationName,
		123	}),
		124	).pipe(Effect.withSpan("executor.stack.engine.init"));
119	return { executor, engine };	125	return { executor, engine };
120	});	126	}).pipe(Effect.withSpan("executor.stack.build"));

packages/core/api/src/server/mcp-build.ts+2−0

     makeExecutionStack(principal.accountId, principal.organizationId, principal.organizationName, {
       mcpResource: options?.resource,
     }).pipe(
+      Effect.withSpan("mcp.execution_stack.build"),
       Effect.map(({ engine }) => engine),
       // Pin browser-handoff URLs to the principal's org slug when present;
       // absent slug leaves the service unprovided and the URL stays bare.
       Effect.mapError((cause) => new McpEngineBuildError({ cause })),
       Effect.flatMap((engine) =>
         createExecutorMcpServer({ engine, ...(options ?? {}) }).pipe(
+          Effect.withSpan("mcp.server.create"),
           Effect.map((mcpServer) => ({ mcpServer, engine })),
         ),
       ),

packages/core/api/src/server/scoped-executor.ts+11−5

   options?: { readonly plugins?: PluginsProviderContext },
 ): Effect.Effect<Executor<TPlugins>, StorageFailure, DbProvider | PluginsProvider | HostConfig> =>
   Effect.gen(function* () {
-    const { db, blobs } = yield* DbProvider;
+    const { db, blobs } = yield* DbProvider.asEffect().pipe(
-    const { plugins: pluginsFactory } = yield* PluginsProvider;
+      Effect.withSpan("executor.stack.db_provider"),
-    const config = yield* HostConfig;
+    );
+    const { plugins: pluginsFactory } = yield* PluginsProvider.asEffect().pipe(
+      Effect.withSpan("executor.stack.plugins_provider"),
+    );
+    const config = yield* HostConfig.asEffect().pipe(Effect.withSpan("executor.stack.host_config"));
     // Explicit config wins; otherwise fall back to the request origin if a host
     // provided one (HTTP middleware / MCP session DO). Stays `undefined` for
     // non-request callers — `coreTools.webBaseUrl` is optional and only the
       oauthCallbackPath: config.oauthCallbackPath,
     });
-    const plugins = pluginsFactory(options?.plugins);
+    const plugins = yield* Effect.sync(() => pluginsFactory(options?.plugins)).pipe(
+      Effect.withSpan("executor.plugins.init"),
+    );
     const hostedHttpOptions = {
       allowLocalNetwork: config.allowLocalNetwork,
     };
         orgSlug,
         includeProviders: config.exposeCredentialProviders ?? true,
       },
-    });
+    }).pipe(Effect.withSpan("executor.stack.create_executor"));
     // The seam erases the plugin tuple type; the caller re-narrows via the
     // `TPlugins` phantom. Runtime shape is identical to a typed
     // `createExecutor({ plugins })` call.