feat: add logger options to file, separate http logs and app logs

Author: sckv

README.md

@@ -16,7 +16,7 @@ Full-featured slim webserver for microservices with extremely low overhead and r
 ## Requirements
 
 ```bash
-Node.js >= 14.8
+Node.js >= 22
 ```
 
 ## Quick start
@@ -147,6 +147,23 @@ Default `false`
 
 Enable request/response logging, format varies from `production` or `development` environments, though to change use e.g. `NODE_ENV=production`
 
+#### `logger?` (Object)
+
+Configure log outputs for app logs and http request logs.
+
+```typescript
+const app = new BareHttp({
+  logging: true,
+  logger: {
+    app: { file: './logs/app.log' },
+    http: { file: './logs/http.log' },
+    level: 'debug',
+  },
+});
+```
+
+`app.file` and `http.file` accept a path string or `{ path, sync }`, and `http.file` is used only when `logging: true`. `console` (default `true`) keeps stdout logging, and `pretty` (default `true` outside production) controls colored console output. `level` sets the base level and can be overridden per target with `app.level` or `http.level`.
+
 #### `ws?` (Boolean)
 
 Default `false`

src/__tests__/logger/output.test.ts

@@ -0,0 +1,53 @@
+import axios from 'axios';
+
+import { mkdtempSync, readFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { envs } from '../../env.js';
+import { BareHttp } from '../../server.js';
+import { logMe } from '../../logger/index.js';
+
+test('Writes http and app logs into separate files', async () => {
+  const tempDir = mkdtempSync(join(tmpdir(), 'barehttp-logger-'));
+  const appLogPath = join(tempDir, 'app.log');
+  const httpLogPath = join(tempDir, 'http.log');
+  const prevIsTest = envs.isTest;
+
+  try {
+    envs.isTest = false;
+    const app = new BareHttp({
+      setRandomPort: true,
+      logging: true,
+      logger: {
+        console: false,
+        pretty: false,
+        app: { file: { path: appLogPath, sync: true } },
+        http: { file: { path: httpLogPath, sync: true } },
+      },
+    });
+
+    app.route.get({
+      route: '/logger-test',
+      handler: () => {
+        logMe.info('app-log-works');
+        return { ok: true };
+      },
+    });
+
+    await app.start();
+    await axios.get(`http://localhost:${app.getServerPort()}/logger-test`);
+    await app.stop();
+
+    const appLogContents = readFileSync(appLogPath, 'utf8');
+    const httpLogContents = readFileSync(httpLogPath, 'utf8');
+
+    expect(appLogContents).toContain('app-log-works');
+    expect(httpLogContents).toContain('GET /logger-test');
+    expect(appLogContents).not.toContain('GET /logger-test');
+    expect(httpLogContents).not.toContain('app-log-works');
+  } finally {
+    envs.isTest = prevIsTest;
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});

src/examples/bare-http.ts

@@ -1,7 +1,15 @@
-import { BareHttp } from '../index.js';
+import { BareHttp, logMe } from '../index.js';
 
 const app = new BareHttp({
-  logging: false,
+  logging: true,
+  requestTimeFormat: 'ms',
+  logger: {
+    console: true,
+    pretty: true,
+    level: 'trace',
+    app: { file: './logs/example-app.log', level: 'trace' },
+    http: { file: './logs/example-http.log', level: 'trace' },
+  },
   enableSchemaValidation: false,
   declaredRoutesPaths: ['examples/bare-http'],
 });
@@ -51,6 +59,7 @@ app.route.get({
     // if (flow.remoteIp) {
     //   return { special: 'return' };
     // }
+    logMe.info('Handling /route GET request');
     return returning;
     // flow.send(returning);
   },

src/index.ts

@@ -2,4 +2,5 @@ export { BareHttp } from './server.js';
 export type { BareHttpType } from './server.js';
 export type { BareRequest } from './request.js';
 export { context } from './context/index.js';
-export { logMe } from './logger/index.js';
+export { configureLogger, logMe } from './logger/index.js';
+export type { LoggerConfig } from './logger/index.js';

src/logger/index.ts

@@ -1,21 +1,130 @@
-import pino, { destination } from 'pino';
+import pino, {
+  destination,
+  type LevelWithSilent,
+  type Logger as PinoLogger,
+  type LoggerOptions as PinoLoggerOptions,
+} from 'pino';
 
-import { serializeLog, serializeHttp } from './serializers.js';
+import { mkdirSync } from 'fs';
+import { dirname } from 'path';
 
+import { serializeLog, serializeHttp } from './serializers.js';
 import { envs } from '../env.js';
 
-const asyncDest = envs.isProd ? [destination({ sync: false })] : [];
+type LoggerFileConfig = {
+  path: string;
+  sync?: boolean;
+};
+
+type LoggerTargetConfig = {
+  file?: string | LoggerFileConfig;
+  level?: LevelWithSilent;
+};
+
+export type LoggerConfig = {
+  console?: boolean;
+  pretty?: boolean;
+  level?: LevelWithSilent;
+  app?: LoggerTargetConfig;
+  http?: LoggerTargetConfig;
+};
 
-const pinoCommonOptions = {
+const defaultPretty = !envs.isProd;
+const defaultFileSync = envs.isProd ? false : true;
+
+const pinoCommonOptions: PinoLoggerOptions = {
   timestamp: () => `,"time":"${new Date()[envs.isProd ? 'toISOString' : 'toLocaleTimeString']()}"`,
   formatters: {
     level: (label: string) => ({ level: label }),
   },
   messageKey: 'message',
-  transport: envs.isProd ? undefined : { target: 'pino-pretty', options: { colorize: true } },
 };
 
-const logger = pino(pinoCommonOptions, asyncDest[0]);
+const normalizeFileConfig = (file?: string | LoggerFileConfig) => {
+  if (!file) return undefined;
+  if (typeof file === 'string') return { path: file, sync: defaultFileSync };
+  return { path: file.path, sync: file.sync ?? defaultFileSync };
+};
+
+const ensureLogDir = (filePath: string) => {
+  const dir = dirname(filePath);
+  if (dir && dir !== '.') {
+    mkdirSync(dir, { recursive: true });
+  }
+};
+
+const buildLogger = (config: LoggerConfig, target?: LoggerTargetConfig): PinoLogger => {
+  const consoleEnabled = config.console ?? true;
+  const prettyEnabled = config.pretty ?? defaultPretty;
+  const fileConfig = normalizeFileConfig(target?.file);
+  const level = target?.level ?? config.level;
+
+  const options: PinoLoggerOptions = { ...pinoCommonOptions };
+  if (level) options.level = level;
+
+  if (consoleEnabled && !prettyEnabled && !fileConfig) {
+    const stream = envs.isProd ? destination({ sync: false }) : undefined;
+    return pino(options, stream);
+  }
+
+  if (!consoleEnabled && fileConfig) {
+    ensureLogDir(fileConfig.path);
+    return pino(
+      options,
+      destination({ dest: fileConfig.path, sync: fileConfig.sync ?? defaultFileSync }),
+    );
+  }
+
+  const targets: Array<{
+    target: string;
+    level?: LevelWithSilent;
+    options?: Record<string, unknown>;
+  }> = [];
+
+  if (consoleEnabled) {
+    if (prettyEnabled) {
+      targets.push({ target: 'pino-pretty', level, options: { colorize: true } });
+    } else {
+      targets.push({ target: 'pino/file', level, options: { destination: 1 } });
+    }
+  }
+
+  if (fileConfig) {
+    ensureLogDir(fileConfig.path);
+    targets.push({
+      target: 'pino/file',
+      level,
+      options: {
+        destination: fileConfig.path,
+        mkdir: true,
+        sync: fileConfig.sync ?? defaultFileSync,
+      },
+    });
+  }
+
+  if (targets.length === 0) {
+    return pino({ ...options, level: 'silent' });
+  }
+
+  const transport = pino.transport({ targets });
+  return pino(options, transport);
+};
+
+let appLogger: PinoLogger;
+let httpLogger: PinoLogger;
+
+export const configureLogger = (config: LoggerConfig = {}) => {
+  if (config.app || config.http) {
+    appLogger = buildLogger(config, config.app);
+    httpLogger = buildLogger(config, config.http);
+  } else {
+    const shared = buildLogger(config);
+    appLogger = shared;
+    httpLogger = shared;
+  }
+};
+
+configureLogger();
 
 interface LogMeFn {
   (obj: unknown, ...args: []): void;
@@ -33,15 +142,15 @@ type LogMe = {
 
 export const logHttp = (...params: Parameters<typeof serializeHttp>) => {
   const { level, logObject } = serializeHttp(...params);
-  logger[level](logObject);
+  httpLogger[level](logObject);
 };
 
 // TODO: remove the test condition
 export const logMe: LogMe = {
-  debug: (...args) => !envs.isTest && logger.debug(serializeLog(...args)),
-  info: (...args) => !envs.isTest && logger.info(serializeLog(...args)),
-  warn: (...args) => !envs.isTest && logger.warn(serializeLog(...args)),
-  error: (...args) => !envs.isTest && logger.error(serializeLog(...args)),
-  fatal: (...args) => !envs.isTest && logger.fatal(serializeLog(...args)),
-  trace: (...args) => !envs.isTest && logger.trace(serializeLog(...args)),
+  debug: (...args) => !envs.isTest && appLogger.debug(serializeLog(...args)),
+  info: (...args) => !envs.isTest && appLogger.info(serializeLog(...args)),
+  warn: (...args) => !envs.isTest && appLogger.warn(serializeLog(...args)),
+  error: (...args) => !envs.isTest && appLogger.error(serializeLog(...args)),
+  fatal: (...args) => !envs.isTest && appLogger.fatal(serializeLog(...args)),
+  trace: (...args) => !envs.isTest && appLogger.trace(serializeLog(...args)),
 };

src/server.ts

@@ -3,7 +3,8 @@ import { ServerOptions } from 'ws';
 import { Ajv, ValidateFunction } from 'ajv';
 
 import { BareRequest, CacheOpts } from './request.js';
-import { logMe } from './logger/index.js';
+import { configureLogger, logMe } from './logger/index.js';
+import type { LoggerConfig } from './logger/index.js';
 import { context, enableContext, newContext } from './context/index.js';
 import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager.js';
 import {
@@ -77,6 +78,10 @@ type BareOptions<A extends IP> = {
    * Default `false`
    */
   logging?: boolean;
+  /**
+   * Logger configuration. Controls outputs for app and http logs.
+   */
+  logger?: LoggerConfig;
   errorHandlerMiddleware?: ErrorHandler;
   /**
    * Request time format in `seconds` or `milliseconds`
@@ -213,6 +218,8 @@ export class BareServer<A extends IP> {
   private applyLaunchOptions = () => {
     const { bareOptions: bo } = this;
 
+    if (bo.logger) configureLogger(bo.logger);
+
     if (bo.setRandomPort) {
       this.#port = undefined as any;
     } else {