@contrast/agent-bundle 5.46.0 → 5.48.0

package/node_modules/pino/test/transport/uses-pino-config.test.js

@@ -1,11 +1,13 @@
 'use strict'
 
-const os = require('os')
-const { join } = require('path')
-const { readFile } = require('fs').promises
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { join } = require('node:path')
+const { readFile } = require('node:fs').promises
 const writeStream = require('flush-write-stream')
+
 const { watchFileCreated, file } = require('../helper')
-const { test } = require('tap')
 const pino = require('../../')
 
 const { pid } = process
@@ -23,8 +25,7 @@ function parseLogs (buffer) {
   return JSON.parse(`[${buffer.toString().replace(/}{/g, '},{')}]`)
 }
 
-test('transport uses pino config', async ({ same, teardown, plan }) => {
-  plan(1)
+test('transport uses pino config', async (t) => {
   const destination = file()
   const transport = pino.transport({
     pipeline: [{
@@ -34,7 +35,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino({
     messageKey: 'customMessageKey',
     errorKey: 'customErrorKey',
@@ -47,7 +48,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'custom',
     body: 'foo',
     attributes: {
@@ -65,8 +66,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
   }])
 })
 
-test('transport uses pino config without customizations', async ({ same, teardown, plan }) => {
-  plan(1)
+test('transport uses pino config without customizations', async (t) => {
   const destination = file()
   const transport = pino.transport({
     pipeline: [{
@@ -76,7 +76,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino(transport)
 
   const error = new Error('qux')
@@ -85,7 +85,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'info',
     body: 'baz',
     attributes: {
@@ -103,8 +103,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
   }])
 })
 
-test('transport uses pino config with multistream', async ({ same, teardown, plan }) => {
-  plan(2)
+test('transport uses pino config with multistream', async (t) => {
   const destination = file()
   const messages = []
   const stream = writeStream(function (data, enc, cb) {
@@ -121,7 +120,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino({
     messageKey: 'customMessageKey',
     errorKey: 'customErrorKey',
@@ -135,7 +134,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'custom',
     body: 'fizz',
     attributes: {
@@ -152,7 +151,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
     error: serializedError
   }])
 
-  same(messages, [{
+  assert.deepEqual(messages, [{
     level: 35,
     pid,
     hostname,

package/node_modules/pino/test/transport-stream.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const test = require('node:test')
+const proxyquire = require('proxyquire')
+const tspl = require('@matteo.collina/tspl')
+
+test('should import', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const mockRealRequire = (target) => {
+    return {
+      default: {
+        default: () => {
+          plan.equal(target, 'pino-pretty')
+          return Promise.resolve()
+        }
+      }
+    }
+  }
+  const mockRealImport = async () => {
+    await Promise.resolve()
+    throw Object.assign(new Error(), { code: 'ERR_MODULE_NOT_FOUND' })
+  }
+
+  const loadTransportStreamBuilder = proxyquire(
+    '../lib/transport-stream.js',
+    {
+      'real-require': {
+        realRequire: mockRealRequire,
+        realImport: mockRealImport
+      }
+    }
+  )
+
+  const fn = await loadTransportStreamBuilder('pino-pretty')
+
+  await fn()
+  plan.ok('returned promise resolved')
+
+  await plan
+})

package/node_modules/pino/test/types/{pino-import.test-d.ts → pino-import.test-d.cts}

@@ -1,8 +1,7 @@
 import { expectType } from "tsd";
 
-import pino from '../../pino';
-import { pino as pinoNamed, P } from "../../pino";
 import * as pinoStar from "../../pino";
+import { default as P, default as pino, pino as pinoNamed } from '../../pino';
 import pinoCjsImport = require ("../../pino");
 const pinoCjs = require("../../pino");
 const { P: pinoCjsNamed } = require('pino')
@@ -15,10 +14,12 @@ expectType<pino.Logger>(pinoNamed());
 expectType<P.Logger>(pinoNamed());
 expectType<pino.Logger>(pinoStar.default());
 expectType<pino.Logger>(pinoStar.pino());
-expectType<pino.Logger>(pinoCjsImport.default());
+// expectType<pino.Logger>(pinoCjsImport.default());
 expectType<pino.Logger>(pinoCjsImport.pino());
 expectType<any>(pinoCjsNamed());
 expectType<any>(pinoCjs());
+expectType<P.TimeFn>(pinoNamed.stdTimeFunctions.isoTimeNano)
+expectType<string>(pinoNamed.stdTimeFunctions.isoTimeNano())
 
 const levelChangeEventListener: P.LevelChangeEventListener = (
     lvl: P.LevelWithSilent | string,

package/node_modules/pino/test/types/pino-multistream.test-d.ts

@@ -1,6 +1,6 @@
 import { expectType } from 'tsd'
 
-import { createWriteStream } from 'fs'
+import { createWriteStream } from 'node:fs'
 
 import pino, { multistream } from '../../pino'
 

package/node_modules/pino/test/types/pino-top-export.test-d.ts

@@ -22,6 +22,7 @@ expectType<LevelMapping>(levels);
 expectType<MultiStreamRes>(multistream(process.stdout));
 expectType<SerializedError>(stdSerializers.err({} as any));
 expectType<string>(stdTimeFunctions.isoTime());
+expectType<string>(stdTimeFunctions.isoTimeNano());
 expectType<string>(version);
 
 // Can't test against `unique symbol`, see https://github.com/SamVerschueren/tsd/issues/49

package/node_modules/pino/test/types/pino-transport.test-d.ts

@@ -1,4 +1,4 @@
-import { pino } from '../../pino'
+import pino from '../../pino'
 import { expectType } from "tsd";
 
 // Single

package/node_modules/pino/test/types/pino-type-only.test-d.ts

@@ -1,7 +1,7 @@
 import { expectAssignable, expectType, expectNotAssignable } from "tsd";
 
 import pino from "../../";
-import type {LevelWithSilent, Logger, LogFn, P, DestinationStreamWithMetadata,  Level, LevelOrString, LevelWithSilentOrString, LoggerExtras } from "../../pino";
+import type {LevelWithSilent, Logger, LogFn, DestinationStreamWithMetadata,  Level, LevelOrString, LevelWithSilentOrString, LoggerExtras, LoggerOptions } from "../../pino";
 
 // NB: can also use `import * as pino`, but that form is callable as `pino()`
 // under `esModuleInterop: false` or `pino.default()` under `esModuleInterop: true`.
@@ -10,18 +10,13 @@ expectAssignable<LoggerExtras>(log);
 expectType<Logger>(log);
 expectType<LogFn>(log.info);
 
-expectType<P.Logger>(log);
-expectType<P.LogFn>(log.info);
-
 expectType<Parameters<typeof log.isLevelEnabled>>([log.level]);
 
 const level: Level = 'debug';
 expectAssignable<string>(level);
-expectAssignable<P.Level>(level);
 
 const levelWithSilent: LevelWithSilent = 'silent';
 expectAssignable<string>(levelWithSilent);
-expectAssignable<P.LevelWithSilent>(levelWithSilent);
 
 const levelOrString: LevelOrString = "myCustomLevel";
 expectAssignable<string>(levelOrString);
@@ -46,3 +41,26 @@ const needsMetadata: typeof pino.symbols.needsMetadataGsym = pino.symbols.needsM
 if (stream[needsMetadata]) {
     expectType<number>(stream.lastLevel);
 }
+
+const loggerOptions:LoggerOptions = {
+    browser: {
+        formatters: {
+            log(obj) {
+                return obj
+            },
+            level(label, number) {
+                return { label, number}
+            }
+
+        }
+    }
+}
+
+expectType<LoggerOptions>(loggerOptions)
+
+// Reference: https://github.com/pinojs/pino/issues/2285
+const someConst = "test" as const;
+pino().error({}, someConst);
+const someFunc = <T extends typeof someConst>(someConst: T) => {
+    pino().error({}, someConst);
+};

package/node_modules/pino/test/types/pino.test-d.ts

@@ -1,8 +1,9 @@
 import { IncomingMessage, ServerResponse } from "http";
+import { mock } from 'node:test'
 import { Socket } from "net";
 import { expectError, expectType } from 'tsd';
-import P, { pino } from "../../";
-import Logger = P.Logger;
+import pino, { LogFn, LoggerOptions } from "../../";
+import Logger = pino.Logger;
 
 const log = pino();
 const info = log.info;
@@ -10,10 +11,77 @@ const error = log.error;
 
 info("hello world");
 error("this is at error level");
-info("the answer is %d", 42);
+
+// primitive types
+info('simple string');
+info(true)
+info(42);
+info(3.14);
+info(null);
+info(undefined);
+
+// object types
+info({ a: 1, b: '2' });
+info(new Error());
+info(new Date());
+info([])
+info(new Map());
+info(new Set());
+
+// placeholder messages
+info('Hello %s', 'world');
+info('The answer is %d', 42);
+info('The object is %o', { a: 1, b: '2' });
+info('The json is %j', { a: 1, b: '2' });
+info('The object is %O', { a: 1, b: '2' });
+info('The answer is %d and the question is %s with %o', 42, 'unknown', { correct: 'order' });
+info('Missing placeholder is fine %s');
+
+// %s placeholder supports all primitive types
+info('Boolean %s', true);
+info('Boolean %s', false);
+info('Number %s', 123);
+info('Number %s', 3.14);
+info('BigInt %s', BigInt(123));
+info('Null %s', null);
+info('Undefined %s', undefined);
+info('Symbol %s', Symbol('test'));
+info('String %s', 'hello');
+
+// %s placeholder with multiple primitives
+info('Multiple primitives %s %s %s', true, 42, 'world');
+info('All primitive types %s %s %s %s %s %s %s', 'string', 123, true, BigInt(123), null, undefined, Symbol('test'));
+declare const errorOrString: string | Error;
+info(errorOrString)
+
+// placeholder messages type errors
+expectError(info('The answer is %d', 'not a number'));
+expectError(info('The object is %o', 'not an object'));
+expectError(info('The object is %j', 'not a JSON'));
+expectError(info('The object is %O', 'not an object'));
+expectError(info('The answer is %d and the question is %s with %o', 42, { incorrect: 'order' }, 'unknown'));
+expectError(info('Extra message %s', 'after placeholder', 'not allowed'));
+
+// object types with messages
 info({ obj: 42 }, "hello world");
 info({ obj: 42, b: 2 }, "hello world");
 info({ obj: { aa: "bbb" } }, "another");
+info({ a: 1, b: '2' }, 'hello world with %s', 'extra data');
+
+// Extra message after placeholder
+expectError(info({ a: 1, b: '2' }, 'hello world with %d', 2, 'extra' ));
+
+// metadata with messages type passes, because of custom toString method
+// We can't detect if the object has a custom toString method that returns a string
+info({ a: 1, b: '2' }, 'hello world with %s', {});
+
+// metadata after message
+expectError(info('message', { a: 1, b: '2' }));
+
+// multiple strings without placeholder
+expectError(info('string1', 'string2'));
+expectError(info('string1', 'string2', 'string3'));
+
 setImmediate(info, "after setImmediate");
 error(new Error("an error"));
 
@@ -23,7 +91,7 @@ const testUniqSymbol = {
     [pino.symbols.needsMetadataGsym]: true,
 }[pino.symbols.needsMetadataGsym];
 
-const log2: P.Logger = pino({
+const log2: pino.Logger = pino({
     name: "myapp",
     safe: true,
     serializers: {
@@ -71,6 +139,17 @@ pino({
     redact: { paths: [], censor: (value, path) => path.join() },
 });
 
+pino({
+		redact: {
+				paths: [],
+				censor: (value): string => 'SECRET',
+		},
+});
+
+expectError(pino({
+    redact: { paths: [], censor: (value: string) => value },
+}));
+
 pino({
     depthLimit: 1
 });
@@ -107,6 +186,12 @@ pino({
     },
 });
 
+pino({
+  browser: {
+    asObjectBindingsOnly: true,
+  }
+});
+
 pino({}, undefined);
 
 pino({ base: null });
@@ -199,6 +284,10 @@ const withTimeFn = pino({
     timestamp: pino.stdTimeFunctions.isoTime,
 });
 
+const withRFC3339TimeFn = pino({
+    timestamp: pino.stdTimeFunctions.isoTimeNano,
+});
+
 const withNestedKey = pino({
     nestedKey: "payload",
 });
@@ -209,6 +298,10 @@ const withHooks = pino({
             expectType<pino.Logger>(this);
             return method.apply(this, args);
         },
+        streamWrite(s) {
+            expectType<string>(s);
+            return s.replaceAll('secret-key', 'xxx');
+        },
     },
 });
 
@@ -296,7 +389,8 @@ const customBaseLogger: CustomBaseLogger = {
   debug() {},
   trace() {},
   silent() {},
-  child() { return this }
+  child() { return this },
+  msgPrefix: 'prefix',
 }
 
 // custom levels
@@ -394,6 +488,32 @@ const bLogger = pino({
   },
 });
 
+// Test that we can properly extract parameters from the log fn type
+type LogParam = Parameters<LogFn>
+const [param1, param2, param3, param4]: LogParam = [{ multiple: 'params' }, 'should', 'be', 'accepted']
+
+expectType<unknown>(param1)
+expectType<string>(param2)
+expectType<unknown>(param3)
+expectType<unknown>(param4)
+
+const logger = mock.fn<LogFn>()
+logger.mock.calls[0].arguments[1]?.includes('I should be able to get params')
+
+const hooks: LoggerOptions['hooks'] = {
+    logMethod(this, parameters, method) {
+        if (parameters.length >= 2) {
+        const [parameter1, parameter2, ...remainingParameters] = parameters;
+        if (typeof parameter1 === 'string') {
+            return method.apply(this, [parameter2, parameter1, ...remainingParameters]);
+        }
+        return method.apply(this, [parameter2]);
+        }
+
+        return method.apply(this, parameters);
+    }
+}
+
 expectType<Logger<'log'>>(pino({
   customLevels: {
     log: 5,
@@ -438,4 +558,39 @@ expectError(pino({ levelComparison: 123}), process.stdout);
 // with wrong custom level comparison return type
 expectError(pino({ levelComparison: () => null }), process.stdout);
 expectError(pino({ levelComparison: () => 1 }), process.stdout);
-expectError(pino({ levelComparison: () => 'string' }), process.stdout);
+expectError(pino({ levelComparison: () => 'string' }), process.stdout);
+
+const customLevelsOnlyOpts = {
+    useOnlyCustomLevels: true,
+    customLevels: {
+        customDebug: 10,
+        info: 20, // to make sure the default names are also available for override
+        customNetwork: 30,
+        customError: 40,
+    },
+    level: 'customDebug',
+} satisfies LoggerOptions;
+
+const loggerWithCustomLevelOnly = pino(customLevelsOnlyOpts);
+loggerWithCustomLevelOnly.customDebug('test3')
+loggerWithCustomLevelOnly.info('test4')
+loggerWithCustomLevelOnly.customError('test5')
+loggerWithCustomLevelOnly.customNetwork('test6')
+
+expectError(loggerWithCustomLevelOnly.fatal('test'));
+expectError(loggerWithCustomLevelOnly.error('test'));
+expectError(loggerWithCustomLevelOnly.warn('test'));
+expectError(loggerWithCustomLevelOnly.debug('test'));
+expectError(loggerWithCustomLevelOnly.trace('test'));
+
+// Module extension
+declare module "../../" {
+    interface LogFnFields {
+        bannedField?: never;
+        typeCheckedField?: string
+    }
+}
+
+info({typeCheckedField: 'bar'})
+expectError(info({bannedField: 'bar'}))
+expectError(info({typeCheckedField: 123}))

package/node_modules/pino/test/types/pino.ts

@@ -1,7 +1,8 @@
-import { StreamEntry, pino } from '../../pino'
-import { join } from 'path'
-import { tmpdir } from 'os'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
 import pinoPretty from 'pino-pretty'
+// Test both default ("Pino") and named ("pino") imports.
+import Pino, { LoggerOptions, StreamEntry, pino, multistream, transport } from '../../pino'
 
 const destination = join(
     tmpdir(),
@@ -9,25 +10,31 @@ const destination = join(
 )
 
 // Single
-const transport = pino.transport({
+const transport1 = transport({
     target: 'pino-pretty',
     options: { some: 'options for', the: 'transport' }
 })
-const logger = pino(transport)
+const logger = pino(transport1)
 logger.setBindings({ some: 'bindings' })
 logger.info('test2')
 logger.flush()
+const loggerDefault = Pino(transport1)
+loggerDefault.setBindings({ some: 'bindings' })
+loggerDefault.info('test2')
+loggerDefault.flush()
 
-const transport2 = pino.transport({
+const transport2 = transport({
     target: 'pino-pretty',
 })
 const logger2 = pino(transport2)
 logger2.info('test2')
+const logger2Default = Pino(transport2)
+logger2Default.info('test2')
 
 
 // Multiple
 
-const transports = pino.transport({targets: [
+const transports = transport({targets: [
     {
         level: 'info',
         target: 'pino-pretty',
@@ -45,19 +52,19 @@ loggerMulti.info('test2')
 // custom levels
 
 const customLevels = {
-    debug   : 1,
+    customDebug   : 1,
     info    : 2,
-    network : 3,
-    error   : 4,
+    customNetwork : 3,
+    customError   : 4,
 };
 
 type CustomLevels = keyof typeof customLevels;
 
 const pinoOpts = {
-    level: 'debug',
     useOnlyCustomLevels: true,
     customLevels: customLevels,
-};
+    level: 'customDebug',
+} satisfies LoggerOptions;
 
 const multistreamOpts = {
     dedupe: true,
@@ -65,14 +72,19 @@ const multistreamOpts = {
 };
 
 const streams: StreamEntry<CustomLevels>[] = [
-    { level : 'debug',   stream : pinoPretty() },
+    { level : 'customDebug',   stream : pinoPretty() },
     { level : 'info',    stream : pinoPretty() },
-    { level : 'network', stream : pinoPretty() },
-    { level : 'error',   stream : pinoPretty() },
+    { level : 'customNetwork', stream : pinoPretty() },
+    { level : 'customError',   stream : pinoPretty() },
 ];
 
-const loggerCustomLevel = pino(pinoOpts, pino.multistream(streams, multistreamOpts));
-loggerCustomLevel.debug('test3')
+const loggerCustomLevel = pino(pinoOpts, multistream(streams, multistreamOpts));
+loggerCustomLevel.customDebug('test3')
 loggerCustomLevel.info('test4')
-loggerCustomLevel.error('test5')
-loggerCustomLevel.network('test6')
+loggerCustomLevel.customError('test5')
+loggerCustomLevel.customNetwork('test6')
+const loggerCustomLevelDefault = Pino(pinoOpts, multistream(streams, multistreamOpts));
+loggerCustomLevelDefault.customDebug('test3')
+loggerCustomLevelDefault.info('test4')
+loggerCustomLevelDefault.customError('test5')
+loggerCustomLevelDefault.customNetwork('test6')

package/node_modules/pino/tsconfig.json

@@ -5,7 +5,7 @@
     "module": "commonjs",
     "noEmit": true,
     "strict": true,
-    "esModuleInterop": true,
+    "esModuleInterop": true
   },
   "exclude": [
     "./test/types/*.test-d.ts",

package/node_modules/pino-abstract-transport/.github/workflows/ci.yml

@@ -38,11 +38,9 @@ jobs:
       contents: read
     strategy:
       matrix:
-        node-version: [14, 16, 18, 20]
+        node-version: [18, 20, 22]
         os: [macos-latest, ubuntu-latest, windows-latest]
-        exclude:
-          - node-version: 14
-            os: windows-latest
+
     steps:
       - name: Check out repo
         uses: actions/checkout@v4

package/node_modules/pino-abstract-transport/index.js

@@ -2,7 +2,7 @@
 
 const metadata = Symbol.for('pino.metadata')
 const split = require('split2')
-const { Duplex } = require('readable-stream')
+const { Duplex } = require('stream')
 const { parentPort, workerData } = require('worker_threads')
 
 function createDeferred () {

package/node_modules/pino-abstract-transport/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pino-abstract-transport",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Write Pino transports easily",
   "main": "index.js",
   "scripts": {
@@ -23,7 +23,6 @@
   },
   "homepage": "https://github.com/pinojs/pino-abstract-transport#readme",
   "dependencies": {
-    "readable-stream": "^4.0.0",
     "split2": "^4.0.0"
   },
   "devDependencies": {
@@ -32,7 +31,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "thread-stream": "^2.4.1",
+    "thread-stream": "^2.6.0",
     "tsd": "^0.31.0"
   },
   "tsd": {

package/node_modules/pino-abstract-transport/test/base.test.js

@@ -80,7 +80,7 @@ test('broken json', ({ match, same, plan }) => {
   const stream = build(function (source) {
     source.on('unknown', function (line, error) {
       same(expected, line)
-      const regex = /^(Unexpected end of JSON input|Unterminated string in JSON at position 12)$/
+      const regex = /^(Unexpected end of JSON input|Unterminated string in JSON at position 12)( \(line 1 column 13\))?$/
       match(error.message, regex)
     })
   })