Stop grepping
through chaos.

Wide events and structured errors for TypeScript. One log per request, full context, errors that explain why and how to fix.

Fix your logs GitHub

FrontendNuxt / Next.js

API ServerNitro / Express

request logs

live

▍

WorkersBackground jobs

DatabaseQueries & events

? What failed?

? Why?

? Which users?

? How to fix?

Simple API

Set context.
Get answers.

Accumulate context with log.set, throw structured errors with why and fix. One wide event captures everything, whether the request succeeds or fails.

Wide events Root cause Fix suggestion

Quick start guide

checkout.post.ts

export default defineEventHandler(async (event) => {
  const log = useLogger(event)

  log.set({ user: { id: user.id, plan: user.plan } })
  log.set({ cart: { items: 3, total: 9999 } })

  if (!charge.success) {
    throw createError({
      status: 402,
      why: 'Card declined by issuer',
      fix: 'Try a different card',
    })
  }

  return { orderId: charge.id }
})

output

INFOPOST/api/checkout(234ms)

user: { id: 1842, plan: "pro" }

cart: { items: 3, total: 9999 }

status: 200

requestId: "req_8f2k..."

✓ One log with full context

ERRORPOST/api/checkout402

message: "Payment failed"

why: "Card declined by issuer"

fix: "Try a different card"

user: { id: 1842, plan: "pro" }

✓ Actionable error with context

Agent Ready

Built for agents.

Structured fields, machine-readable context, and actionable metadata that give AI agents everything they need to diagnose and resolve issues on their own. Enable the file system drain to write NDJSON logs locally and let agents read them directly.

Structured context Machine-parseable Local NDJSON files

Agent skills setup

outputERROR

ERRORPOST/api/payment402

message: "Payment processing failed"

why: "Card issuer declined: insufficient funds"

fix: "Retry with a different payment method"

user: { id: 1842, plan: "pro" }

links: ["stripe.com/docs/declines"]

AI Agent analyzing

Reading structured error context...

→

Root cause

Card declined by issuer — insufficient funds

→

User impact

