import { log } from 'vestig'

// Simple logging
log.info('Hello world')
log.error('Something failed', { userId: 123 })

// Sensitive data is automatically redacted
log.info('User login', {
  email: '[email protected]',     // → us***@example.com
  password: 'secret123',          // → [REDACTED]
  creditCard: '4111111111111111', // → ****1111
})

// app/page.tsx
import { getLogger } from '@vestig/next'

export default async function Page() {
  const log = await getLogger('home')

  log.info('Rendering home page')

  return <h1>Welcome</h1>
}

// lib/db.ts
import postgres from 'postgres'
import { instrumentPostgres } from '@vestig/next/db'
import { drizzle } from 'drizzle-orm/postgres-js'

// Wrap postgres-js client for automatic instrumentation
const client = instrumentPostgres(postgres(process.env.DATABASE_URL!), {
  slowQueryThreshold: 100,  // Flag queries over 100ms
  onQuery: (entry) => {
    // Custom metrics callback (e.g., for noisy neighbor detection)
    if (entry.isSlow) {
      metrics.record('slow_query', { table: entry.table, duration: entry.duration })
    }
  }
})

export const db = drizzle(client)

import { createLogger, HTTPTransport, DatadogTransport, SentryTransport } from 'vestig'

const log = createLogger()

// Add HTTP transport for centralized logging
log.addTransport(new HTTPTransport({
  name: 'api-logs',
  url: 'https://logs.example.com/ingest',
  headers: { 'Authorization': 'Bearer token' },
}))

// Add Datadog for observability
log.addTransport(new DatadogTransport({
  name: 'datadog',
  apiKey: process.env.DD_API_KEY,
  service: 'my-app',
  tags: ['env:production'],
}))

// Add Sentry for error tracking
log.addTransport(new SentryTransport({
  name: 'sentry',
  dsn: process.env.SENTRY_DSN,
  environment: 'production',
  minLevel: 'warn', // Only send warn/error to Sentry
}))

// Initialize transports (starts flush timers)
await log.init()

// All logs go to console, HTTP endpoint, Datadog, and Sentry
log.info('Server started', { port: 3000 })

import { Sanitizer } from 'vestig'

// GDPR compliance (EU data protection)
const gdprSanitizer = Sanitizer.fromPreset('gdpr')

// HIPAA compliance (healthcare)
const hipaaSanitizer = Sanitizer.fromPreset('hipaa')

// PCI-DSS compliance (payment cards)
const pciSanitizer = Sanitizer.fromPreset('pci-dss')

// Apply to logger
const log = createLogger({
  sanitize: 'gdpr', // Use preset name directly
})

import { span } from 'vestig'

// Trace async operations
await span('api:request', async (s) => {
  s.setAttribute('method', 'GET')
  s.setAttribute('path', '/users')

  await span('db:query', async () => {
    return await db.query('SELECT * FROM users')
  })

  s.setStatus('ok')
})

import { instrumentFetch } from 'vestig'

// One line - all fetch() calls now create spans
instrumentFetch({
  ignoreUrls: ['/health', /^\/_next/],
  captureHeaders: ['content-type', 'x-request-id'],
})

// Now every fetch is traced automatically
await fetch('https://api.example.com/users')
// → Span: "http.client GET api.example.com/users"

import { registerSpanProcessor, span } from 'vestig'
import { OTLPExporter } from 'vestig/otlp'

// Connect to Jaeger, Honeycomb, Vercel, Grafana, etc.
const exporter = new OTLPExporter({
  endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
  serviceName: 'my-app',
  headers: { 'Authorization': `Bearer ${process.env.OTEL_TOKEN}` },
})

registerSpanProcessor(exporter)

// All spans automatically exported
await span('checkout', async (s) => {
  s.setAttribute('orderId', order.id)
  await processPayment()
})

// instrumentation.ts
import { registerVestig } from '@vestig/next/instrumentation'

export function register() {
  registerVestig({
    serviceName: 'my-nextjs-app',
    otlp: {
      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
    },
    autoInstrument: {
      fetch: true,  // Auto-trace all fetch() calls
    },
  })
}

import { createLogger, createProbabilitySampler, createRateLimitSampler } from 'vestig'

// Probability sampling - keep 10% of logs
const logger = createLogger({
  sampling: {
    sampler: createProbabilitySampler({ rate: 0.1 }),
    alwaysSample: ['error', 'warn']  // Always keep errors and warnings
  }
})

