fix(otel): propagate incoming trace context for HTTP requests

packages/opencode/package.json

@@ -101,6 +101,9 @@
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/util": "workspace:*",
     "@openrouter/ai-sdk-provider": "1.5.4",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.2.0",
+    "@opentelemetry/core": "^2.2.0",
     "@opentui/core": "0.1.90",
     "@opentui/solid": "0.1.90",
     "@parcel/watcher": "2.5.1",

packages/opencode/src/server/server.ts

@@ -36,13 +36,15 @@ import { NotFoundError } from "../storage/db"
 import type { ContentfulStatusCode } from "hono/utils/http-status"
 import { websocket } from "hono/bun"
 import { HTTPException } from "hono/http-exception"
+import { ROOT_CONTEXT, context as otelContext, propagation } from "@opentelemetry/api"
 import { errors } from "./error"
 import { Filesystem } from "@/util/filesystem"
 import { QuestionRoutes } from "./routes/question"
 import { PermissionRoutes } from "./routes/permission"
 import { GlobalRoutes } from "./routes/global"
 import { MDNS } from "./mdns"
 import { lazy } from "@/util/lazy"
+import { TelemetryBootstrap } from "@/telemetry/bootstrap"
 
 // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -53,8 +55,21 @@ export namespace Server {
   export const Default = lazy(() => createApp({}))
 
   export const createApp = (opts: { cors?: string[] }): Hono => {
+    TelemetryBootstrap.init()
     const app = new Hono()
     return app
+      .use(async (_c, next) => {
+        // Continue any incoming distributed trace context.
+        const extractedContext = propagation.extract(ROOT_CONTEXT, _c.req.raw.headers, {
+          get(carrier, key) {
+            return carrier.get(key) ?? undefined
+          },
+          keys(carrier) {
+            return [...carrier.keys()]
+          },
+        })
+        return otelContext.with(extractedContext, next)
+      })
       .onError((err, c) => {
         log.error("failed", {
           error: err,

packages/opencode/src/telemetry/bootstrap.ts

@@ -0,0 +1,14 @@
+import { context, propagation } from "@opentelemetry/api"
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks"
+import { W3CTraceContextPropagator } from "@opentelemetry/core"
+
+let initialized = false
+
+export namespace TelemetryBootstrap {
+  export function init() {
+    if (initialized) return
+    context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable())
+    propagation.setGlobalPropagator(new W3CTraceContextPropagator())
+    initialized = true
+  }
+}

packages/opencode/test/server/trace-context.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, spyOn, test } from "bun:test"
+import { context, trace } from "@opentelemetry/api"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import { Log } from "../../src/util/log"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+describe("server trace context", () => {
+  test("continues incoming trace context for request handlers", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const app = Server.createApp({})
+    const originalProvide = Instance.provide
+    let seen:
+      | {
+          traceId: string | null
+          spanId: string | null
+          isRemote: boolean
+        }
+      | undefined
+    const provideSpy = spyOn(Instance, "provide").mockImplementation(async (input) => {
+      const spanContext = trace.getSpanContext(context.active())
+      seen = {
+        traceId: spanContext?.traceId ?? null,
+        spanId: spanContext?.spanId ?? null,
+        isRemote: spanContext?.isRemote ?? false,
+      }
+      return originalProvide(input)
+    })
+
+    try {
+      const response = await app.request("/path", {
+        headers: {
+          traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+          "x-opencode-directory": tmp.path,
+        },
+      })
+
+      expect(response.status).toBe(200)
+      expect(seen).toEqual({
+        traceId: "4bf92f3577b34da6a3ce929d0e0e4736",
+        spanId: "00f067aa0ba902b7",
+        isRemote: true,
+      })
+    } finally {
+      provideSpy.mockRestore()
+    }
+  })
+
+  test("leaves request handlers on root context when no trace headers are present", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const app = Server.createApp({})
+    const originalProvide = Instance.provide
+    let seen:
+      | {
+          traceId: string | null
+          spanId: string | null
+          isRemote: boolean
+        }
+      | undefined
+    const provideSpy = spyOn(Instance, "provide").mockImplementation(async (input) => {
+      const spanContext = trace.getSpanContext(context.active())
+      seen = {
+        traceId: spanContext?.traceId ?? null,
+        spanId: spanContext?.spanId ?? null,
+        isRemote: spanContext?.isRemote ?? false,
+      }
+      return originalProvide(input)
+    })
+
+    try {
+      const response = await app.request("/path", {
+        headers: {
+          "x-opencode-directory": tmp.path,
+        },
+      })
+
+      expect(response.status).toBe(200)
+      expect(seen).toEqual({
+        traceId: null,
+        spanId: null,
+        isRemote: false,
+      })
+    } finally {
+      provideSpy.mockRestore()
+    }
+  })
+})