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

sckv · sckv · commit 058bb940cd9c · 2025-12-26T14:08:27.000+01:00
diff --git a/README.md b/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`. Use `sourceMaps: true` to map log locations back to `.ts` files (requires source maps in your build).
+
 #### `ws?` (Boolean)
 
 Default `false`
diff --git a/package.json b/package.json
@@ -53,6 +53,7 @@
     "lodash": "^4.17.21",
     "pino": "^10.1.0",
     "pino-pretty": "^13.1.3",
+    "source-map-support": "^0.5.21",
     "ts-morph": "^27.0.2",
     "ws": "^8.18.3"
   },
diff --git a/src/__tests__/logger/output.test.ts b/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 });
+  }
+});
diff --git a/src/examples/bare-http.ts b/src/examples/bare-http.ts
@@ -1,7 +1,16 @@
-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,
+    sourceMaps: 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 +60,7 @@ app.route.get({
     // if (flow.remoteIp) {
     //   return { special: 'return' };
     // }
+    logMe.info('Handling /route GET request');
     return returning;
     // flow.send(returning);
   },
@@ -105,6 +115,7 @@ app
       route: '/runtime_route',
       options: { timeout: 2000 },
       handler: async () => {
+        logMe.info('Handling /runtime_route GET request');
         return 'JUST MESSAGE 2';
       },
     });
diff --git a/src/index.ts b/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';
diff --git a/src/logger/index.ts b/src/logger/index.ts
@@ -1,21 +1,184 @@
-import pino, { destination } from 'pino';
+import pino, {
+  destination,
+  type LevelWithSilent,
+  type Logger as PinoLogger,
+  type LoggerOptions as PinoLoggerOptions,
+} from 'pino';
 
+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;
+};
 
-const pinoCommonOptions = {
+type LoggerTargetConfig = {
+  file?: string | LoggerFileConfig;
+  level?: LevelWithSilent;
+};
+
+export type LoggerConfig = {
+  console?: boolean;
+  pretty?: boolean;
+  level?: LevelWithSilent;
+  app?: LoggerTargetConfig;
+  http?: LoggerTargetConfig;
+  sourceMaps?: boolean;
+};
+
+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]);
+type LoggerLike = Record<LevelWithSilent, (...args: any[]) => void>;
+
+const noop = () => {};
+const noopLogger: LoggerLike = {
+  trace: noop,
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop,
+  fatal: noop,
+  silent: noop,
+};
+
+let sourceMapsRegistered = false;
+
+const enableSourceMaps = (enabled?: boolean) => {
+  if (!enabled || sourceMapsRegistered) return;
+  sourceMapsRegistered = true;
+  void import('source-map-support/register').catch(() => {
+    sourceMapsRegistered = false;
+  });
+};
+
+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 toLoggerLike = (logger: PinoLogger): LoggerLike => {
+  const call =
+    (method: keyof LoggerLike) =>
+    (...args: any[]) =>
+      (logger as any)[method](...args);
+
+  return {
+    trace: call('trace'),
+    debug: call('debug'),
+    info: call('info'),
+    warn: call('warn'),
+    error: call('error'),
+    fatal: call('fatal'),
+    silent: noop,
+  };
+};
+
+const buildConsoleLogger = (options: PinoLoggerOptions, prettyEnabled: boolean) => {
+  if (prettyEnabled) {
+    try {
+      const transport = pino.transport({
+        targets: [{ target: 'pino-pretty', options: { colorize: true } }],
+      });
+      return toLoggerLike(pino(options, transport));
+    } catch {
+      return toLoggerLike(pino(options, destination({ dest: 1, sync: false })));
+    }
+  }
+  return toLoggerLike(pino(options, destination({ dest: 1, sync: false })));
+};
+
+const buildFileLogger = (options: PinoLoggerOptions, fileConfig: LoggerFileConfig) => {
+  ensureLogDir(fileConfig.path);
+  return toLoggerLike(
+    pino(options, destination({ dest: fileConfig.path, sync: fileConfig.sync ?? defaultFileSync })),
+  );
+};
+
+const combineLoggers = (primary?: LoggerLike, secondary?: LoggerLike): LoggerLike => {
+  if (!primary && !secondary) return noopLogger;
+  const first = primary ?? noopLogger;
+  const second = secondary ?? noopLogger;
+  return {
+    trace: (...args) => {
+      first.trace(...args);
+      second.trace(...args);
+    },
+    debug: (...args) => {
+      first.debug(...args);
+      second.debug(...args);
+    },
+    info: (...args) => {
+      first.info(...args);
+      second.info(...args);
+    },
+    warn: (...args) => {
+      first.warn(...args);
+      second.warn(...args);
+    },
+    error: (...args) => {
+      first.error(...args);
+      second.error(...args);
+    },
+    fatal: (...args) => {
+      first.fatal(...args);
+      second.fatal(...args);
+    },
+    silent: noop,
+  };
+};
+
+const buildLogger = (config: LoggerConfig, target?: LoggerTargetConfig): LoggerLike => {
+  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;
+
+  const consoleLogger = consoleEnabled ? buildConsoleLogger(options, prettyEnabled) : undefined;
+  const fileLogger = fileConfig ? buildFileLogger(options, fileConfig) : undefined;
+
+  return combineLoggers(consoleLogger, fileLogger);
+};
+
+let appLogger: LoggerLike;
+let httpLogger: LoggerLike;
+
+export const configureLogger = (config: LoggerConfig = {}) => {
+  enableSourceMaps(config.sourceMaps);
+
+  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 +196,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)),
 };
diff --git a/src/server.ts b/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 {
diff --git a/tsconfig.dev.json b/tsconfig.dev.json
@@ -1,7 +1,9 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "./dev-lib"
+    "outDir": "./dev-lib",
+    "sourceMap": true,
+    "inlineSources": true
   },
   "exclude": ["**/__tests__/**"]
 }
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
`1`	`1`	`{`
`2`	`2`	`"extends": "./tsconfig.json",`
`3`	`3`	`"compilerOptions": {`
`4`		`- "outDir": "./dev-lib"`
	`4`	`+ "outDir": "./dev-lib",`
	`5`	`+ "sourceMap": true,`
	`6`	`+ "inlineSources": true`
`5`	`7`	`},`
`6`	`8`	`"exclude": ["/__tests__/"]`
`7`	`9`	`}`