Performance Tuning

1log.info("message")
2  ↓
31. Level check (< 1μs)
42. Format args (1-5μs)
53. Build entry (2-5μs)
64. Sanitize (0-10μs)
75. Transport.log() (varies)

1import { createLogger } from 'vestig'
2 
3// Development: trace for debugging
4const devLogger = createLogger({ level: 'trace' })
5 
6// Production: info or above
7const prodLogger = createLogger({
8  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug'
9})

1// This is fast when level is 'info' or above
2logger.debug('Expensive calculation result:', expensiveFunction())
3 
4// The function is STILL called! Use guards for expensive operations:
5if (logger.getLevel() === 'debug' || logger.getLevel() === 'trace') {
6  logger.debug('Result:', expensiveFunction())
7}

1import { createLogger } from 'vestig'
2 
3const logger = createLogger({ level: 'info' })
4 
5// Temporarily enable debug for troubleshooting
6function enableDebug(durationMs = 60000) {
7  const original = logger.getLevel()
8  logger.setLevel('debug')
9 
10  setTimeout(() => {
11    logger.setLevel(original)
12    logger.info('Debug logging disabled')
13  }, durationMs)
14}
15 
16// Expose via API or signal
17process.on('SIGUSR1', () => enableDebug(60000))

1import { createLogger } from 'vestig'
2 
3const logger = createLogger({
4  sampling: {
5    enabled: true,
6    sampler: 0.1, // Log 10% of entries
7  }
8})
9 
10// 10 logs → 1 stored (statistically)
11for (let i = 0; i < 100; i++) {
12  logger.info(`Request ${i}`)  // ~10 will be logged
13}

1const logger = createLogger({
2  sampling: {
3    enabled: true,
4    sampler: { maxPerSecond: 100 }
5  }
6})
7 
8// Even under 10k req/sec, max 100 logs/sec

1const logger = createLogger({
2  sampling: {
3    enabled: true,
4    sampler: {
5      default: 0.1,  // 10% default
6      namespaces: {
7        'auth.*': 1.0,        // 100% for auth (security)
8        'db.*': 0.01,         // 1% for noisy DB logs
9        'http.*': { maxPerSecond: 50 }
10      }
11    }
12  }
13})
14 
15const authLogger = logger.child('auth')    // 100%
16const dbLogger = logger.child('db')        // 1%
17const httpLogger = logger.child('http')    // Rate limited

1import { HTTPTransport } from 'vestig'
2 
3// Low volume: smaller batches, faster feedback
4new HTTPTransport({
5  batchSize: 25,
6  flushInterval: 1000,  // 1 second
7})
8 
9// High volume: larger batches, fewer requests
10new HTTPTransport({
11  batchSize: 500,
12  flushInterval: 5000,  // 5 seconds
13})

1// Target: < 1MB per batch, < 100 requests/minute
2 
3const avgLogSize = 500  // bytes
4const logsPerSecond = 1000
5const flushInterval = 5  // seconds
6 
7const batchSize = logsPerSecond * flushInterval
8// 1000 * 5 = 5000 logs per batch
9// 5000 * 500 = 2.5MB - TOO BIG!
10 
11// Adjust down
12const optimalBatchSize = Math.min(
13  1000,  // Max batch size
14  Math.floor(1_000_000 / avgLogSize)  // ~2000 to stay under 1MB
15)

1// Real-time visibility (development)
2new HTTPTransport({
3  flushInterval: 500,   // 500ms
4  batchSize: 50,
5})
6 
7// Balanced (staging)
8new HTTPTransport({
9  flushInterval: 2000,  // 2s
10  batchSize: 200,
11})
12 
13// High efficiency (production)
14new HTTPTransport({
15  flushInterval: 10000, // 10s
16  batchSize: 1000,
17})

1const logger = createLogger({
2  structured: true,  // Default in production
3})
4 
5logger.info('Request handled', { duration: 45 })
6// {"level":"info","message":"Request handled","metadata":{"duration":45},...}

1const logger = createLogger({
2  structured: false,
3})
4 
5logger.info('Request handled', { duration: 45 })
6// [INFO] Request handled { duration: 45 }

1const logger = createLogger({
2  structured: process.env.NODE_ENV === 'production'
3})

1import { createLogger } from 'vestig'
2 
3// Fast: Exact field names
4const logger = createLogger({
5  sanitize: {
6    fields: ['password', 'token', 'secret']
7  }
8})
9 
10// Slower: Regex patterns
11const slowLogger = createLogger({
12  sanitize: {
13    fields: [
14      { type: 'regex', value: '.*password.*', caseSensitive: false }
15    ]
16  }
17})

