PlatformLogger

Effect’s logging system generally writes messages to the console by default. However, you might prefer to store logs in a file for easier debugging or archiving. The Logger.toFile function creates a logger that sends log messages to a file on disk.

toFile

Creates a new logger from an existing string-based logger, writing its output to the specified file.

If you include a batchWindow duration when calling toFile, logs are batched for that period before being written. This can reduce overhead if your application produces many log entries. Without a batchWindow, logs are written as they arrive.

Note that toFile returns an Effect that may fail with a PlatformError if the file cannot be opened or written to. Be sure to handle this possibility if you need to react to file I/O issues.

Example (Directing Logs to a File)

This logger requires a FileSystem implementation to open and write to the file. For Node.js, you can use NodeFileSystem.layer.

1
import { NodeFileSystem } from "@effect/platform-node"
2
import { Effect, FileSystem, Layer, Logger } from "effect"
3

4
// Create a string-based logger (formatLogFmt in this case)
5
const myStringLogger = Logger.formatLogFmt
6

7
// Apply toFile to write logs to "/tmp/log.txt"
8
const fileLogger = myStringLogger.pipe(Logger.toFile("/tmp/log.txt"))
9

10
// Replace the default logger, providing NodeFileSystem
11
// to access the file system
12
const LoggerLive = Logger.layer([fileLogger]).pipe(
13
  Layer.provide(NodeFileSystem.layer),
14
)
15

16
const program = Effect.log("Hello")
17

18
// Run the program, writing logs to /tmp/log.txt
19
await Effect.runPromise(program.pipe(Effect.provide(LoggerLive)))
20
/*
21
Logs will be written to "/tmp/log.txt" in the logfmt format,
22
and won't appear on the console.
23
*/
24

25
// Read back the file to verify the log entry was written
26
// (the timestamp is omitted from the assertion since it varies)
27
const content = await Effect.runPromise(
28
  Effect.gen(function* () {
29
    const fs = yield* FileSystem.FileSystem
30
    return yield* fs.readFileString("/tmp/log.txt")
31
  }).pipe(Effect.provide(NodeFileSystem.layer)),
32
)
33

34
content.includes("level=Info") // => true
35
content.includes("message=Hello") // => true

In the following example, logs are written to both the console and a file. The console uses the pretty logger, while the file uses the logfmt format.

Example (Directing Logs to Both a File and the Console)

1
import { NodeFileSystem } from "@effect/platform-node"
2
import { Effect, FileSystem, Layer, Logger } from "effect"
3

4
const fileLogger = Logger.formatLogFmt.pipe(Logger.toFile("/tmp/log.txt"))
5

6
// Combine the pretty logger for console output with the file logger
7
const LoggerLive = Logger.layer([Logger.consolePretty(), fileLogger]).pipe(
8
  Layer.provide(NodeFileSystem.layer),
9
)
10

11
const program = Effect.log("Hello")
12

13
// Run the program, writing logs to both the console (pretty format)
14
// and "/tmp/log.txt" (logfmt)
15
await Effect.runPromise(program.pipe(Effect.provide(LoggerLive)))
16

17
// The console output includes ANSI styling and a wall-clock timestamp,
18
// so only the file (logfmt) output is asserted here
19
const content = await Effect.runPromise(
20
  Effect.gen(function* () {
21
    const fs = yield* FileSystem.FileSystem
22
    return yield* fs.readFileString("/tmp/log.txt")
23
  }).pipe(Effect.provide(NodeFileSystem.layer)),
24
)
25

26
content.includes("message=Hello") // => true