---
title: "evlog vs Consola: reporters and request context"
description: "Keep Consola for terminal interaction or custom reporters, and evaluate evlog when your application needs accumulated request events."
canonical_url: "https://www.evlog.dev/compare/consola"
---
# evlog vs Consola: reporters and request context

> Keep Consola for terminal interaction or custom reporters, and evaluate evlog when your application needs accumulated request events.

A Nuxt application can need both readable terminal messages and request events that reach a logging backend. Consola and evlog address those needs with different APIs. Start with where the output goes and who maintains the delivery code.

## At a glance

<table>
<thead>
  <tr>
    <th>
      
    </th>
    
    <th>
      Consola
    </th>
    
    <th>
      evlog
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Primary job
    </td>
    
    <td>
      Readable console output for Node.js, browsers and CLIs, and the logger behind Nuxt Kit's <code>
        useLogger
      </code>
    </td>
    
    <td>
      Structured logs and request events delivered to a logging backend
    </td>
  </tr>
  
  <tr>
    <td>
      Output
    </td>
    
    <td>
      Fancy reporter by default, basic reporter in CI and tests, browser reporter; <code>
        consola/basic
      </code>
      
       and <code>
        consola/browser
      </code>
      
       builds are smaller
    </td>
    
    <td>
      Pretty output in development, JSON events in production
    </td>
  </tr>
  
  <tr>
    <td>
      Extension point
    </td>
    
    <td>
      Reporters implementing <code>
        log(logObject)
      </code>
    </td>
    
    <td>
      Plugins, enrichers and drain adapters
    </td>
  </tr>
  
  <tr>
    <td>
      Context
    </td>
    
    <td>
      <code>
        withTag()
      </code>
      
       and <code>
        withDefaults()
      </code>
      
       scope records
    </td>
    
    <td>
      <code>
        set()
      </code>
      
       accumulates fields on an operation logger until <code>
        emit()
      </code>
    </td>
  </tr>
  
  <tr>
    <td>
      CLI helpers
    </td>
    
    <td>
      <code>
        prompt()
      </code>
      
       (powered by clack), <code>
        wrapConsole()
      </code>
      
       / <code>
        wrapStd()
      </code>
      
      , pause/resume, throttling of repeated logs
    </td>
    
    <td>
      None. Keep Consola for terminal interaction
    </td>
  </tr>
  
  <tr>
    <td>
      Levels
    </td>
    
    <td>
      Numeric levels (default <code>
        3
      </code>
      
      ), configurable with the <code>
        level
      </code>
      
       option or <code>
        CONSOLA_LEVEL
      </code>
    </td>
    
    <td>
      Fixed severities, with sampling for wide events
    </td>
  </tr>
</tbody>
</table>

Sources: the [Consola README](https://github.com/unjs/consola#readme) and the [Nuxt Kit logging docs](https://nuxt.com/docs/api/kit/logging).

## Keep the reporter behavior you rely on

Consola reporters receive log objects and control rendering or delivery. A custom reporter can serialize JSON and forward records, so structured output is possible even though a JSON reporter is not included by default. Consola also provides tags, console wrapping, and prompt helpers. Paused logs are queued, and repeated messages can be throttled. See the [Consola documentation](https://github.com/unjs/consola).

Those behaviors can suit a CLI or a production application. Replacing them requires more than changing an import.

## Compare the application work

<table>
<thead>
  <tr>
    <th>
      Need
    </th>
    
    <th>
      evlog approach
    </th>
    
    <th>
      Migration question
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      Context across a request
    </td>
    
    <td>
      <code>
        set()
      </code>
      
       accumulates fields on an operation logger
    </td>
    
    <td>
      Which layers add fields, and who finishes the event?
    </td>
  </tr>
  
  <tr>
    <td>
      Output to a backend
    </td>
    
    <td>
      Drain adapters and pipeline configuration
    </td>
    
    <td>
      Does an adapter preserve the protocol your reporter currently implements?
    </td>
  </tr>
  
  <tr>
    <td>
      Individual messages
    </td>
    
    <td>
      Global structured logging API
    </td>
    
    <td>
      Which call signatures and fields need changing?
    </td>
  </tr>
  
  <tr>
    <td>
      Terminal interaction
    </td>
    
    <td>
      Logging output
    </td>
    
    <td>
      Should prompts and other CLI interaction remain with Consola?
    </td>
  </tr>
</tbody>
</table>

Consola tags scope records. An evlog operation logger accumulates context until emission. These are different contracts, so map tags to an application field only if that preserves how you query or display them.

## Adopt request events where they help

In an application, keep terminal interaction separate from request instrumentation. Choose the evlog framework integration for handlers and use `useLogger()` in the layers that contribute fields. Avoid also capturing those emitted records through a custom reporter that forwards to the same destination, unless duplicate ingestion is intentional.

For a CLI, the [Standalone TypeScript guide](https://www.evlog.dev/integrate/frameworks/standalone) covers explicit initialization and pending delivery. For handlers, [Wide Events](https://www.evlog.dev/learn/wide-events) explains when to accumulate and emit. Check a [drain adapter](https://www.evlog.dev/integrate/adapters/overview) before replacing a custom delivery reporter.

## FAQ

**Nuxt already uses Consola. Do I need evlog in a Nuxt app?**
Nuxt Kit's `useLogger` is a Consola instance meant for module and build output. Add the [evlog Nuxt module](https://www.evlog.dev/integrate/frameworks/nuxt) when you want one structured event per server request delivered to a backend. The two can coexist.

**Can Consola emit JSON?**
Yes, through a custom reporter. Consola doesn't ship a JSON reporter (its [custom reporters section](https://github.com/unjs/consola#custom-reporters) shows how to write one), so delivery, batching and retries stay in your code.

Keep Consola when its reporters and terminal workflow meet your needs. Add or adopt evlog when its request context, structured errors, and drain pipeline remove code you would otherwise maintain. Consult the [logger overview](https://www.evlog.dev/reference/vs-other-loggers) for other configuration models.

---

- [Logger overview](https://www.evlog.dev/reference/vs-other-loggers)


## Sitemap

See the full [sitemap](https://www.evlog.dev/sitemap.md) for all pages.