TypeScript logging
done right.

import { Module } from '@nestjs/common';
import { LogixiaModule } from 'logixia/nest';
import { ConsoleTransport, FileTransport } from 'logixia';
import { ConfigService } from '@nestjs/config';

@Module({
  imports: [
    LogixiaModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        level: config.get('LOG_LEVEL', 'info'),
        transports: [
          new ConsoleTransport({ colorize: config.get('NODE_ENV') !== 'production' }),
          new FileTransport({ filename: 'logs/nest.log', rotate: true }),
        ],
      }),
    }),
  ],
})
export class AppModule {}

// In your service:
@Injectable()
export class UserService {
  constructor(private readonly logger: LogixiaLogger) {}

  async findUser(id: string) {
    this.logger.debug('Finding user', { id });
    // logger automatically carries the request context
  }
}

import {
  createLogger,
  ConsoleTransport,
  FileTransport,
  DatabaseTransport,
  WebhookTransport,
  AnalyticsTransport,
} from 'logixia';

const logger = createLogger({
  level: 'debug',
  transports: [
    // Dev console with colors
    new ConsoleTransport({ colorize: true, pretty: true }),

    // Rotating file logs
    new FileTransport({ filename: 'logs/app.log', rotate: true, maxFiles: 7 }),

    // Persist errors to DB for search
    new DatabaseTransport({
      adapter: 'postgres',
      connectionString: process.env.DATABASE_URL!,
      minLevel: 'warn',
      tableName: 'application_logs',
    }),

    // Slack alerts for errors
    new WebhookTransport({
      url: process.env.SLACK_WEBHOOK_URL!,
      minLevel: 'error',
      batch: { size: 5, intervalMs: 1000 },
    }),

    // Analytics events
    new AnalyticsTransport({
      provider: 'segment',
      writeKey: process.env.SEGMENT_WRITE_KEY!,
      minLevel: 'info',
    }),
  ],
});

import { createLogger, createRequestContext } from 'logixia';
import type { Request, Response, NextFunction } from 'express';

const logger = createLogger({ level: 'info', transports: [...] });

// Express middleware — attaches context to every log in this request
export function requestLogger(req: Request, res: Response, next: NextFunction) {
  const ctx = createRequestContext({
    requestId: req.headers['x-request-id'] as string ?? crypto.randomUUID(),
    userId: req.user?.id,
    tenantId: req.headers['x-tenant-id'] as string,
    ip: req.ip,
    method: req.method,
    path: req.path,
  });

  // reqLogger carries all context fields automatically
  const reqLogger = logger.withContext(ctx);
  req.logger = reqLogger;

  reqLogger.info('Request started');

  res.on('finish', () => {
    reqLogger.info('Request completed', {
      status: res.statusCode,
      duration: Date.now() - req.startTime,
    });
  });

  next();
}

import { LogSearcher } from 'logixia';

const searcher = new LogSearcher({
  adapter: 'postgres',
  connectionString: process.env.DATABASE_URL!,
  tableName: 'application_logs',
});

// Full-text search with filters
const results = await searcher.search({
  query: 'payment failed',
  levels: ['error', 'fatal'],
  from: new Date('2025-01-01'),
  to: new Date('2025-01-31'),
  fields: { userId: '42', tenantId: 'acme' },
  limit: 50,
  orderBy: 'timestamp',
  order: 'desc',
});

console.log(results.total);  // total matching logs
console.log(results.logs);   // LogEntry[] — fully typed

import { Transport, LogEntry } from 'logixia';

// Implement 2 methods. That's all.
class DatadogTransport implements Transport {
  private readonly apiKey: string;

  constructor({ apiKey }: { apiKey: string }) {
    this.apiKey = apiKey;
  }

  async write(entry: LogEntry): Promise<void> {
    await fetch('https://http-intake.logs.datadoghq.com/v1/input/' + this.apiKey, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        level: entry.level,
        message: entry.message,
        timestamp: entry.timestamp,
        ...entry.fields,
      }),
    });
  }

  async close(): Promise<void> {
    // flush pending batches
  }
}

// Use like any built-in transport
const logger = createLogger({
  transports: [new DatadogTransport({ apiKey: process.env.DD_API_KEY! })],
});