Runtime Detection

1import { RUNTIME } from 'vestig'
2 
3console.log(RUNTIME)
4// 'node' | 'bun' | 'deno' | 'edge' | 'browser' | 'worker' | 'unknown'
5 
6// Conditional logic based on runtime
7if (RUNTIME === 'browser') {
8  // Browser-specific code
9} else {
10  // Server-specific code
11}

1import {
2  IS_NODE,
3  IS_BUN,
4  IS_DENO,
5  IS_EDGE,
6  IS_BROWSER,
7  IS_WORKER,
8  IS_SERVER
9} from 'vestig'
10 
11// IS_SERVER is true for Node, Bun, Deno, and Edge
12if (IS_SERVER) {
13  // Run server-side code
14}
15 
16if (IS_BROWSER) {
17  // Run browser code
18}
19 
20// Specific runtime checks
21if (IS_BUN) {
22  console.log('Running on Bun!')
23}
24 
25if (IS_DENO) {
26  console.log('Running on Deno!')
27}

1import { CAPABILITIES } from 'vestig'
2 
3console.log(CAPABILITIES)
4// {
5//   hasAsyncLocalStorage: true,
6//   hasConsole: true,
7//   hasProcess: true,
8//   hasPerformance: true,
9//   hasCrypto: true
10// }
11 
12if (CAPABILITIES.hasAsyncLocalStorage) {
13  // Context propagation will work across async boundaries
14}
15 
16if (CAPABILITIES.hasPerformance) {
17  // High-resolution timing is available
18}

1import { log } from 'vestig'
2 
3log.info('Hello World', { key: 'value' })
4 
5// Node/Bun/Deno (TTY): Colorized, formatted output
6// Edge: Structured JSON
7// Browser: console.log with styled output
8// Worker: console.log plain text

1import { FileTransport, IS_SERVER } from 'vestig'
2 
3// Only use FileTransport on server
4const transports = [
5  new ConsoleTransport(),
6  ...(IS_SERVER ? [new FileTransport({ path: './logs' })] : [])
7]

1import { RUNTIME } from 'vestig'
2 
3function getEnv(key: string): string | undefined {
4  switch (RUNTIME) {
5    case 'node':
6    case 'bun':
7      return process.env[key]
8    case 'deno':
9      return Deno.env.get(key)
10    default:
11      return undefined
12  }
13}
14 
15// Vestig handles this internally for its own config:
16// VESTIG_LEVEL, VESTIG_ENABLED, etc.

1import { CAPABILITIES, IS_SERVER, IS_BROWSER } from 'vestig'
2 
3// Universal logger setup
4function createUniversalLogger() {
5  const transports = []
6 
7  // Always add console
8  transports.push(new ConsoleTransport({
9    colors: IS_SERVER // Only use colors on server
10  }))
11 
12  // Add HTTP transport for browsers
13  if (IS_BROWSER) {
14    transports.push(new HTTPTransport({
15      endpoint: '/api/logs',
16      batchSize: 10
17    }))
18  }
19 
20  // Add file transport on server
21  if (IS_SERVER && CAPABILITIES.hasProcess) {
22    transports.push(new FileTransport({
23      path: process.env.LOG_PATH || './logs'
24    }))
25  }
26 
27  return createLogger({ transports })
28}

1// utils/storage.ts
2import { IS_BROWSER, IS_SERVER } from 'vestig'
3 
4export async function persistData(key: string, data: unknown) {
5  if (IS_BROWSER) {
6    localStorage.setItem(key, JSON.stringify(data))
7  } else if (IS_SERVER) {
8    const fs = await import('fs/promises')
9    await fs.writeFile(`./data/${key}.json`, JSON.stringify(data))
10  }
11}

1import { span, RUNTIME, IS_BROWSER } from 'vestig'
2 
3async function fetchData(url: string) {
4  return await span('fetch-data', async (s) => {
5    s.setAttribute('runtime', RUNTIME)
6    s.setAttribute('url', url)
7 
8    if (IS_BROWSER) {
9      s.setAttribute('userAgent', navigator.userAgent)
10    }
11 
12    const response = await fetch(url)
13    s.setAttribute('status', response.status)
14 
15    return response.json()
16  })
17}

1import { IS_EDGE, CAPABILITIES } from 'vestig'
2 
3if (IS_EDGE) {
4  // ⚠️ Limited AsyncLocalStorage support
5  // Context may not persist across some async boundaries
6 
7  // ⚠️ No file system access
8  // FileTransport won't work
9 
10  // ✅ HTTP transport works great
11  // ✅ Console transport works
12 
13  // ✅ Crypto is available
14  // ✅ Performance timing works
15}

1import { createLogger, ConsoleTransport, HTTPTransport, IS_EDGE } from 'vestig'
2 
3const logger = createLogger({
4  level: IS_EDGE ? 'info' : 'debug', // Less verbose on edge
5  structured: true, // Always JSON on edge
6  transports: [
7    new ConsoleTransport(),
8    new HTTPTransport({
9      endpoint: 'https://logs.example.com/ingest',
10      batchSize: IS_EDGE ? 5 : 50 // Smaller batches on edge
11    })
12  ]
13})

1// Works in Deno!
2import { log, RUNTIME, IS_DENO, withContext } from 'vestig'
3 
4console.log(RUNTIME)  // 'deno'
5console.log(IS_DENO)  // true
6 
7// AsyncLocalStorage works via node:async_hooks compatibility
8await withContext({ requestId: 'req-123' }, async () => {
9  log.info('Hello from Deno!')
10  // Context propagates correctly
11})

1# Basic usage - no special permissions needed
2deno run app.ts
3 
4# With file logging
5deno run --allow-write=./logs app.ts
6 
7# With HTTP transport
8deno run --allow-net app.ts
9 
10# With environment variables
11deno run --allow-env app.ts

1vestig (browser build):
2├── Core logger: ~3KB gzipped
3├── HTTP transport: ~1KB gzipped
4├── Sanitization: ~1KB gzipped
5└── Total: <5KB gzipped

1type Runtime = 'node' | 'bun' | 'deno' | 'edge' | 'browser' | 'worker' | 'unknown'
2 
3interface RuntimeCapabilities {
4  hasAsyncLocalStorage: boolean
5  hasConsole: boolean
6  hasProcess: boolean
7  hasPerformance: boolean
8  hasCrypto: boolean
9}