@react-foundry/fastify-dev-logger 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (C) 2019-2025 Crown Copyright
+Copyright (C) 2019-2026 Daniel A.C. Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+React Foundry - Fastify Dev Logger
+==================================
+
+A Pino transport for pretty printing [Fastify] logs in **dev** environments.
+Built on [pino-pretty].
+
+The output looks like this (but with colours):
+
+```
+[16:56:26.501]  info      | Server listening at http://[::1]:5173
+[16:56:34.020]  info (01) | GET / - incoming request
+[16:56:48.565]  info (01) | GET / - request completed; 200 OK (64ms)
+```
+
+**Note:** It should be possible to use this in [pino] without Fastify, but we
+provide extra features for handling Fastify's (request) objects.
+
+
+Using this package
+------------------
+
+First install the package into your project:
+
+```shell
+npm install -D @react-foundry/fastify-dev-logger
+```
+
+Then use it in your code as follows:
+
+```js
+import fastifyDevLogger from '@react-foundry/fastify-dev-logger';
+import Fastify from 'fastify';
+
+const httpd = Fastify({
+  logger: {
+    transport: {
+      target: '@react-foundry/fastify-dev-logger'
+    }
+  }
+});
+
+[...]
+```
+
+
+Working on this package
+-----------------------
+
+Before working on this package you must install its dependencies using
+the following command:
+
+```shell
+pnpm install
+```
+
+### Testing
+
+Test the package by running the unit tests.
+
+```shell
+npm test
+```
+
+
+[Fastify]: https://fastify.dev/
+[pino]: https://getpino.io/
+[pino-pretty]: https://www.npmjs.com/package/pino-pretty

package/jest.config.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+const baseConfig = require('../../jest.config.base');
+
+const config = {
+  ...baseConfig,
+  collectCoverageFrom: [
+    '<rootDir>/src/**.js',
+  ],
+  testMatch: [
+    '<rootDir>/spec/**.js'
+  ]
+};
+
+module.exports = config;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@react-foundry/fastify-dev-logger",
+  "version": "0.1.0",
+  "description": "A Pino transport for pretty printing Fastify logs in dev environments.",
+  "type": "module",
+  "main": "src/index.js",
+  "typings": "src/index.d.ts",
+  "author": "Daniel A.C. Martin <npm@daniel-martin.co.uk> (http://daniel-martin.co.uk/)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "jest": "30.2.0",
+    "jest-environment-jsdom": "30.2.0",
+    "pino": "10.3.0",
+    "ts-jest": "29.4.6"
+  },
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build": "true",
+    "clean": "true"
+  }
+}

package/spec/index.js

