feat: prevent objects with serializers from being trimmed

package.json

@@ -36,9 +36,9 @@
     "test:ci": "skuba test --coverage"
   },
   "dependencies": {
-    "dtrim": "^1.9.0",
+    "dtrim": "^1.11.0",
     "pino": "^8.0.0",
-    "pino-std-serializers": "^6.0.0"
+    "pino-std-serializers": "^6.2.0"
   },
   "devDependencies": {
     "@types/split2": "3.2.1",

src/formatters/index.ts

@@ -1,5 +1,5 @@
 import { trimmer } from 'dtrim';
-import pino from 'pino';
+import pino, { LoggerOptions } from 'pino';
 
 export interface FormatterOptions {
   /**
@@ -14,9 +14,12 @@ export interface FormatterOptions {
 }
 
 export const createFormatters = (
-  opts: FormatterOptions,
+  opts: FormatterOptions & Pick<LoggerOptions, 'serializers'>,
 ): pino.LoggerOptions['formatters'] => {
-  const trim = trimmer({ depth: opts.maxObjectDepth ?? 4 });
+  const trim = trimmer({
+    depth: opts.maxObjectDepth ?? 4,
+    retain: new Set(Object.keys(opts.serializers ?? {})),
+  });
 
   return {
     log: (input) => trim(input) as typeof input,

src/index.test.ts

@@ -147,39 +147,39 @@ testLog(
 
 testLog(
   'should truncate objects deeper than the default depth of 4 levels',
-  { req: { url: { c: { d: { e: { f: { g: {} } } } } } } },
-  { req: { url: { c: { d: '[Object]' } } } },
+  { foo: { url: { c: { d: { e: { f: { g: {} } } } } } } },
+  { foo: { url: { c: { d: '[Object]' } } } },
 );
 
 testLog(
   'should truncate objects deeper than the configured object depth',
-  { req: { url: { c: { d: { e: { f: { g: {} } } } } } } },
-  { req: { url: { c: { d: { e: '[Object]' } } } } },
+  { foo: { url: { c: { d: { e: { f: { g: {} } } } } } } },
+  { foo: { url: { c: { d: { e: '[Object]' } } } } },
   undefined,
   { maxObjectDepth: 5 },
 );
 
 testLog(
   'should truncate Buffers',
   {
-    res: {
+    foo: {
       statusCode: Buffer.from('aaa'),
     },
   },
-  { res: { statusCode: 'Buffer(3)' } },
+  { foo: { statusCode: 'Buffer(3)' } },
 );
 
 testLog(
   'should truncate strings longer than 512 characters',
-  { req: { url: 'a'.repeat(555) } },
-  { req: { url: `${'a'.repeat(512)}...` } },
+  { foo: { url: 'a'.repeat(555) } },
+  { foo: { url: `${'a'.repeat(512)}...` } },
 );
 
 testLog(
   'should truncate arrays containing more than 64 items',
-  { err: { message: 'a'.repeat(64 + 10).split('') } },
+  { foo: { message: 'a'.repeat(64 + 10).split('') } },
   {
-    err: {
+    foo: {
       message: 'Array(74)',
     },
   },
@@ -322,7 +322,10 @@ testLog(
       request: {
         _options: {
           method: 'get',
-          headers: '[Object]',
+          headers: {
+            Accept: 'application/json, text/plain, */*',
+            authorization: '[Redacted]',
+          },
         },
       },
     },
@@ -502,3 +505,56 @@ test('should log customized timestamp if timestamp logger option is supplied', a
 
   expect(log.timestamp).toBe(mockTimestamp);
 });
+
+class Req {
+  get socket() {
+    return {
+      remoteAddress: 'localhost',
+      remotePort: '4000',
+    };
+  }
+}
+testLog(
+  'should not truncate objects with a serializer',
+  {
+    errWithCause: {
+      a: {
+        b: {},
+      },
+    },
+    err: {
+      a: {
+        b: {},
+      },
+    },
+    req: new Req(),
+    notSerialized: {
+      a: {
+        b: {},
+      },
+    },
+  },
+  {
+    errWithCause: {
+      a: {
+        b: {},
+      },
+    },
+    err: {
+      a: {
+        b: {},
+      },
+    },
+    req: {
+      remoteAddress: 'localhost',
+      remotePort: '4000',
+    },
+    notSerialized: {
+      a: '[Object]',
+    },
+  },
+  'info',
+  {
+    maxObjectDepth: 2,
+  },
+);

src/index.ts

@@ -24,13 +24,12 @@ export default (
     sync: true,
   }),
 ): Logger => {
-  const formatters = createFormatters(opts);
-
   opts.redact = redact.addDefaultRedactPathStrings(opts.redact);
   opts.serializers = {
     ...serializers,
     ...opts.serializers,
   };
+  const formatters = createFormatters(opts);
   opts.base = {
     ...base,
     ...opts.base,

src/serializers/index.test.ts

@@ -122,3 +122,14 @@ describe('res', () => {
     });
   });
 });
+
+describe('serializers', () => {
+  test('it exports only err, errWithCause, req, res', () => {
+    expect(serializers).toStrictEqual({
+      err: expect.any(Function),
+      errWithCause: expect.any(Function),
+      req: expect.any(Function),
+      res: expect.any(Function),
+    });
+  });
+});

src/serializers/index.ts

@@ -1,4 +1,4 @@
-import stdSerializers from 'pino-std-serializers';
+import { err, errWithCause } from 'pino-std-serializers';
 
 interface Socket {
   remoteAddress?: string;
@@ -46,7 +46,8 @@ const res = (response: Response) =>
     : response;
 
 export default {
-  ...stdSerializers,
+  err,
+  errWithCause,
   res,
   req,
 };