Memory Management

1import { createLogger } from 'vestig'
2 
3const logger = createLogger()
4 
5function processRequest(requestId: string) {
6  // Child is created and cached
7  const requestLogger = logger.child(requestId)
8  requestLogger.info('Processing')
9 
10  // When function exits and no references remain,
11  // the child logger can be garbage collected
12}
13 
14// Even with thousands of requests, memory stays bounded
15for (let i = 0; i < 100000; i++) {
16  processRequest(`req-${i}`)
17}
18// Old child loggers are GC'd, only recent ones in memory

1// Internal implementation (simplified):
2const childLoggerRegistry = new FinalizationRegistry<{
3  parent: WeakRef<LoggerImpl>
4  namespace: string
5}>(({ parent, namespace }) => {
6  // When child is GC'd, remove from parent's cache
7  parent.deref()?.cleanupChild(namespace)
8})

1// ✅ Good: Namespaces with config bypass cache
2const logger = createLogger()
3 
4// Each call creates a fresh logger (not cached)
5logger.child('request', { context: { requestId: '123' } })
6logger.child('request', { context: { requestId: '456' } })
7 
8// ✅ Good: Reuse namespace for static children
9const dbLogger = logger.child('db')      // Cached
10const authLogger = logger.child('auth')  // Cached
11 
12// ❌ Avoid: Dynamic namespaces without config
13// These get cached and may accumulate
14for (const userId of users) {
15  logger.child(`user-${userId}`)  // Creates cached entries
16}
17 
18// ✅ Better: Use context instead of namespace
19for (const userId of users) {
20  logger.child('user', { context: { userId } })  // Not cached
21}

1import { CircularBuffer } from 'vestig'
2 
3const buffer = new CircularBuffer<LogEntry>({
4  maxSize: 1000,  // Maximum entries
5})
6 
7// When full, oldest entries are automatically dropped
8for (let i = 0; i < 2000; i++) {
9  buffer.push({ message: `Log ${i}` })
10}
11 
12console.log(buffer.size)  // 1000 (not 2000)

1import { CircularBuffer } from 'vestig'
2 
3let droppedCount = 0
4 
5const buffer = new CircularBuffer<LogEntry>({
6  maxSize: 500,
7  onDrop: (dropped) => {
8    droppedCount += dropped.length
9 
10    // Alert if dropping too many
11    if (droppedCount > 1000) {
12      alertOps('High log drop rate', { droppedCount })
13    }
14 
15    // Optionally persist critical logs
16    const critical = dropped.filter(e => e.level === 'error')
17    if (critical.length > 0) {
18      fs.appendFileSync('./critical.log',
19        critical.map(e => JSON.stringify(e)).join('\n')
20      )
21    }
22  }
23})

1// Formula: (logs per second) × (flush interval seconds) × (safety margin)
2 
3// Example: 100 logs/sec, 5 second flush, 2x margin
4const batchSize = 100 * 5 * 2  // 1000 entries
5 
6new HTTPTransport({
7  batchSize: 1000,
8  flushInterval: 5000,
9})

1import { HTTPTransport } from 'vestig'
2 
3const transport = new HTTPTransport({
4  url: 'https://logs.example.com',
5  batchSize: 100,        // Flush when 100 entries
6  flushInterval: 5000,   // Or every 5 seconds
7})
8 
9// Memory used: ~100 entries max (plus in-flight batches)

1const logger = createLogger()
2 
3async function processLargeFile(path: string) {
4  // Flush logs before memory-intensive work
5  await logger.flush()
6 
7  // Now load large data
8  const data = await fs.readFile(path)
9 
10  logger.info('File loaded', { size: data.length })
11}

1import { createLogger, HTTPTransport, FileTransport } from 'vestig'
2 
3const logger = createLogger()
4logger.addTransport(new HTTPTransport({ url: '...' }))
5logger.addTransport(new FileTransport({ path: '...' }))
6 
7// On shutdown: flush and cleanup
8process.on('SIGTERM', async () => {
9  await logger.destroy()  // Flushes and releases resources
10  process.exit(0)
11})