Pro plan user (#1842) blocked on payment

→

Suggested fix

Prompt for alternate payment method

→

Documentation

stripe.com/docs/declines/codes

✓ Auto-created issue PAY-4521

Drain Pipeline

Send everywhere.

Batched writes, automatic retries with backoff, and fan-out to multiple destinations. Your logs flow through a pipeline that never blocks your response.

Batching Retry & backoff Fan-out

Explore adapters

Non-blocking

Pipeline runs in the background. Your response ships immediately.

Guaranteed delivery

Exponential backoff with jitter ensures logs reach every destination.

Bring your own drain

Write a simple function to send logs anywhere.

evlog-drain.ts

import { createDrainPipeline } from 'evlog/pipeline'
import { createAxiomDrain } from 'evlog/axiom'
import { createSentryDrain } from 'evlog/sentry'

const pipeline = createDrainPipeline({
  drains: [
    createAxiomDrain(),
    createSentryDrain(),
  ],
  batchSize: 50,
  flushInterval: 5000,
})

evlog

BATCH · RETRY · FANOUT

Axiom

OTLP

Sentry

PostHog

Better Stack

+ File System·Custom drains

Client Logs

See the full picture.

Capture browser events and drain them to your server. Automatic batching, retries, and page-aware flushing with the same pipeline from client to server.

Auto-batch sendBeacon Origin validation

Client logging guide

Automatic batching

Events are batched by size and time interval, reducing network overhead.

Page-aware delivery

Switches to sendBeacon when the page is hidden. No event left behind.

Server-side validation

Origin check, payload sanitization, and source tagging on every ingest.

browser-drain.ts

import { createBrowserLogDrain } from 'evlog/browser'

const drain = createBrowserLogDrain({
  drain: {
    endpoint: '/api/_evlog/ingest',
  },
  pipeline: {
    batch: { size: 25, intervalMs: 2000 },
    retry: { maxAttempts: 2 },
  },
})

initLogger({ drain })

BrowserEVENTS

BATCH · FLUSH

PipelineRETRY · BACKOFF

POST · BEACON

ServerVALIDATE · DRAIN

auto-flush on page visibility change

Sampling

Keep what matters.

Two-tier filtering: head sampling drops noise by level, tail sampling rescues critical events. Never miss errors, slow requests, or critical paths.

Head sampling Tail sampling Per-level rates

Sampling guide

evlog.config.ts

initLogger({
  sampling: {
    // Head: per-level rates
    rates: {
      info:  10,   // keep 10%
      warn:  50,   // keep 50%
      error: 100,  // always
    },
    // Tail: force keep if match
    keep: [
      { status: 400 },
      { duration: 1000 },
      { path: '/api/critical/**' },
    ]
  }
})

log stream

HEADTAIL

INFOGET/api/users45ms

INFOPOST/api/orders120ms

INFOGET/api/health12ms

WARNPOST/api/payment340ms

INFOGET/api/search1240ms

ERRORPOST/api/checkout450ms

INFOGET/api/feed32ms

INFOPOST/api/critical/alert55ms

5 kept·3 dropped· noise reduced without data loss

Performance

Add logging,
not overhead.

Zero dependencies, 5.1 kB gzip, ~7µs per request. Benchmarked against pino, consola, and winston — evlog wins 5 out of 6 comparisons while producing richer, more useful output.

Zero-alloc hot path CodSpeed CI Open source benchmarks

Full benchmark results

benchmark

evlog

1.0M

consola

690K1.5x slower

pino

473K2.2x slower

winston

373K2.7x slower

ops/sec · higher is better · silent mode (no I/O)

evlog

819K

consola

477K1.7x slower

pino

283K2.9x slower

winston

132K6.2x slower

ops/sec · higher is better · silent mode (no I/O)

evlog

7.6M

pino

2.4M3.2x slower

winston

1.8M4.3x slower

consola

122K62.6x slower

ops/sec · higher is better · silent mode (no I/O)

0deps/5.1 kBgzip/12frameworks/tree-shakeable

why it's fast

1 event, not N log lines

Accumulate context, emit once. 75% less data downstream.

In-place mutations

No object spreads, no copies. Direct recursive merge.

Lazy allocation

Timestamps, sampling context — created only when needed.

No serialization until drain

Plain objects throughout. JSON.stringify runs once at the end.

Zero dependencies

No transitive deps. Nothing to audit, nothing to break.

Total overhead per request

create + 3x set + emit + sampling + enrichers

~7µs

0.007ms

Frameworks

Your stack. Covered.

Native integrations for every major framework. One import, zero config, same API everywhere. The Vite plugin adds auto-init, debug stripping, and source location to any Vite-based stack.

Framework integrations

Vite

server/api/checkout.post.ts

export default defineEventHandler(async (event) => {
  const log = useLogger(event)
  const { cartId } = await readBody(event)

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  if (!charge.success) {
    throw createError({
      status: 402,
      message: 'Payment failed',
      why: charge.decline_reason,
      fix: 'Try a different payment method',
    })
  }

  return { orderId: charge.id }
})

app/api/checkout/route.ts

import { withEvlog, useLogger } from '@/lib/evlog'

export const POST = withEvlog(async (req) => {
  const log = useLogger()
  const { cartId } = await req.json()

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  if (!charge.success) {
    throw createError({
      status: 402,
      message: 'Payment failed',
      why: charge.decline_reason,
      fix: 'Try a different payment method',
    })
  }

  return Response.json({ orderId: charge.id })
})

src/routes/api/checkout/+server.ts

import { json } from '@sveltejs/kit'
import { createError } from 'evlog'
import { useLogger } from 'evlog/sveltekit'
import type { RequestHandler } from './$types'

export const POST: RequestHandler = async ({ request }) => {
  const log = useLogger()
  const { cartId } = await request.json()

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  if (!charge.success) {
    throw createError({
      status: 402,
      message: 'Payment failed',
      why: charge.decline_reason,
      fix: 'Try a different payment method',
    })
  }

  return json({ orderId: charge.id })
}

routes/api/checkout.post.ts

import { defineHandler } from 'nitro/h3'
import { useLogger, createError } from 'evlog/nitro/v3'

export default defineHandler(async (event) => {
  const log = useLogger(event)
  const { cartId } = await readBody(event)

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  if (!charge.success) {
    throw createError({
      status: 402,
      message: 'Payment failed',
      why: charge.decline_reason,
      fix: 'Try a different payment method',
    })
  }

  return { orderId: charge.id }
})

src/routes/api/checkout.ts

import { createFileRoute } from '@tanstack/react-router'
import { useRequest } from 'nitro/context'
import { createError } from 'evlog'
import type { RequestLogger } from 'evlog'

export const Route = createFileRoute('/api/checkout')({
  server: {
    handlers: {
      POST: async ({ request }) => {
        const req = useRequest()
        const log = req.context.log as RequestLogger
        const { cartId } = await request.json()

        const cart = await db.findCart(cartId)
        log.set({ cart: { items: cart.items.length, total: cart.total } })

        const charge = await stripe.charge(cart.total)
        log.set({ stripe: { chargeId: charge.id } })

        if (!charge.success) {
          throw createError({
            status: 402,
            message: 'Payment failed',
            why: charge.decline_reason,
            fix: 'Try a different payment method',
          })
        }

        return Response.json({ orderId: charge.id })
      },
    },
  },
})

app.module.ts

import { Module } from '@nestjs/common'
import { EvlogModule } from 'evlog/nestjs'

@Module({
  imports: [
    EvlogModule.forRoot({
      drain: createAxiomDrain(),
    }),
  ],
})
export class AppModule {}

// In any service or controller:
const log = useLogger()
log.set({ cart: { items: cart.items.length, total: cart.total } })

src/index.ts

import { evlog, useLogger } from 'evlog/express'

const app = express()
app.use(evlog({ drain: createAxiomDrain() }))

app.post('/checkout', async (req, res) => {
  const log = useLogger()
  const { cartId } = req.body

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  res.json({ orderId: charge.id })
})

src/index.ts

import { evlog, type EvlogVariables } from 'evlog/hono'

const app = new Hono<EvlogVariables>()
app.use(evlog({ drain: createAxiomDrain() }))

app.post('/checkout', async (c) => {
  const log = c.get('log')
  const { cartId } = await c.req.json()

  const cart = await db.findCart(cartId)
  log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  log.set({ stripe: { chargeId: charge.id } })

  return c.json({ orderId: charge.id })
})

src/index.ts

import { evlog, useLogger } from 'evlog/fastify'

const app = Fastify({ logger: false })
await app.register(evlog, { drain: createAxiomDrain() })

app.post('/checkout', async (request) => {
  const { cartId } = request.body

  const cart = await db.findCart(cartId)
  request.log.set({ cart: { items: cart.items.length, total: cart.total } })

  const charge = await stripe.charge(cart.total)
  request.log.set({ stripe: { chargeId: charge.id } })

  return { orderId: charge.id }
})

src/index.ts

import { evlog, useLogger } from 'evlog/elysia'

const app = new Elysia()
  .use(evlog({ drain: createAxiomDrain() }))
  .post('/checkout', async ({ log }) => {
    const { cartId } = await req.body

    const cart = await db.findCart(cartId)
    log.set({ cart: { items: cart.items.length, total: cart.total } })

    const charge = await stripe.charge(cart.total)
    log.set({ stripe: { chargeId: charge.id } })

    return { orderId: charge.id }
  })

src/worker.ts

import { initLogger, createRequestLogger } from 'evlog'

initLogger({ service: 'checkout-worker' })

export default {
  async fetch(request, env) {
    const log = createRequestLogger({
      method: request.method,
      path: new URL(request.url).pathname,
    })

    const { cartId } = await request.json()
    const cart = await env.DB.findCart(cartId)
    log.set({ cart: { items: cart.items.length, total: cart.total } })

    log.emit()
    return Response.json({ orderId: cart.id })
  },
}

scripts/migrate-users.ts

import { initLogger, createRequestLogger } from 'evlog'

initLogger({ service: 'migrate' })

const log = createRequestLogger({ task: 'user-migration' })

const users = await db.query('SELECT * FROM legacy_users')
log.set({ found: users.length })

for (const user of users) {
  await newDb.upsert({ id: user.id, email: user.email, plan: user.plan })
}

log.set({ migrated: users.length, status: 'complete' })
log.emit()

Better logging
by tonight.

Wide events, structured errors, dead simple setup. Set up evlog in 10 minutes. Your future self will thank you.

Get Started View on GitHub

Stop grepping through chaos.

Set context. Get answers.

Built for agents.

Send everywhere.

See the full picture.

Keep what matters.

Add logging, not overhead.

Your stack. Covered.

Better loggingby tonight.

Stop grepping
through chaos.

Set context.
Get answers.

Add logging,
not overhead.

Better logging
by tonight.