Migration from Pino

1// Pino
2import pino from 'pino'
3 
4const logger = pino({
5  level: 'info',
6  transport: {
7    target: 'pino-pretty'
8  }
9})
10 
11// Vestig
12import { createLogger } from 'vestig'
13 
14const logger = createLogger({
15  level: 'info',
16  structured: false  // Pretty print in development
17})

1// Pino - same API!
2logger.info('User logged in')
3logger.info({ userId: '123' }, 'User logged in')
4logger.error({ err: new Error('failed') }, 'Operation failed')
5 
6// Vestig - same API!
7logger.info('User logged in')
8logger.info('User logged in', { userId: '123' })
9logger.error('Operation failed', { error: new Error('failed') })

1// Pino - child with bindings
2const childLogger = logger.child({ module: 'auth' })
3childLogger.info('Login attempt')
4// Output: { "module": "auth", "msg": "Login attempt" }
5 
6// Vestig - child with namespace
7const childLogger = logger.child('auth')
8childLogger.info('Login attempt')
9// Output: { "namespace": "auth", "message": "Login attempt" }
10 
11// Vestig - child with context (like Pino bindings)
12const childLogger = logger.child('auth', {
13  context: { module: 'auth' }
14})
15childLogger.info('Login attempt')
16// Output: { "namespace": "auth", "context": { "module": "auth" }, "message": "Login attempt" }

1// Pino
2import pino from 'pino'
3 
4const logger = pino({
5  transport: {
6    target: 'pino-pretty',
7    options: {
8      colorize: true
9    }
10  }
11})
12 
13// Vestig
14import { createLogger, ConsoleTransport } from 'vestig'
15 
16const logger = createLogger()
17// ConsoleTransport is added by default with pretty print in development

1// Pino (using pino-transport and pino/file)
2import pino from 'pino'
3import { join } from 'path'
4 
5const logger = pino({
6  transport: {
7    target: 'pino/file',
8    options: { destination: join(__dirname, 'app.log') }
9  }
10})
11 
12// Vestig
13import { createLogger, FileTransport } from 'vestig'
14 
15const logger = createLogger()
16logger.addTransport(new FileTransport({
17  path: './logs/app.log',
18  maxSize: 10 * 1024 * 1024,  // 10MB rotation
19  maxFiles: 5
20}))

1// Pino (using pino-http)
2import pino from 'pino'
3import pinoms from 'pino-multi-stream'
4 
5const streams = [
6  { stream: process.stdout },
7  { stream: someHttpStream }
8]
9const logger = pino({}, pinoms.multistream(streams))
10 
11// Vestig
12import { createLogger, ConsoleTransport, HTTPTransport } from 'vestig'
13 
14const logger = createLogger()
15// Console is added by default
16 
17logger.addTransport(new HTTPTransport({
18  url: 'https://logs.example.com',
19  batchSize: 100,
20  headers: { 'Authorization': `Bearer ${process.env.API_KEY}` }
21}))

1// Pino (using pino-multi-stream)
2import pino from 'pino'
3import pinoms from 'pino-multi-stream'
4 
5const streams = [
6  { level: 'info', stream: process.stdout },
7  { level: 'error', stream: errorFileStream },
8  { level: 'fatal', stream: alertStream }
9]
10const logger = pino({ level: 'info' }, pinoms.multistream(streams))
11 
12// Vestig - simpler built-in multi-transport
13import { createLogger, ConsoleTransport, FileTransport, HTTPTransport } from 'vestig'
14 
15const logger = createLogger({ level: 'info' })
16 
17logger.addTransport(new ConsoleTransport({ level: 'info' }))
18logger.addTransport(new FileTransport({ path: './error.log', level: 'error' }))
19logger.addTransport(new HTTPTransport({ url: '/alerts', level: 'fatal' }))

1// Pino
2import pino from 'pino'
3 
4const logger = pino({
5  serializers: {
6    req: (req) => ({
7      method: req.method,
8      url: req.url,
9      // Don't log headers
10    }),
11    err: pino.stdSerializers.err,
12    user: (user) => ({
13      id: user.id,
14      // Don't log email, password
15    })
16  }
17})

