Error Recovery Patterns

1import { HTTPTransport, HTTPTransportError } from 'vestig'
2 
3const transport = new HTTPTransport({
4  url: 'https://logs.example.com/ingest',
5  maxRetries: 3,
6  retryDelay: 1000,
7})
8 
9// Error properties help you decide how to handle failures
10try {
11  await transport.flush()
12} catch (error) {
13  if (error instanceof HTTPTransportError) {
14    if (error.isNetworkError) {
15      // No response received - network issue, DNS failure, etc.
16      console.log('Network unavailable, logs queued locally')
17    } else if (error.isTimeout) {
18      // Request timed out (408)
19      console.log('Request timed out, will retry')
20    } else if (error.isServerError) {
21      // 5xx - server issue, retry makes sense
22      console.log('Server error, will retry')
23    } else if (error.isClientError) {
24      // 4xx - our fault, don't retry (bad config, auth, etc.)
25      console.log('Client error, check configuration')
26    }
27 
28    // Access original error for debugging
29    if (error.cause) {
30      console.log('Original error:', error.cause.message)
31    }
32  }
33}

1import { HTTPTransport } from 'vestig'
2 
3const transport = new HTTPTransport({
4  url: 'https://logs.example.com',
5  maxRetries: 5,       // Number of retry attempts
6  retryDelay: 1000,    // Base delay in ms (doubles each retry)
7  timeout: 30000,      // Request timeout
8})

1// Retry delays: 1s, 2s, 4s, 8s, 16s (with jitter)
2// This prevents thundering herd when multiple clients retry

1import { BatchTransport, type LogEntry, type Transport } from 'vestig'
2 
3class RetryingTransport implements Transport {
4  readonly name = 'retrying'
5  readonly config = { name: 'retrying', enabled: true }
6 
7  private queue: LogEntry[] = []
8  private retryTimer: Timer | null = null
9  private backoffMs = 1000
10  private maxBackoff = 60000
11 
12  constructor(private inner: Transport) {}
13 
14  log(entry: LogEntry): void {
15    this.queue.push(entry)
16    this.scheduleFlush()
17  }
18 
19  private scheduleFlush() {
20    if (this.retryTimer) return
21 
22    this.retryTimer = setTimeout(async () => {
23      this.retryTimer = null
24      await this.attemptFlush()
25    }, 100)
26  }
27 
28  private async attemptFlush() {
29    try {
30      for (const entry of this.queue) {
31        await this.inner.log(entry)
32      }
33      this.queue = []
34      this.backoffMs = 1000 // Reset on success
35    } catch (error) {
36      // Exponential backoff
37      this.backoffMs = Math.min(this.backoffMs * 2, this.maxBackoff)
38      this.retryTimer = setTimeout(() => {
39        this.retryTimer = null
40        this.attemptFlush()
41      }, this.backoffMs)
42    }
43  }
44 
45  async flush(): Promise<void> {
46    await this.attemptFlush()
47  }
48}

1import { createLogger, HTTPTransport, ConsoleTransport, type LogEntry } from 'vestig'
2 
3class FallbackTransport {
4  readonly name = 'fallback'
5  readonly config = { name: 'fallback', enabled: true }
6 
7  private primaryHealthy = true
8  private healthCheckTimer: Timer | null = null
9 
10  constructor(
11    private primary: HTTPTransport,
12    private fallback: ConsoleTransport
13  ) {
14    this.startHealthCheck()
15  }
16 
17  log(entry: LogEntry): void {
18    if (this.primaryHealthy) {
19      try {
20        this.primary.log(entry)
21      } catch {
22        this.primaryHealthy = false
23        this.fallback.log(entry)
24      }
25    } else {
26      this.fallback.log(entry)
27    }
28  }
29 
30  private startHealthCheck() {
31    this.healthCheckTimer = setInterval(async () => {
32      if (!this.primaryHealthy) {
33        try {
34          await this.primary.flush()
35          this.primaryHealthy = true
36        } catch {
37          // Still unhealthy
38        }
39      }
40    }, 30000)
41  }
42 
43  async flush(): Promise<void> {
44    await Promise.allSettled([
45      this.primary.flush(),
46      this.fallback.flush(),
47    ])
48  }
49 
50  async destroy(): Promise<void> {
51    if (this.healthCheckTimer) {
52      clearInterval(this.healthCheckTimer)
53    }
54    await Promise.all([
55      this.primary.destroy?.(),
56      this.fallback.destroy?.(),
57    ])
58  }
59}

