refactor: extract shared util package (#37828)

packages/util/src/observability/logging.ts

@@ -0,0 +1,77 @@
+import { Formatter, Logger, type LogLevel } from "effect"
+import path from "path"
+import { Global } from "../global"
+import { InstallationChannel, InstallationLocal } from "../installation/version"
+import { runID } from "./shared"
+
+function formatter(id: string = runID) {
+  return Logger.map(Logger.formatStructured, (output) => {
+    const messages = Array.isArray(output.message) ? output.message : [output.message]
+    return [
+      ["timestamp", output.timestamp],
+      ["level", output.level],
+      ["run", id],
+      ...messages.flatMap((value) => (plain(value) ? flatten(value) : [["message", value] as const])),
+      ...(output.cause === undefined ? [] : [["cause", output.cause] as const]),
+      ...flatten(output.spans),
+      ...flatten(output.annotations),
+    ]
+      .map(([key, value]) => `${key}=${format(value)}`)
+      .join(" ")
+  })
+}
+
+function flatten(
+  input: Record<string, unknown>,
+  prefix = "",
+  seen = new WeakSet<object>(),
+): Array<readonly [string, unknown]> {
+  if (seen.has(input)) return [[prefix, "[Circular]"]]
+  seen.add(input)
+  const entries = Object.entries(input)
+  if (entries.length === 0 && prefix) return [[prefix, input]]
+  return entries.flatMap(([key, value]) => {
+    const path = prefix ? `${prefix}.${key}` : key
+    return plain(value) ? flatten(value, path, seen) : [[path, value] as const]
+  })
+}
+
+function plain(input: unknown): input is Record<string, unknown> {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false
+  const prototype = Object.getPrototypeOf(input)
+  return prototype === Object.prototype || prototype === null
+}
+
+function format(input: unknown) {
+  const value = typeof input === "string" ? input : Formatter.format(input)
+  return /^[^\s="\\]+$/.test(value) ? value : JSON.stringify(value)
+}
+
+export function file(local = InstallationLocal, channel = InstallationChannel) {
+  if (!local) return path.join(Global.Path.log, "opencode.log")
+  return path.join(Global.Path.log, `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "-")}.log`)
+}
+
+export function fileLogger(target = file(), id: string = runID) {
+  // Do not set batchWindow to 0; it causes high idle CPU usage.
+  return Logger.toFile(formatter(id), target, { flag: "a" })
+}
+
+const stderrLogger = Logger.make((options) => process.stderr.write(formatter().log(options) + "\n"))
+
+export function minimumLogLevel() {
+  const value = process.env.OPENCODE_LOG_LEVEL?.toUpperCase()
+  const levels = {
+    DEBUG: "Debug",
+    INFO: "Info",
+    WARN: "Warn",
+    ERROR: "Error",
+  } as const satisfies Record<string, LogLevel.LogLevel>
+  return value && value in levels ? levels[value as keyof typeof levels] : levels.INFO
+}
+
+export function loggers() {
+  return process.env.OPENCODE_PRINT_LOGS === "1" ? [fileLogger(), stderrLogger] : [fileLogger()]
+}
+
+export * as Logging from "./logging"

packages/util/src/observability/otlp.ts

@@ -0,0 +1,90 @@
+import { Layer } from "effect"
+import { OtlpLogger } from "effect/unstable/observability"
+import { InstallationChannel, InstallationVersion } from "../installation/version"
+import { runID } from "./shared"
+
+export interface Options {
+  readonly endpoint?: string
+  readonly headers?: string
+  readonly client?: string
+}
+
+function parseHeaders(value?: string) {
+  return value
+    ? value.split(",").reduce(
+      (acc, entry) => {
+        const [key, ...value] = entry.split("=")
+        acc[key] = value.join("=")
+        return acc
+      },
+      {} as Record<string, string>,
+    )
+    : undefined
+}
+
+function resourceAttributes() {
+  const value = process.env.OTEL_RESOURCE_ATTRIBUTES
+  if (!value) return {}
+  try {
+    return Object.fromEntries(
+      value.split(",").map((entry) => {
+        const index = entry.indexOf("=")
+        if (index < 1) throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry")
+        return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))]
+      }),
+    )
+  } catch {
+    return {}
+  }
+}
+
+export function resource(client = "cli"): { serviceName: string; serviceVersion: string; attributes: Record<string, string> } {
+  return {
+    serviceName: "opencode",
+    serviceVersion: InstallationVersion,
+    attributes: {
+      ...resourceAttributes(),
+      "deployment.environment.name": InstallationChannel,
+      "opencode.client": client,
+      "opencode.run": runID,
+      "service.instance.id": runID,
+    },
+  }
+}
+
+export function loggers(options?: Options) {
+  if (!options?.endpoint) return []
+  return [
+    OtlpLogger.make({
+      url: `${options.endpoint}/v1/logs`,
+      resource: resource(options.client),
+      headers: parseHeaders(options.headers),
+    }),
+  ]
+}
+
+export async function tracingLayer(options?: Options) {
+  if (!options?.endpoint) return Layer.empty
+  const NodeSdk = await import("@effect/opentelemetry/NodeSdk")
+  const OTLP = await import("@opentelemetry/exporter-trace-otlp-http")
+  const SdkBase = await import("@opentelemetry/sdk-trace-base")
+  const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks")
+  const { context } = await import("@opentelemetry/api")
+
+  // The Effect Node SDK does not register a global context manager, but the AI SDK uses it to parent spans.
+  const manager = new AsyncLocalStorageContextManager()
+  manager.enable()
+  context.setGlobalContextManager(manager)
+
+  return NodeSdk.layer(() => ({
+    resource: resource(options.client),
+    spanProcessor: new SdkBase.BatchSpanProcessor(
+      new OTLP.OTLPTraceExporter({
+        url: `${options.endpoint}/v1/traces`,
+        headers: parseHeaders(options.headers),
+      }),
+    ),
+  }))
+}
+
+export * as Otlp from "./otlp"

packages/util/src/observability/shared.ts

@@ -0,0 +1 @@
+export const runID = crypto.randomUUID().slice(0, 8)