refactor(core): replace legacy logger with Effect logging (anomalyco#31310)

Author: thdxr

packages/core/src/effect/logger.ts

@@ -1,6 +1,6 @@
 import { Layer, type Context, ManagedRuntime, type Effect } from "effect"
 import { memoMap } from "./memo-map"
-import { Observability } from "./observability"
+import { Observability } from "../observability"
 
 export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
   let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined

packages/core/src/effect/observability.ts

@@ -410,9 +410,7 @@ export const layerWith = (options?: LayerOptions) =>
           Effect.catchCauseIf(
             (cause) => !Cause.hasInterrupts(cause),
             (cause) =>
-              Effect.logError("Event observer failed").pipe(
-                Effect.annotateLogs({ eventID: event.id, eventType: event.type, kind, cause }),
-              ),
+              Effect.logError("Event observer failed", { eventID: event.id, eventType: event.type, kind, cause }),
           ),
         )
 

packages/core/src/effect/runtime.ts

@@ -10,11 +10,8 @@ import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner
 import { CrossSpawnSpawner } from "../cross-spawn-spawner"
 import { Global } from "../global"
 import { NonNegativeInt } from "../schema"
-import * as Log from "../util/log"
-import { sanitizedProcessEnv } from "../util/opencode-process"
 import { which } from "../util/which"
 
-const log = Log.create({ service: "ripgrep" })
 const VERSION = "15.1.0"
 const PLATFORM = {
   "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
@@ -146,7 +143,9 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Ri
 export const use = serviceUse(Service)
 
 function env() {
-  const env = sanitizedProcessEnv()
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+  )
   delete env.RIPGREP_CONFIG_PATH
   return env
 }