// Rate limit sampling - max 100 logs per second
const rateLimitedLogger = createLogger({
  sampling: {
    sampler: createRateLimitSampler({ maxPerSecond: 100 })
  }
})

import { createLogger, createWideEvent } from 'vestig'

const log = createLogger({
  tailSampling: {
    enabled: true,
    alwaysKeepStatuses: ['error'],  // 100% of errors
    slowThresholdMs: 2000,          // 100% of slow requests
    successSampleRate: 0.1,         // 10% of successful requests
  }
})

// Create and enrich the wide event throughout the request
const event = createWideEvent({ type: 'http.request' })

// Add context as you go
event.merge('http', { method: 'POST', path: '/api/checkout', status_code: 200 })
event.merge('user', { id: 'user-456', subscription: 'premium' })
event.merge('performance', { db_query_ms: 45, external_api_ms: 230 })

// End and emit the event
const completedEvent = event.end({ status: 'success' })
log.emitWideEvent(completedEvent)

// Output: ONE event with 50+ fields, easily queryable

import { Sanitizer } from 'vestig'

const sanitizer = new Sanitizer({
  fields: [
    'customSecret',
    { type: 'prefix', value: 'private_' },
    { type: 'contains', value: 'token' },
  ],
  patterns: [{
    name: 'internal-id',
    pattern: /ID-[A-Z0-9]+/g,
    replacement: '[ID_REDACTED]',
  }],
})

const safe = sanitizer.sanitize({
  private_key: 'abc123',     // → [REDACTED]
  auth_token: 'xyz789',      // → [REDACTED]
  internalId: 'ID-ABC123',   // → [ID_REDACTED]
})

const log = createLogger({ namespace: 'app' })
const dbLog = log.child('database')
const cacheLog = log.child('cache')

dbLog.info('Query executed')  // [app:database] Query executed
cacheLog.info('Cache hit')    // [app:cache] Cache hit

import { withContext, createCorrelationContext } from 'vestig'

// Next.js API Route
export async function GET(req: Request) {
  const context = createCorrelationContext({
    requestId: req.headers.get('x-request-id') ?? undefined
  })

  return withContext(context, async () => {
    log.info('Request started')
    // All logs include: requestId, traceId, spanId

    const result = await fetchData()
    log.info('Request completed')

    return Response.json(result)
  })
}

const log = createLogger({
  level: 'debug',
  enabled: true,
  structured: false,
  sanitize: 'gdpr',  // or true, false, or SanitizeConfig
  context: { environment: 'development' }
})

import { RUNTIME, IS_SERVER, IS_DENO } from 'vestig'

console.log(RUNTIME) // 'node' | 'bun' | 'deno' | 'edge' | 'browser' | 'worker' | 'unknown'

import { HTTPTransport } from 'vestig'

const transport = new HTTPTransport({
  name: 'my-http',
  url: 'https://logs.example.com/ingest',
  method: 'POST',
  headers: {
    'Authorization': 'Bearer my-token',
    'X-Custom-Header': 'value',
  },
  batchSize: 100,        // Send when 100 logs accumulated
  flushInterval: 5000,   // Or every 5 seconds
  maxRetries: 3,         // Retry failed requests
  timeout: 30000,        // Request timeout
  transform: (entries) => ({
    logs: entries,
    timestamp: Date.now(),
  }),
})

import { FileTransport } from 'vestig'

const transport = new FileTransport({
  name: 'file',
  path: '/var/log/app/app.log',
  maxSize: 10 * 1024 * 1024,  // 10MB before rotation
  maxFiles: 5,                 // Keep 5 rotated files
  compress: true,              // Gzip rotated files
})

import { DatadogTransport } from 'vestig'

const transport = new DatadogTransport({
  name: 'datadog',
  apiKey: process.env.DD_API_KEY!,
  site: 'datadoghq.com',  // or datadoghq.eu, us3, us5
  service: 'my-service',
  source: 'vestig',
  tags: ['env:production', 'team:backend'],
})

// Before (Pino)
import pino from 'pino'
const logger = pino({ level: 'info' })
logger.info({ userId: 123 }, 'User logged in')

// After (Vestig)
import { createLogger } from 'vestig'
const logger = createLogger({ level: 'info' })
logger.info('User logged in', { userId: 123 })

// Before (Winston)
import winston from 'winston'
const logger = winston.createLogger({
  level: 'info',
  transports: [new winston.transports.Console()],
})
logger.info('Hello', { meta: 'data' })

// After (Vestig)
import { createLogger } from 'vestig'
const logger = createLogger({ level: 'info' })
logger.info('Hello', { meta: 'data' })