1// Vestig - automatic field sanitization
2import { createLogger } from 'vestig'
3 
4const logger = createLogger({
5  sanitize: {
6    fields: [
7      'password',
8      'token',
9      'secret',
10      'authorization',
11      { type: 'suffix', value: '_key' },
12      { type: 'regex', value: 'credit.*number' }
13    ]
14  }
15})
16 
17// Or use presets
18const logger = createLogger({
19  sanitize: 'gdpr'  // Auto-redacts PII fields
20})

1// Pino with async_hooks
2import pino from 'pino'
3import { AsyncLocalStorage } from 'async_hooks'
4 
5const als = new AsyncLocalStorage()
6 
7function getLogger() {
8  const store = als.getStore()
9  return store?.logger ?? logger
10}
11 
12app.use((req, res, next) => {
13  const requestLogger = logger.child({ requestId: req.id })
14  als.run({ logger: requestLogger }, next)
15})
16 
17// In handlers
18getLogger().info('Processing request')

1// Vestig - built-in async context
2import { withContext, getContext, createLogger } from 'vestig'
3 
4const logger = createLogger()
5 
6app.use((req, res, next) => {
7  withContext({ requestId: req.id }, () => {
8    next()
9  })
10})
11 
12// In handlers - context is automatic
13logger.info('Processing request')
14// Output includes: { "context": { "requestId": "..." } }

1// Vestig with @vestig/next
2import { getLogger } from '@vestig/next'
3 
4// Server Component - context is automatic
5export default async function Page() {
6  const log = await getLogger('my-page')
7  log.info('Rendering page')  // Includes request context
8  return <div>Hello</div>
9}
10 
11// Route Handler
12import { withVestig } from '@vestig/next'
13 
14export const GET = withVestig(async (req, { log }) => {
15  log.info('Handling request')  // Automatic context
16  return Response.json({ ok: true })
17})

1// Pino
2logger.fatal({ err }, 'Application crashed')
3 
4// Vestig - use error with fatal flag
5logger.error('Application crashed', {
6  error: err,
7  fatal: true
8})

1// Pino
2import pino from 'pino'
3 
4const logger = pino({
5  serializers: {
6    err: pino.stdSerializers.err
7  }
8})
9 
10try {
11  throw new Error('Something failed')
12} catch (err) {
13  logger.error({ err }, 'Operation failed')
14}
15 
16// Vestig - automatic serialization
17import { createLogger, serializeError } from 'vestig'
18 
19const logger = createLogger()
20 
21try {
22  throw new Error('Something failed')
23} catch (error) {
24  logger.error('Operation failed', { error })
25  // Error is automatically serialized with stack trace
26}

1// Vestig supports ES2022 error causes
2const dbError = new Error('Connection failed')
3const serviceError = new Error('User lookup failed', { cause: dbError })
4 
5logger.error('Request failed', { error: serviceError })
6// Output includes entire cause chain

1// Pino
2import pino from 'pino'
3 
4const logger = pino({
5  redact: ['password', 'user.password', '*.secret']
6})
7 
8logger.info({ user: { name: 'John', password: 'secret' } })
9// Output: { user: { name: 'John', password: '[Redacted]' } }

1// Vestig
2import { createLogger } from 'vestig'
3 
4const logger = createLogger({
5  sanitize: {
6    fields: [
7      'password',
8      { type: 'contains', value: 'secret' }
9    ]
10  }
11})
12 
13logger.info('User data', { user: { name: 'John', password: 'secret' } })
14// Output: { user: { name: 'John', password: '[REDACTED]' } }

1// Pino
2import pino from 'pino'
3import pinoHttp from 'pino-http'
4 
5const logger = pino()
6app.use(pinoHttp({ logger }))
7 
8// Vestig
9import { createLogger, withContext } from 'vestig'
10 
11const logger = createLogger()
12 
13app.use((req, res, next) => {
14  const start = Date.now()
15 
16  withContext({ requestId: req.id }, () => {
17    res.on('finish', () => {
18      logger.info('Request completed', {
19        method: req.method,
20        url: req.url,
21        status: res.statusCode,
22        duration: Date.now() - start
23      })
24    })
25    next()
26  })
27})

1// Vestig with Prisma
2import { withVestigPrisma } from '@vestig/next/db'
3 
4const prisma = withVestigPrisma(new PrismaClient(), {
5  logger,
6  slowQueryThreshold: 100
7})
8 
9// Vestig with Drizzle
10import { createVestigDrizzleLogger } from '@vestig/next/db'
11 
12const db = drizzle(client, {
13  logger: createVestigDrizzleLogger({ logger })
14})