@@ -0,0 +1,115 @@
+import pino from 'pino';
+import { Transform, Writable } from 'node:stream';
+import { fastifyDevLogger } from '../src/index.js';
+
+// See: https://github.com/chalk/ansi-regex/blob/94983fc6ba00e1e9657f72c07eb7b9c75e4011a2/index.js
+const controlCodesRegex = /(?:\u001B\][\s\S]*?(?:\u0007|\u001B\u005C|\u009C))|[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]/g;
+const stripColours = (str) => str.replace(controlCodesRegex, '');
+
+describe('fastifyDevLogger', () => {
+  it('is a function', () => expect(fastifyDevLogger).toBeInstanceOf(Function));
+  it('that takes one parameter', () => expect(fastifyDevLogger).toHaveLength(1));
+
+  describe('when given minimal options', () => {
+    let output = [];
+    const captureStream = new Writable({
+      write(chunk, _enc, cb) {
+        output.push(
+          stripColours(chunk.toString())
+            .replace(/\n$/, '')
+        );
+        cb();
+      },
+    });
+    const options = {
+      sync: true,
+      destination: captureStream
+    };
+    const result = fastifyDevLogger(options);
+
+    it('returns a Transform object', () => expect(result).toBeInstanceOf(Transform));
+
+    describe('the Transform', () => {
+      describe('when run in pino', () => {
+        const pinoOptions = {
+          level: 'trace'
+        };
+        const logger = pino(pinoOptions, result);
+        const timePattern = '\\[[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{3}\\]';
+        const timeRegex = new RegExp(timePattern);
+
+        describe('when logging a string', () => {
+          beforeAll(() => {
+            output = [];
+            logger.warn('My message');
+          });
+
+          it('writes only once', () => expect(output.length).toEqual(1));
+          it('outputs the message', () => expect(output[0]).toContain('My message'));
+          it('outputs the log level', () => expect(output[0]).toContain('warn'));
+          it('outputs the time', () => expect(output[0]).toMatch(timeRegex));
+          it('outputs in the correct format', () => expect(output[0]).toMatch(new RegExp(
+            `^${timePattern}  warn      \\| My message$`
+          )));
+        });
+
+        describe('when logging an error', () => {
+          beforeAll(() => {
+            output = [];
+            logger.error(new Error('My error message'));
+          });
+
+          it('writes only once', () => expect(output.length).toEqual(1));
+          it('outputs the message', () => expect(output[0]).toContain('My error message'));
+          it('outputs log level', () => expect(output[0]).toContain('error'));
+          it('outputs the time', () => expect(output[0]).toMatch(timeRegex));
+          it('outputs in the correct format', () => expect(output[0]).toMatch(new RegExp(
+            `^${timePattern} error      \\| Error: My error message\n\\s*at `,
+            'ms'
+          )));
+        });
+
+        describe('when logging an object', () => {
+          beforeAll(() => {
+            output = [];
+            logger.debug({ my: 'object' });
+          });
+
+          it('writes only once', () => expect(output.length).toEqual(1));
+          it('outputs the object', () => expect(output[0]).toContain('{ my: \'object\' }'));
+          it('outputs log level', () => expect(output[0]).toContain('debug'));
+          it('outputs the time', () => expect(output[0]).toMatch(timeRegex));
+          it('outputs in the correct format', () => expect(output[0]).toMatch(new RegExp(
+            `^${timePattern} debug      \\| { my: 'object' }$`
+          )));
+        });
+
+        describe('when logging a request', () => {
+          beforeAll(() => {
+            output = [];
+            logger.info({
+              reqId: 'req-c3',
+              req: {
+                method: 'GET',
+                url: '/path/to/resource'
+              },
+              res: {
+                statusCode: 200
+              },
+              responseTime: 1066,
+              msg: 'request completed'
+            });
+          });
+
+          it('writes only once', () => expect(output.length).toEqual(1));
+          it('outputs the message', () => expect(output[0]).toContain('request completed'));
+          it('outputs log level', () => expect(output[0]).toContain('info'));
+          it('outputs the time', () => expect(output[0]).toMatch(timeRegex));
+          it('outputs in the correct format', () => expect(output[0]).toMatch(new RegExp(
+            `^${timePattern}  info \\(C3\\) \\| GET /path/to/resource - request completed; 200 OK \\(1066ms\\)$`
+          )));
+        });
+      });
+    });
+  });
+});

package/src/index.d.ts

@@ -0,0 +1,8 @@
+import type { PrettyOptions, PrettyStream } from 'pino-pretty';
+
+export type FastifyDevLoggerOptions = Pick<PrettyOptions, 'append', 'destination', 'minimumLevel', 'mkdir', 'sync'> & {
+};
+
+declare export const fastifyDevLogger: (a: FastifyDevLoggerOptions) => PrettyStream;
+
+export default fastifyDevLogger;

package/src/index.js