@@ -307,7 +306,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | ChildProcessSpa
           const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`
           const archive = path.join(Global.Path.bin, filename)
 
-          log.info("downloading ripgrep", { url })
+          yield* Effect.logInfo("downloading ripgrep", { url })
           yield* fs.ensureDir(Global.Path.bin).pipe(Effect.orDie)
 
           const bytes = yield* HttpClientRequest.get(url).pipe(
@@ -418,7 +417,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | ChildProcessSpa
       })
 
       const tree: Interface["tree"] = Effect.fn("Ripgrep.tree")(function* (input: TreeInput) {
-        log.info("tree", input)
+        yield* Effect.logInfo("tree", input)
         const list = Array.from(yield* files({ cwd: input.cwd, signal: input.signal }).pipe(Stream.runCollect))
 
         interface Node {

packages/core/src/event.ts

@@ -4,13 +4,11 @@ import type { PlatformError } from "effect/PlatformError"
 import { FSUtil } from "../fs-util"
 import { Glob } from "../util/glob"
 import { Global } from "../global"
-import * as Log from "../util/log"
 import { serviceUse } from "../effect/service-use"
 import { makeRuntime } from "../effect/runtime"
 import { Fff } from "#fff"
 import { Ripgrep } from "./ripgrep"
 
-const log = Log.create({ service: "file.search" })
 const root = path.join(Global.Path.cache, "fff")
 
 export type Item = Ripgrep.Item
@@ -220,12 +218,14 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
         if (!scanned.ok || !scanned.value) {
           yield* fffSync("destroy picker", () => pick.destroy()).pipe(Effect.ignore)
           state.pick.delete(dir)
-          log.warn("fff scan not ready", { dir })
+          yield* Effect.logWarning("fff scan not ready", { dir })
           return yield* Effect.fail(new Error(scanned.ok ? "fff scan timed out" : scanned.error))
         }
 
         const git = yield* fffSync("refresh git status", () => pick.refreshGitStatus())
-        if (!git.ok) log.warn("fff git refresh failed", { dir, error: git.error })
+        if (!git.ok) {
+          yield* Effect.logWarning("fff git refresh failed", { dir, error: git.error })
+        }
       })
 
     // Create (or return) the picker for a directory. Creation is synchronous
@@ -244,10 +244,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
       if (pending) return yield* Deferred.await(pending)
 
       const available = yield* fffSync("check availability", () => Fff.available()).pipe(
-        Effect.catch((error) => {
-          log.warn("fff availability check failed", { error })
-          return Effect.succeed(false)
-        }),
+        Effect.catch((error) => Effect.logWarning("fff availability check failed", { error }).pipe(Effect.as(false))),
       )
       if (!available) return undefined
 
@@ -272,7 +269,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
           }),
         )
         if (!made.ok) {
-          log.warn("fff init failed", { dir, error: made.error })
+          yield* Effect.logWarning("fff init failed", { dir, error: made.error })
           const err = new Error(made.error)
           yield* Deferred.fail(gate, err)
           return yield* Effect.fail(err)
@@ -355,14 +352,15 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
           pageSize: limit,
         }),
       ).pipe(
-        Effect.catch((error) => {
-          log.warn(`fff ${kind} search failed`, { dir, query, error })
-          return Effect.succeed<Fff.Result<string[]> | undefined>(undefined)
-        }),
+        Effect.catch((error) =>
+          Effect.logWarning(`fff ${kind} search failed`, { dir, query, error }).pipe(
+            Effect.as<Fff.Result<string[]> | undefined>(undefined),
+          ),
+        ),
       )
       if (!fffResult) return undefined
       if (!fffResult.ok) {
-        log.warn(`fff ${kind} search failed`, { dir, query, error: fffResult.error })
+        yield* Effect.logWarning(`fff ${kind} search failed`, { dir, query, error: fffResult.error })
         return undefined
       }
 
@@ -393,14 +391,15 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
           timeBudgetMs: 1_500,
         }),
       ).pipe(
-        Effect.catch((error) => {
-          log.warn("fff grep failed", { dir, pattern: input.pattern, error })
-          return Effect.succeed<Fff.Result<Fff.Grep> | undefined>(undefined)
-        }),
+        Effect.catch((error) =>
+          Effect.logWarning("fff grep failed", { dir, pattern: input.pattern, error }).pipe(
+            Effect.as<Fff.Result<Fff.Grep> | undefined>(undefined),
+          ),
+        ),
       )
       if (!fffGrep) return yield* rip(input)
       if (!fffGrep.ok) {
-        log.warn("fff grep failed", { dir, pattern: input.pattern, error: fffGrep.error })
+        yield* Effect.logWarning("fff grep failed", { dir, pattern: input.pattern, error: fffGrep.error })
         return yield* rip(input)
       }
 
@@ -432,10 +431,11 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
             pageSize: limit,
           }),
         ).pipe(
-          Effect.catch((error) => {
-            log.warn("fff glob failed", { dir, pattern: input.pattern, error })
-            return Effect.succeed<Fff.Result<Fff.Search> | undefined>(undefined)
-          }),
+          Effect.catch((error) =>
+            Effect.logWarning("fff glob failed", { dir, pattern: input.pattern, error }).pipe(
+              Effect.as<Fff.Result<Fff.Search> | undefined>(undefined),
+            ),
+          ),
         )
 
         if (fffGlob?.ok) {
@@ -453,7 +453,7 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
             truncated: fffGlob.value.totalMatched > rows.length,
           }
         } else if (fffGlob) {
-          log.warn("fff glob failed", { dir, pattern: input.pattern, error: fffGlob.error })
+          yield* Effect.logWarning("fff glob failed", { dir, pattern: input.pattern, error: fffGlob.error })
           // fall through to the fallback
         }
       }
@@ -500,13 +500,16 @@ export const layer: Layer.Layer<Service, never, FSUtil.Service | Ripgrep.Service
       if (!entry) return
 
       const out = yield* fffSync("track query", () => entry.pick.trackQuery(row.text, file)).pipe(
-        Effect.catch((error) => {
-          log.warn("fff track query failed", { dir: row.dir, query: row.text, file, error })
-          return Effect.succeed<Fff.Result<boolean> | undefined>(undefined)
-        }),
+        Effect.catch((error) =>
+          Effect.logWarning("fff track query failed", { dir: row.dir, query: row.text, file, error }).pipe(
+            Effect.as<Fff.Result<boolean> | undefined>(undefined),
+          ),
+        ),
       )
       if (!out) return
-      if (!out.ok) log.warn("fff track query failed", { dir: row.dir, query: row.text, file, error: out.error })
+      if (!out.ok) {
+        yield* Effect.logWarning("fff track query failed", { dir: row.dir, query: row.text, file, error: out.error })
+      }
     })
 
     return Service.of({ files, tree, search, file, glob, open, warm, release })