Fiber Logger middleware output destination and format customization

Answer

Override the default console output by setting logger.Config.Output to any io.Writer. Set a JSON-like Format string with the built-in tags to get structured lines. For safe, production JSON under high traffic, do not rely on the string formatter for escaping; use a custom middleware that marshals a struct with encoding/json to the same writer.

Confirmed facts

• github.com/gofiber/fiber/v2/middleware/logger exposes a Config struct with Output io.Writer. If Output is nil the middleware falls back to its default stdout writer.
• Config.Format is a string template interpolated per request with tags such as ${time}, ${status}, ${latency}, ${method}, ${path}, ${ip}, ${error}.
• The logger writes in the request path, after c.Next() completes. A blocking or slow Output adds directly to request latency.

Likely explanation for performance and safety

Because Fiber is fasthttp-based, request handling is highly concurrent. A shared io.Writer must tolerate concurrent Write calls. The built-in formatter substitutes tag values as plain text; it does not JSON-escape dynamic values. Paths, queries or errors containing quotes, backslashes, newlines or invalid UTF-8 can produce invalid JSON lines. ANSI color codes can also break machine parsers.

Steps for this case

1. Choose a writer for the destination.

type asyncWriter struct{ ch chan []byte }
func (a *asyncWriter) Write(p []byte) (n int, err error) {
    // copy to avoid referencing fasthttp buffers
    b := make([]byte, len(p)); copy(b, p)
    select { case a.ch <- b: default: } 
    return len(p), nil
}

Start a single consumer goroutine that drains the channel and writes to the external system. This decouples request latency from remote I/O.

2. Wire the writer into Logger.

w := &asyncWriter{ch: make(chan []byte, 10000)}
app.Use(logger.New(logger.Config{
    Output: w,
    Format: `{"time":"${time}","status":${status},"latency":"${latency}","method":"${method}","path":"${path}","ip":"${ip}"}` + "\n",
    DisableColors: true,
}))

3. For robust JSON, prefer a custom middleware when you need guaranteed escaping.

app.Use(func(c fiber.Ctx) error {
    start := time.Now()
    err := c.Next()
    entry := map[string]any{
        "time": time.Now().Format(time.RFC3339),
        "status": c.Response().StatusCode(),
        "latency": time.Since(start).String(),
        "method": c.Method(),
        "path": c.Path(),
        "ip": c.IP(),
    }
    if err != nil { entry["error"] = err.Error() }
    b, _ := json.Marshal(entry)
    w.Write(append(b, '\n'))
    return err
})

This marshals values with proper JSON escaping and avoids the string template limitation.

Verification checks: inspect the module cache for logger.Config fields to confirm Output, Format, DisableColors and whether CustomTags is available in your version. Test with paths containing quotes and backslashes and parse output lines with encoding/json. Load test p95/p99 latency with stdout vs async writer and check for interleaved lines.

One missing diagnostic detail that changes the recommendation: the Fiber major version you are on. v2 and v3 differ in Config field names and whether CustomTags-based escaping is exposed, which determines if the built-in formatter can be used safely for JSON or a custom middleware is required.