Logging

Meloqui provides structured logging with configurable log levels.

ILogger

Interface for structured logging implementations.

interface ILogger {
  debug(message: string, context?: Record<string, unknown>): void;
  info(message: string, context?: Record<string, unknown>): void;
  warn(message: string, context?: Record<string, unknown>): void;
  error(message: string, error?: Error, context?: Record<string, unknown>): void;
}

LogLevel

Log level hierarchy: debug < info < warn < error

type LogLevel = 'debug' | 'info' | 'warn' | 'error';

ConsoleLogger

Default logger implementation that outputs to the console.

import { ChatClient, ConsoleLogger } from 'meloqui';

const logger = new ConsoleLogger({ level: 'debug' });

const client = new ChatClient({
  provider: 'openai',
  model: 'gpt-4o',
  logger
});

ConsoleLoggerOptions

interface ConsoleLoggerOptions {
  /** Log level - only messages at this level or higher are logged */
  level?: LogLevel; // default: 'info'
}

Output Format

[DEBUG] Message here { context: 'data' }
[INFO] Message here { context: 'data' }
[WARN] Message here { context: 'data' }
[ERROR] Message here Error: ... { context: 'data' }

Custom Logger Implementation

Implement ILogger to integrate with your logging infrastructure:

import { ILogger } from 'meloqui';
import winston from 'winston';

class WinstonLogger implements ILogger {
  private logger: winston.Logger;

  constructor() {
    this.logger = winston.createLogger({
      level: 'debug',
      format: winston.format.json(),
      transports: [new winston.transports.Console()]
    });
  }

  debug(message: string, context?: Record<string, unknown>): void {
    this.logger.debug(message, context);
  }

  info(message: string, context?: Record<string, unknown>): void {
    this.logger.info(message, context);
  }

  warn(message: string, context?: Record<string, unknown>): void {
    this.logger.warn(message, context);
  }

  error(message: string, error?: Error, context?: Record<string, unknown>): void {
    this.logger.error(message, { error, ...context });
  }
}

With Pino

import { ILogger } from 'meloqui';
import pino from 'pino';

class PinoLogger implements ILogger {
  private logger = pino();

  debug(message: string, context?: Record<string, unknown>): void {
    this.logger.debug(context, message);
  }

  info(message: string, context?: Record<string, unknown>): void {
    this.logger.info(context, message);
  }

  warn(message: string, context?: Record<string, unknown>): void {
    this.logger.warn(context, message);
  }

  error(message: string, error?: Error, context?: Record<string, unknown>): void {
    this.logger.error({ err: error, ...context }, message);
  }
}

Silent Logger

To disable logging entirely:

const silentLogger: ILogger = {
  debug: () => {},
  info: () => {},
  warn: () => {},
  error: () => {}
};

const client = new ChatClient({
  provider: 'openai',
  model: 'gpt-4o',
  logger: silentLogger
});