@@ -0,0 +1,249 @@
+import { inspect } from 'node:util';
+import pretty from 'pino-pretty';
+
+const formatNumber = (width, number) => (
+  number.toString().padStart(width, '0')
+);
+
+export const fastifyDevLogger = ({
+  ...prettyOptions
+}) => {
+  const colourise = pretty.colorizerFactory(true);
+  const colourMessage = colourise.message;
+  const greyMessage = colourise.greyMessage;
+  const redMessage = colourise.colors.red;
+  const amberMessage = colourise.colors.yellow;
+  const greenMessage = colourise.colors.green;
+  const space = ' ';
+  const colourLevel = (level) => (
+    space.repeat(5 - level.length) +
+      colourise(level)
+      .toLowerCase()
+  );
+  const levelName = {
+    10: colourLevel('trace'),
+    20: colourLevel('debug'),
+    30: colourLevel('info'),
+    40: colourLevel('warn'),
+    50: colourLevel('error'),
+    60: colourLevel('fatal')
+  };
+  const statusName = {
+    100: colourMessage('100 Continue'),
+    101: colourMessage('101 Switching Protocols'),
+    102: colourMessage('102 Processing'),
+    103: colourMessage('103 Early Hints'),
+    200: greenMessage('200 OK'),
+    201: greenMessage('201 Created'),
+    202: greenMessage('202 Accepted'),
+    203: greenMessage('203 Non-Authoritative Information'),
+    204: greenMessage('204 No Content'),
+    205: greenMessage('205 Reset Content'),
+    206: greenMessage('206 Partial Content'),
+    207: greenMessage('207 Multi-Status'),
+    208: greenMessage('208 Already Reported'),
+    226: greenMessage('226 IM Used'),
+    300: colourMessage('300 Multiple Choices'),
+    301: colourMessage('301 Moved Permanently'),
+    302: colourMessage('302 Found'),
+    303: colourMessage('303 See Other'),
+    304: colourMessage('304 Not Modified'),
+    305: colourMessage('305 Use Proxy'),
+    306: colourMessage('306 unused'),
+    307: colourMessage('307 Temporary Redirect'),
+    308: colourMessage('308 Permanent Redirect'),
+    400: amberMessage('400 Bad Request'),
+    401: amberMessage('401 Unauthorised'),
+    402: amberMessage('402 Payment Required'),
+    403: amberMessage('403 Forbidden'),
+    404: amberMessage('404 Not Found'),
+    405: amberMessage('405 Method Not Allowed'),
+    406: amberMessage('406 Not Acceptable'),
+    407: amberMessage('407 Proxy Authentication Required'),
+    408: amberMessage('408 Request Timeout'),
+    409: amberMessage('409 Conflict'),
+    410: amberMessage('410 Gone'),
+    411: amberMessage('411 Length Required'),
+    412: amberMessage('412 Precondition Failed'),
+    413: amberMessage('413 Content Too Large'),
+    414: amberMessage('414 URI Too Long'),
+    415: amberMessage('415 Unsupported Media Type'),
+    416: amberMessage('416 Range Not Satisfiable'),
+    417: amberMessage('417 Expectation Failed'),
+    418: amberMessage('418 I am a teapot'),
+    421: amberMessage('421 Misdirected Request'),
+    422: amberMessage('422 Unprocessable Content'),
+    423: amberMessage('423 Locked'),
+    424: amberMessage('424 Failed Dependency'),
+    425: amberMessage('425 Too Early'),
+    426: amberMessage('426 Upgrade Required'),
+    428: amberMessage('428 Precondition Required'),
+    429: amberMessage('429 Too Many Requests'),
+    431: amberMessage('431 Request Header Fields Too Large'),
+    451: amberMessage('451 Unavailable For Legal Reasons'),
+    500: redMessage('500 Internal Server Error'),
+    501: redMessage('501 Not Implemented'),
+    502: redMessage('502 Bad Gateway'),
+    503: redMessage('503 Service Unavailable'),
+    504: redMessage('504 Gateway Timeout'),
+    505: redMessage('505 HTTP Version Not Supported'),
+    506: redMessage('506 Variant Also Negotiates'),
+    507: redMessage('507 Insufficient Storage'),
+    508: redMessage('508 Loop Detected'),
+    510: redMessage('510 Not Extended'),
+    511: redMessage('511 Network Authentication Required')
+  };
+  const reqContext = {};
+
+  const messageFormat = (log, messageKey, _levelLabel, { colors }) => {
+    const {
+      level: _level,
+      time: _time,
+      pid,
+      hostname,
+      reqId,
+      ...obj
+    } = log;
+    const {
+      err,
+      req,
+      res,
+      responseTime: _responseTime,
+      [messageKey]: msg,
+    } = log;
+
+    if (reqId && req && !err) {
+      // Create new context
+      reqContext[reqId] = req;
+    }
+
+    const ctx = (
+      reqId
+        ? reqContext[reqId]
+        : req
+    );
+
+    // Suppress noise in dev environment
+    const url = ctx?.url || '';
+    const fileRequest = url && (url.startsWith('/@') || url.match(/^\/(app|src|node_modules)\/.*\.[^\.\/]+$/));
+    const standardMsg = msg === 'incoming request' || msg === 'request completed';
+    const unhealthyResponse = res?.statusCode >= 400;
+
+    if (fileRequest && standardMsg && !unhealthyResponse) {
+      return undefined;
+    }
+
+    const datetime = new Date(_time);
+    const HH = formatNumber(2, datetime.getHours());
+    const mm = formatNumber(2, datetime.getMinutes());
+    const ss = formatNumber(2, datetime.getSeconds());
+    const mmm = formatNumber(3, datetime.getMilliseconds());
+
+    const time = greyMessage(`[${HH}:${mm}:${ss}.${mmm}]`);
+    const level = levelName[_level] || '?????';
+    const request = (
+      reqId
+        ? greyMessage(` (${reqId.substring(4).substring(-2).padStart(2, '0').toUpperCase()})`)
+        : '     '
+    );
+    const sep1 = greyMessage(' | ');
+    const sep2 = greyMessage(' - ');
+    const http = (
+      ctx
+        ? colourMessage(`${ctx.method} ${ctx.url}`)
+        : ''
+    );
+
+    const indent = space.repeat(25) + sep1;
+    const breakLength = 52; // Magic constants as colours make it hard to count characters
+    const message = (
+      err
+        ? (
+          err.stack
+            .split('\n')
+            .map((v, i) => (
+              i === 0
+                ? redMessage(`${err.type}: `) + err.message
+                : greyMessage(v)
+            ))
+            .join('\n')
+        )
+        : msg || inspect(obj, { breakLength }).replace(/\n/g, '\n' + indent)
+    );
+    const status = (
+      res?.statusCode && !err
+        ? greyMessage('; ') + colourMessage(`${statusName[res.statusCode] || res.statusCode}`)
+        : ''
+    );
+    const round = (num) => num.toPrecision(3);
+    const responseTimeSeconds = round(_responseTime / 1000) + 's';
+    const responseTime = (
+      _responseTime
+        ? (
+          _responseTime < 1
+            ? greyMessage(_responseTime.toFixed(2) + 'ms')
+            : (
+              _responseTime < 1000
+                ? greyMessage(round(_responseTime) + 'ms')
+                : (
+                  _responseTime < 3000
+                    ? colourMessage(responseTimeSeconds)
+                    : (
+                      _responseTime < 25000
+                        ? amberMessage(responseTimeSeconds)
+                        : redMessage(responseTimeSeconds)
+                    )
+                )
+            )
+        )
+        : ''
+    );
+    const _contentLength = res?.contentLength;
+    const contentLength = (
+      _contentLength
+        ?
+        (
+          _contentLength >= 1000000
+            ? colourMessage(round(_contentLength / 1000000) + 'MB')
+            : (
+              _contentLength >= 1000
+                ? greyMessage(round(_contentLength / 1000) + 'kB')
+                : greyMessage(_contentLength)
+            )
+        )
+        : ''
+    );
+    const responseInfo = (
+      responseTime
+        ? (
+          greyMessage(' (') + responseTime + (
+            contentLength
+              ? greyMessage(', ') + contentLength
+              : ''
+          ) + greyMessage(')')
+        )
+        : ''
+    );
+
+    if (reqId && res && !err) {
+      // Request is finished; clean up the context
+      delete reqContext[reqId];
+    }
+
+    return `\r${time} ${level}${request}${sep1}` + (
+      http
+        ? `${http}${sep2}${message}${status}${responseInfo}`
+        : message
+    );
+  };
+
+  return pretty({
+    ...prettyOptions,
+    messageFormat,
+    include: '',
+    hideObject: true,
+    colorize: false
+  });
+};
+
+export default fastifyDevLogger;