1import { createLogger, HTTPTransport, FileTransport } from 'vestig'
2 
3const logger = createLogger()
4 
5// Primary: HTTP to log aggregator
6logger.addTransport(new HTTPTransport({
7  url: 'https://logs.example.com',
8  maxRetries: 3,
9}))
10 
11// Secondary: Local file as backup
12logger.addTransport(new FileTransport({
13  path: './logs/backup.log',
14  maxSize: 50 * 1024 * 1024, // 50MB
15}))
16 
17// Logs go to both destinations
18logger.info('This is sent to both HTTP and file')

1class CircuitBreaker {
2  private failures = 0
3  private lastFailure = 0
4  private state: 'closed' | 'open' | 'half-open' = 'closed'
5 
6  constructor(
7    private threshold = 5,
8    private resetTimeout = 30000
9  ) {}
10 
11  async execute<T>(fn: () => Promise<T>): Promise<T | null> {
12    if (this.state === 'open') {
13      if (Date.now() - this.lastFailure > this.resetTimeout) {
14        this.state = 'half-open'
15      } else {
16        return null // Circuit open, skip execution
17      }
18    }
19 
20    try {
21      const result = await fn()
22      this.onSuccess()
23      return result
24    } catch (error) {
25      this.onFailure()
26      throw error
27    }
28  }
29 
30  private onSuccess() {
31    this.failures = 0
32    this.state = 'closed'
33  }
34 
35  private onFailure() {
36    this.failures++
37    this.lastFailure = Date.now()
38    if (this.failures >= this.threshold) {
39      this.state = 'open'
40    }
41  }
42 
43  get isOpen(): boolean {
44    return this.state === 'open'
45  }
46}
47 
48// Usage with HTTPTransport
49const circuitBreaker = new CircuitBreaker(5, 30000)
50 
51const transport = new HTTPTransport({
52  url: 'https://logs.example.com',
53})
54 
55// Wrap flush with circuit breaker
56async function safeFlush() {
57  const result = await circuitBreaker.execute(() => transport.flush())
58  if (result === null) {
59    console.warn('Circuit breaker open, logs queued')
60  }
61}

1import { createLogger } from 'vestig'
2 
3const logger = createLogger({
4  sampling: {
5    enabled: true,
6    sampler: {
7      // Normal: log everything
8      default: 1.0,
9      namespaces: {
10        // Under load: sample debug logs
11        'db.*': process.env.HIGH_LOAD ? 0.1 : 1.0,
12        'http.*': process.env.HIGH_LOAD ? 0.5 : 1.0,
13      }
14    }
15  }
16})

1import { CircularBuffer } from 'vestig'
2 
3const buffer = new CircularBuffer<LogEntry>({
4  maxSize: 1000,
5  onDrop: (dropped) => {
6    // Called when entries are dropped
7    console.warn(`Dropped ${dropped.length} log entries due to buffer overflow`)
8 
9    // Optionally: Write to emergency file
10    fs.appendFileSync('./emergency.log',
11      dropped.map(e => JSON.stringify(e)).join('\n')
12    )
13  }
14})

1import { createLogger, BatchTransport, type LogEntry } from 'vestig'
2import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
3 
4class PersistentQueueTransport extends BatchTransport {
5  private queueFile: string
6 
7  constructor(options: { queueFile: string; url: string }) {
8    super({
9      name: 'persistent-queue',
10      batchSize: 100,
11      flushInterval: 5000,
12    })
13    this.queueFile = options.queueFile
14    this.loadQueue()
15  }
16 
17  private loadQueue() {
18    if (existsSync(this.queueFile)) {
19      const data = readFileSync(this.queueFile, 'utf-8')
20      const entries = JSON.parse(data) as LogEntry[]
21      for (const entry of entries) {
22        super.log(entry)
23      }
24      unlinkSync(this.queueFile)
25    }
26  }
27 
28  protected async send(entries: LogEntry[]): Promise<void> {
29    try {
30      await this.sendToServer(entries)
31    } catch (error) {
32      // Persist failed entries
33      const existing = existsSync(this.queueFile)
34        ? JSON.parse(readFileSync(this.queueFile, 'utf-8'))
35        : []
36      writeFileSync(this.queueFile, JSON.stringify([...existing, ...entries]))
37      throw error
38    }
39  }
40 
41  private async sendToServer(entries: LogEntry[]): Promise<void> {
42    // Implementation
43  }
44}