1import { withContext } from 'vestig'
2 
3async function handleRequest(req: Request) {
4  // Context allocated for this async chain
5  await withContext({ requestId: req.id }, async () => {
6    await processRequest(req)
7    // Context is released when this async scope exits
8  })
9}

1// ❌ Bad: Storing context references outside scope
2let savedContext: LogContext
3 
4await withContext({ requestId: '123' }, async () => {
5  savedContext = getContext()  // Reference escapes scope
6})
7// savedContext may prevent GC of request data
8 
9// ✅ Good: Extract only needed data
10let requestId: string
11 
12await withContext({ requestId: '123' }, async () => {
13  requestId = getContext()?.requestId ?? ''
14})
15// Only primitive saved, context can be GC'd

1import { serializeError } from 'vestig'
2 
3// Deep cause chain (for demonstration)
4let error = new Error('level 0')
5for (let i = 1; i <= 20; i++) {
6  error = new Error(`level ${i}`, { cause: error })
7}
8 
9const serialized = serializeError(error)
10// Only first 10 levels serialized, preventing unbounded memory

1const error1 = new Error('Error 1')
2const error2 = new Error('Error 2', { cause: error1 })
3;(error1 as any).cause = error2  // Circular!
4 
5const serialized = serializeError(error1)
6// Circular reference detected, "[Circular Reference]" inserted

1import { createLogger } from 'vestig'
2 
3const logger = createLogger({
4  sampling: {
5    enabled: true,
6    sampler: {
7      // Keep all errors
8      default: { probability: 0.1 },  // 10% of normal logs
9      namespaces: {
10        'db.*': { maxPerSecond: 100 },  // Rate limit DB logs
11      }
12    }
13  }
14})
15 
16// Fewer logs = less memory for buffering

1// ❌ Bad: Large objects in metadata
2logger.info('Response', {
3  body: hugeJsonResponse  // May be megabytes
4})
5 
6// ✅ Good: Log summary, store full data elsewhere
7logger.info('Response', {
8  bodySize: hugeJsonResponse.length,
9  bodyHash: hash(hugeJsonResponse),
10  storageRef: await storeBlob(hugeJsonResponse)
11})

1import { FileTransport } from 'vestig'
2 
3const transport = new FileTransport({
4  path: './logs/app.log',
5  batchSize: 50,       // Smaller batches
6  flushInterval: 1000, // Flush frequently
7  maxSize: 100 * 1024 * 1024,  // 100MB per file
8  maxFiles: 5,         // Keep 5 files max
9})
10 
11// Memory used: ~50 entries max per batch

1import { createMetricsCollector } from 'vestig'
2 
3const metrics = createMetricsCollector()
4 
5// Periodically check metrics
6setInterval(() => {
7  const prometheus = metrics.toPrometheus()
8 
9  // Parse and alert on high buffer usage
10  if (metrics.getBufferSize() > 800) {
11    console.warn('Log buffer near capacity')
12  }
13}, 10000)

1// Add to your monitoring
2const memoryUsage = process.memoryUsage()
3 
4logger.info('Memory stats', {
5  heapUsed: memoryUsage.heapUsed / 1024 / 1024,
6  heapTotal: memoryUsage.heapTotal / 1024 / 1024,
7  external: memoryUsage.external / 1024 / 1024,
8  rss: memoryUsage.rss / 1024 / 1024,
9})

1interface CircularBufferConfig<T> {
2  maxSize: number
3  onDrop?: (dropped: T[]) => void
4}

1interface Transport {
2  destroy?(): Promise<void>  // Cleanup resources
3  flush?(): Promise<void>    // Flush pending logs
4}

1interface Logger {
2  init(): Promise<void>     // Initialize transports
3  flush(): Promise<void>    // Flush all transports
4  destroy(): Promise<void>  // Cleanup everything
5}