Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

2.6 KB
Raw Blame
type LogLevel = 'debug' | 'info' | 'warn' | 'error'

interface LogContext {
  [key: string]: unknown
}

/**
 * One line per log, in one of two shapes.
 *
 * In the cluster: JSON, because that is what Datadog can read. It parses a JSON line into
 * attributes, so `logger.info('web user disconnected', { userId })` becomes something you can filter
 * with `@userId` and group by. `message` and `status` are the names it reads for the text and the
 * level; every other key becomes an attribute of its own. The old format — `[ts] [INFO] text {json}`
 * — arrived as one string, so the context was text nobody could query.
 *
 * Anywhere else (a terminal, the tests): that readable line, unchanged. `npm run dev` should not be
 * a wall of JSON.
 */
export class Logger {
  private isDevelopment = process.env.NODE_ENV === 'development'

  constructor(private readonly asJson: boolean = process.env.NODE_ENV === 'production') {}

  private write(level: LogLevel, to: (line: string) => void, message: string, context?: LogContext): void {
    const timestamp = new Date().toISOString()
    if (this.asJson) {
      // Context first: a field called `message` or `status` is data about the event, and must not
      // take the place of the event's own message or level.
      to(JSON.stringify({ ...context, timestamp, status: level, message }))
      return
    }
    to(`[${timestamp}] [${level.toUpperCase()}] ${message}${context ? ` ${JSON.stringify(context)}` : ''}`)
  }

  debug(message: string, context?: LogContext): void {
    if (this.isDevelopment) this.write('debug', (line) => console.debug(line), message, context)
  }

  info(message: string, context?: LogContext): void {
    this.write('info', (line) => console.log(line), message, context)
  }

  warn(message: string, context?: LogContext): void {
    this.write('warn', (line) => console.warn(line), message, context)
  }

  error(message: string, error?: Error | unknown, context?: LogContext): void {
    let errorContext: LogContext
    if (error instanceof Error) {
      errorContext = { ...context, error: error.message, stack: this.isDevelopment ? error.stack : undefined }
    } else if (error && typeof error === 'object') {
      const errorObj = error as Record<string, unknown>
      errorContext = { ...context, error: errorObj.message || errorObj.code || JSON.stringify(error) }
    } else if (error !== undefined) {
      errorContext = { ...context, error: String(error) }
    } else {
      errorContext = { ...context }
    }
    this.write('error', (line) => console.error(line), message, errorContext)
  }
}

export const logger = new Logger()