1// Minimal overhead
2createLogger({ sanitize: 'minimal' })
3 
4// Standard protection
5createLogger({ sanitize: 'default' })
6 
7// Comprehensive (slight overhead)
8createLogger({ sanitize: 'gdpr' })
9createLogger({ sanitize: 'pci-dss' })

1// Internal service with no sensitive data
2const internalLogger = createLogger({
3  sanitize: false  // Skip sanitization entirely
4})

1import { ConsoleTransport } from 'vestig'
2 
3new ConsoleTransport({
4  structured: false,  // Pretty print
5  colors: true,       // ANSI colors
6})

1import { HTTPTransport } from 'vestig'
2 
3new HTTPTransport({
4  url: 'https://logs.example.com',
5  batchSize: 500,
6  flushInterval: 5000,
7  timeout: 10000,
8  maxRetries: 3,
9})

1import { FileTransport } from 'vestig'
2 
3new FileTransport({
4  path: './logs/app.log',
5  batchSize: 100,
6  maxSize: 100 * 1024 * 1024,  // 100MB
7  maxFiles: 10,
8  rotateInterval: 'daily',
9  compress: true,  // Gzip rotated files
10})

1const logger = createLogger()
2 
3// Fast local buffer
4logger.addTransport(new ConsoleTransport())
5 
6// Async remote storage
7logger.addTransport(new HTTPTransport({ url: '...' }))
8 
9// Logs go to both, batched separately

1import { createLogger, createLoggerAsync, HTTPTransport } from 'vestig'
2 
3// Immediate startup (console only)
4const logger = createLogger()
5 
6// Background: add expensive transports
7;(async () => {
8  const http = new HTTPTransport({ url: '...' })
9  await http.init?.()
10  logger.addTransport(http)
11})()
12 
13// Logs work immediately, HTTP added when ready
14logger.info('Server starting')

1import { createLogger, HTTPTransport, FileTransport, initLogger } from 'vestig'
2 
3const logger = createLogger()
4 
5// Add all transports
6logger.addTransport(new HTTPTransport({ url: '...' }))
7logger.addTransport(new FileTransport({ path: './logs/app.log' }))
8 
9// Initialize all in parallel
10await initLogger(logger)
11 
12// Now fully operational
13logger.info('All transports ready')

1import { createLogger } from 'vestig'
2 
3const logger = createLogger({ level: 'info' })
4 
5// Warm up
6for (let i = 0; i < 1000; i++) {
7  logger.info('warmup')
8}
9await logger.flush()
10 
11// Measure
12const iterations = 10000
13const start = performance.now()
14 
15for (let i = 0; i < iterations; i++) {
16  logger.info('Test message', { iteration: i })
17}
18 
19await logger.flush()
20const end = performance.now()
21 
22const totalMs = end - start
23const perLogUs = (totalMs / iterations) * 1000
24 
25console.log(`${perLogUs.toFixed(2)}μs per log`)
26console.log(`${iterations / (totalMs / 1000)} logs/second`)

1import { ConsoleTransport, HTTPTransport, FileTransport } from 'vestig'
2 
3async function benchmarkTransport(transport: Transport, name: string) {
4  const iterations = 1000
5 
6  const start = performance.now()
7  for (let i = 0; i < iterations; i++) {
8    transport.log({ level: 'info', message: 'test', timestamp: new Date().toISOString() })
9  }
10  await transport.flush?.()
11  const end = performance.now()
12 
13  console.log(`${name}: ${((end - start) / iterations * 1000).toFixed(2)}μs per log`)
14}
15 
16await benchmarkTransport(new ConsoleTransport(), 'Console')
17await benchmarkTransport(new HTTPTransport({ url: '...' }), 'HTTP')
18await benchmarkTransport(new FileTransport({ path: '/tmp/bench.log' }), 'File')

1const prodLogger = createLogger({
2  // Performance
3  level: 'info',           // No debug/trace
4  structured: true,        // Fast JSON
5  sanitize: 'default',     // Standard protection
6 
7  // Sampling
8  sampling: {
9    enabled: true,
10    sampler: {
11      default: 0.1,        // 10% sampling
12      namespaces: {
13        'error.*': 1.0,    // 100% errors
14      }
15    }
16  }
17})
18 
19// Transport tuning
20prodLogger.addTransport(new HTTPTransport({
21  url: process.env.LOG_ENDPOINT,
22  batchSize: 500,
23  flushInterval: 5000,
24  timeout: 10000,
25  maxRetries: 3,
26}))

1import { createMetricsCollector } from 'vestig'
2 
3const metrics = createMetricsCollector()
4 
5// Export to Prometheus
6app.get('/metrics', (req, res) => {
7  res.type('text/plain')
8  res.send(metrics.toPrometheus())
9})