1import { createLoggerAsync, FileTransport, HTTPTransport } from 'vestig'
2 
3async function initLogging(retries = 3): Promise<Logger> {
4  for (let i = 0; i < retries; i++) {
5    try {
6      const logger = await createLoggerAsync({
7        level: 'info',
8        namespace: 'app',
9      })
10 
11      // Add transports that need async init
12      logger.addTransport(new FileTransport({
13        path: './logs/app.log',
14      }))
15 
16      logger.addTransport(new HTTPTransport({
17        url: process.env.LOG_ENDPOINT!,
18      }))
19 
20      return logger
21    } catch (error) {
22      if (i === retries - 1) throw error
23      await new Promise(r => setTimeout(r, 1000 * (i + 1)))
24    }
25  }
26  throw new Error('Failed to initialize logging')
27}
28 
29// Usage
30const logger = await initLogging()

1import { createLogger, createLoggerAsync, HTTPTransport } from 'vestig'
2 
3// Immediate: console-only logger
4let logger = createLogger({ level: 'info' })
5logger.info('App starting with console logging')
6 
7// Background: upgrade to HTTP transport
8;(async () => {
9  try {
10    const httpTransport = new HTTPTransport({
11      url: process.env.LOG_ENDPOINT!,
12    })
13    await httpTransport.init?.()
14    logger.addTransport(httpTransport)
15    logger.info('Upgraded to HTTP logging')
16  } catch (error) {
17    logger.warn('Failed to initialize HTTP transport, using console only', { error })
18  }
19})()

1import { createLogger, HTTPTransport, initLogger } from 'vestig'
2 
3const logger = createLogger()
4logger.addTransport(new HTTPTransport({ url: '...' }))
5 
6// Flush on shutdown signals
7const shutdown = async (signal: string) => {
8  logger.info('Shutdown initiated', { signal })
9 
10  try {
11    await logger.flush()
12    logger.info('All logs flushed')
13  } catch (error) {
14    console.error('Failed to flush logs:', error)
15  } finally {
16    process.exit(0)
17  }
18}
19 
20process.on('SIGTERM', () => shutdown('SIGTERM'))
21process.on('SIGINT', () => shutdown('SIGINT'))
22 
23// Also handle uncaught exceptions
24process.on('uncaughtException', async (error) => {
25  logger.error('Uncaught exception', { error })
26  await logger.flush()
27  process.exit(1)
28})

1new HTTPTransport({
2  url: '...',
3  timeout: 10000, // Don't wait forever
4})

1// Production: more retries for reliability
2new HTTPTransport({
3  maxRetries: 5,
4  retryDelay: 1000,
5})
6 
7// Development: fail fast
8new HTTPTransport({
9  maxRetries: 1,
10  retryDelay: 100,
11})

1const transport = new HTTPTransport({ url: '...' })
2 
3// Periodically check health
4setInterval(async () => {
5  try {
6    await transport.flush()
7  } catch (error) {
8    if (error instanceof HTTPTransportError) {
9      alertOps({
10        type: 'logging_unhealthy',
11        error: error.message,
12        statusCode: error.statusCode,
13      })
14    }
15  }
16}, 60000)

1// Don't rely on a single destination
2logger.addTransport(new HTTPTransport({ url: primary }))
3logger.addTransport(new HTTPTransport({ url: secondary }))
4logger.addTransport(new FileTransport({ path: './backup.log' }))

1// Network offline
2if (!navigator.onLine) {
3  // Queue locally, sync when online
4  window.addEventListener('online', () => logger.flush())
5}
6 
7// Page unload (browser)
8window.addEventListener('beforeunload', () => {
9  navigator.sendBeacon('/api/logs', JSON.stringify(pendingLogs))
10})