@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/pino/docs/transports.md

@@ -85,7 +85,7 @@ This means that the options object can only contain types that are supported by
 [Structured Clone Algorithm][sca] which is used to (de)serialize objects between threads.
 
 What if we wanted to use both transports, but send only error logs to `my-transport.mjs` while
-sending all logs to `some-file-transport`? We can use the `pino.transport` function's `level` option:
+sending all logs to `some-file-transport`? We can use the per-target `level` option:
 
 ```js
 const pino = require('pino')
@@ -98,6 +98,54 @@ const transport = pino.transport({
 pino(transport)
 ```
 
+### How level filtering works with transports
+
+Pino applies level filtering in two different places depending on the transport configuration.
+
+#### A) Single `target` (or single `pipeline`)
+
+```text
+Main thread                                   Worker thread
+────────────────────────────────────────────  ─────────────────────────────────
+logger.debug()/info()/...                     transport target (stream)
+        │                                              ▲
+        ▼                                              │
+logger.level gate (enabled methods) ──ThreadStream─────┘
+
+Result:
+- `logger.level` decides what is emitted.
+- `transport.level` is not used in this path.
+```
+
+#### B) `targets` (multiple destinations)
+
+```text
+Main thread                                   Worker thread
+────────────────────────────────────────────  ─────────────────────────────────
+logger.debug()/info()/...                     pino.multistream
+        │                                      (per-target level filter)
+        ▼                                              │
+logger.level gate (enabled methods) ──ThreadStream────┼──> target #1 (level: ...)
+                                                       ├──> target #2 (level: ...)
+                                                       └──> target #N (default: info)
+
+Result:
+- `logger.level` is the first gate.
+- each `targets[i].level` is the second gate.
+- missing `targets[i].level` defaults to `info`.
+```
+
+Summary:
+
+- Single `target`/single `pipeline`: only `logger.level` filters messages.
+- Multiple `targets`: `logger.level` is applied first, then each `targets[i].level` is applied.
+- If `targets[i].level` is missing, it defaults to `info`.
+
+If you need `debug` (or lower) logs to reach one or more targets, set:
+
+1. `logger.level` low enough, and
+2. `level` on each target that should receive those messages.
+
 If we're using custom levels, they should be passed in when using more than one transport.
 ```js
 const pino = require('pino')
@@ -139,6 +187,27 @@ pino(transport);
 
 For more details on `pino.transport` see the [API docs for `pino.transport`][pino-transport].
 
+### Using transports with `--import` or `--require` preloads
+
+Pino transports work correctly when loaded via Node.js preload flags (`--import` or `--require`).
+Pino automatically detects when it's being loaded during the preload phase and filters out the
+preload flags from the transport worker's `execArgv` to prevent infinite worker spawning.
+
+```js
+// preload.mjs
+import pino from 'pino'
+
+export const logger = pino({
+  transport: {
+    target: 'pino-pretty'
+  }
+})
+```
+
+```bash
+node --import=./preload.mjs app.js
+```
+
 [pino-transport]: /docs/api.md#pino-transport
 [sca]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
 
@@ -222,7 +291,7 @@ In case you want to both use a custom transport, and output the log entries with
       }
     ]
 
-    const logger = pino(pino.transport({ targets: transports })
+    const logger = pino(pino.transport({ targets: transports }))
 ```
 
 ### Creating a transport pipeline
@@ -286,19 +355,63 @@ a terminating target, i.e. a `Writable` stream.__
 
 ### TypeScript compatibility
 
-Pino provides basic support for transports written in TypeScript.
+Pino provides support for transports written in TypeScript.
+
+#### Node.js 22+ with Type Stripping
+
+Starting with Node.js 22.6.0, you can use TypeScript transports directly with native type stripping support. This provides full ESM support without any transpilation or additional tooling:
+
+```ts
+// my-transport.mts
+import { createWriteStream } from 'node:fs'
 
-Ideally, they should be transpiled to ensure maximum compatibility, but sometimes
-you might want to use tools such as TS-Node, to execute your TypeScript
-code without having to go through an explicit transpilation step.
+export default (options: { destination: string }) => {
+  return createWriteStream(options.destination)
+}
+```
 
-You can use your TypeScript code without explicit transpilation, but there are
-some known caveats:
-- For "pure" TypeScript code, ES imports are still not supported (ES imports are
+```js
+// app.js
+const pino = require('pino')
+const transport = pino.transport({
+  target: './my-transport.mts',
+  options: { destination: '/path/to/file' }
+})
+pino(transport)
+```
+
+**Version requirements:**
+
+- **Node.js 22.6.0 - 22.17.x**: Use the `--experimental-strip-types` flag:
+  ```sh
+  node --experimental-strip-types app.ts
+  ```
+
+- **Node.js 22.18.0+ and 24.0.0+**: Type stripping is enabled by default, no flag needed:
+  ```sh
+  node app.ts
+  ```
+
+**Important notes:**
+- Use the `.mts` extension for TypeScript ESM modules to ensure proper module resolution
+- Alternatively, you can use `.ts` extension if your `package.json` has `"type": "module"`, but this requires your entire application to use ESM
+- Type stripping is not available in Node.js 20.x or earlier versions
+- This approach provides the cleanest TypeScript experience with full ESM support and no build step required
+
+#### Using TS-Node (Legacy)
+
+For older Node.js versions, you can use tools such as [TS-Node](https://typestrong.org/ts-node/) to execute TypeScript
+code without explicit transpilation, but there are some known caveats:
+- For "pure" TypeScript code, ES imports are not fully supported (ES imports are
   supported once the code is transpiled).
-- Only TS-Node is supported for now, there's no TSM support.
-- Running transports TypeScript code on TS-Node seems to be problematic on
-  Windows systems, there's no official support for that yet.
+- Only TS-Node is supported. Other TypeScript loaders like [TSM](https://github.com/lukeed/tsm) are not currently supported.
+- Running transports TypeScript code on TS-Node may be problematic on
+  Windows systems.
+
+#### Transpiled TypeScript (Recommended for Production)
+
+For maximum compatibility and production use, it's still recommended to transpile
+TypeScript transports to JavaScript before deployment.
 
 ### Notable transports
 
@@ -426,16 +539,19 @@ PRs to this document are welcome for any new transports!
 + [@axiomhq/pino](#@axiomhq/pino)
 + [@logtail/pino](#@logtail/pino)
 + [@macfja/pino-fingers-crossed](#macfja-pino-fingers-crossed)
++ [@openobserve/pino-openobserve](#pino-openobserve)
++ [datadog-logger-integrations](#datadog-logger-integrations)
 + [pino-airbrake-transport](#pino-airbrake-transport)
 + [pino-axiom](#pino-axiom)
-+ [pino-datadog-transport](#pino-datadog-transport)
 + [pino-discord-webhook](#pino-discord-webhook)
 + [pino-elasticsearch](#pino-elasticsearch)
 + [pino-hana](#pino-hana)
++ [pino-logflare](#pino-logflare)
 + [pino-logfmt](#pino-logfmt)
 + [pino-loki](#pino-loki)
 + [pino-opentelemetry-transport](#pino-opentelemetry-transport)
 + [pino-pretty](#pino-pretty)
++ [pino-roll](#pino-roll)
 + [pino-seq-transport](#pino-seq-transport)
 + [pino-sentry-transport](#pino-sentry-transport)
 + [pino-slack-webhook](#pino-slack-webhook)
@@ -453,7 +569,6 @@ PRs to this document are welcome for any new transports!
 + [pino-http-send](#pino-http-send)
 + [pino-kafka](#pino-kafka)
 + [pino-logdna](#pino-logdna)
-+ [pino-logflare](#pino-logflare)
 + [pino-loki](#pino-loki)
 + [pino-mq](#pino-mq)
 + [pino-mysql](#pino-mysql)
@@ -525,6 +640,35 @@ logger.info('Will NOT appear')
 logger.info({ [enable]: false }, 'Will appear immedialty')
 logger.info('Will NOT appear')
 ```
+<a id="pino-openobserve"></a>
+### @openobserve/pino-openobserve
+
+[@openobserve/pino-openobserve](https://github.com/openobserve/pino-openobserve) is a 
+Pino v7+ transport that will send logs to an 
+[OpenObserve](https://openobserve.ai) instance.
+
+```
+const pino = require('pino');
+const OpenobserveTransport = require('@openobserve/pino-openobserve');
+
+const logger = pino({
+  level: 'info',
+  transport: {
+    target: OpenobserveTransport,
+    options: {
+      url: 'https://your-openobserve-server.com',
+      organization: 'your-organization',
+      streamName: 'your-stream',
+      auth: {
+        username: 'your-username',
+        password: 'your-password',
+      },
+    },
+  },
+});
+```
+
+For full documentation check the [README](https://github.com/openobserve/pino-openobserve).
 
 <a id="pino-airbrake-transport"></a>
 ### pino-airbrake-transport
@@ -631,18 +775,18 @@ $ node foo | pino-datadog --key blablabla
 
 For full documentation of command line switches read [README](https://github.com/ovhemert/pino-datadog#readme)
 
-<a id="pino-datadog-transport"></a>
-### pino-datadog-transport
+<a id="datadog-logger-integrations"></a>
+### datadog-logger-integrations
 
-[pino-datadog-transport][pino-datadog-transport] is a Pino v7+ compatible transport to forward log events to [Datadog][Datadog]
+[datadog-logger-integrations][datadog-logger-integrations] is a Pino v7+ compatible transport to forward log events to [Datadog][Datadog]
 from a dedicated worker:
 
 ```js
 const pino = require('pino')
 const transport = pino.transport({
-  target: 'pino-datadog-transport',
+  target: 'datadog-logger-integrations',
   options: {
-    ddClientConf: {
+    ddClientConfig: {
       authMethods: {
         apiKeyAuth: <your datadog API key>
       }
@@ -653,7 +797,7 @@ const transport = pino.transport({
 pino(transport)
 ```
 
-[pino-datadog-transport]: https://github.com/theogravity/pino-datadog-transport
+[datadog-logger-integrations]: https://github.com/marklai1998/datadog-logger-integrations
 [Datadog]: https://www.datadoghq.com/
 
 #### Logstash
@@ -964,6 +1108,30 @@ $ node app.js | pino-redis -U redis://username:password@localhost:6379
 [pino-redis]: https://github.com/buianhthang/pino-redis
 [Redis]: https://redis.io/
 
+<a id="pino-roll"></a>
+### pino-roll
+
+`pino-roll` is a Pino transport that automatically rolls your log files based on size or time frequency.
+
+```js
+import { join } from 'path';
+import pino from 'pino';
+
+const transport = pino.transport({
+  target: 'pino-roll',
+  options: { file: join('logs', 'log'), frequency: 'daily', mkdir: true }
+});
+
+const logger = pino(transport);
+```
+
+then you can use the logger as usual:
+
+```js
+logger.info('Hello from pino-roll!');
+```
+For full documentation check the [README](https://github.com/mcollina/pino-roll?tab=readme-ov-file#pino-roll).
+
 <a id="pino-sentry"></a>
 ### pino-sentry
 

package/node_modules/pino/docs/web.md

@@ -12,6 +12,7 @@ web framework ecosystem.
   - [Pino with Node core `http`](#pino-with-node-core-http)
   - [Pino with Nest](#pino-with-nest)
   - [Pino with H3](#pino-with-h3)
+  - [Pino with Hono](#pino-with-hono)
 
 <a id="fastify"></a>
 ## Pino with Fastify
@@ -267,3 +268,42 @@ router.get(
 Execute `npx --yes listhen -w --open ./server.mjs`.
 
 See the [pino-http README](https://npm.im/pino-http) for more info.
+
+
+<a id="hono"></a>
+## Pino with Hono
+
+```sh
+npm install pino pino-http hono
+```
+
+```js
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { requestId } from 'hono/request-id';
+import { pinoHttp } from 'pino-http';
+
+const app = new Hono();
+app.use(requestId());
+app.use(async (c, next) => {
+  // pass hono's request-id to pino-http
+  c.env.incoming.id = c.var.requestId;
+
+  // map express style middleware to hono
+  await new Promise((resolve) => pinoHttp()(c.env.incoming, c.env.outgoing, () => resolve()));
+
+  c.set('logger', c.env.incoming.log);
+
+  await next();
+});
+
+app.get('/', (c) => {
+  c.var.logger.info('something');
+
+  return c.text('Hello Node.js!');
+});
+
+serve(app);
+```
+
+See the [pino-http README](https://npm.im/pino-http) for more info.

package/node_modules/pino/eslint.config.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { defineConfig, globalIgnores } = require('eslint/config')
+const neostandard = require('neostandard')
+
+module.exports = defineConfig([
+  neostandard({
+    ts: true
+  }),
+  globalIgnores([
+    'pino.d.ts',
+    'test/fixtures/syntax-error-esm.mjs',
+    'test/fixtures/ts/*cjs',
+  ]),
+  {
+    rules: {
+      'no-var': 'off',
+    },
+  },
+  {
+    files: ['test/types/**/*'],
+    rules: {
+      '@typescript-eslint/no-unused-expressions': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'n/handle-callback-err': 'off',
+    },
+  },
+])

package/node_modules/pino/lib/meta.js

@@ -1,3 +1,3 @@
 'use strict'
 
-module.exports = { version: '9.5.0' }
+module.exports = { version: '10.3.1' }

package/node_modules/pino/lib/multistream.js

@@ -6,7 +6,6 @@ const { DEFAULT_LEVELS } = require('./constants')
 const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info
 
 function multistream (streamsArray, opts) {
-  let counter = 0
   streamsArray = streamsArray || []
   opts = opts || { dedupe: false }
 
@@ -21,10 +20,12 @@ function multistream (streamsArray, opts) {
   const res = {
     write,
     add,
+    remove,
     emit,
     flushSync,
     end,
     minLevel: 0,
+    lastId: 0,
     streams: [],
     clone,
     [metadata]: true,
@@ -126,7 +127,7 @@ function multistream (streamsArray, opts) {
       stream: stream_,
       level,
       levelVal: undefined,
-      id: counter++
+      id: ++res.lastId
     }
 
     streams.unshift(dest_)
@@ -137,6 +138,19 @@ function multistream (streamsArray, opts) {
     return res
   }
 
+  function remove (id) {
+    const { streams } = this
+    const index = streams.findIndex(s => s.id === id)
+
+    if (index >= 0) {
+      streams.splice(index, 1)
+      streams.sort(compareByLevel)
+      this.minLevel = streams.length > 0 ? streams[0].level : -1
+    }
+
+    return res
+  }
+
   function end () {
     for (const { stream } of this.streams) {
       if (typeof stream.flushSync === 'function') {
@@ -159,6 +173,7 @@ function multistream (streamsArray, opts) {
     return {
       write,
       add,
+      remove,
       minLevel: level,
       streams,
       clone,

package/node_modules/pino/lib/proto.js

@@ -9,7 +9,6 @@ const {
   setLevelSym,
   getLevelSym,
   chindingsSym,
-  parsedChindingsSym,
   mixinSym,
   asJsonSym,
   writeSym,
@@ -27,7 +26,8 @@ const {
   stringifySym,
   formatOptsSym,
   stringifiersSym,
-  msgPrefixSym
+  msgPrefixSym,
+  hooksSym
 } = require('./symbols')
 const {
   getLevel,
@@ -42,7 +42,8 @@ const {
   asChindings,
   asJson,
   buildFormatters,
-  stringify
+  stringify,
+  noop
 } = require('./tools')
 const {
   version
@@ -64,6 +65,8 @@ const prototype = {
   set level (lvl) { this[setLevelSym](lvl) },
   get levelVal () { return this[levelValSym] },
   set levelVal (n) { throw Error('levelVal is read-only') },
+  get msgPrefix () { return this[msgPrefixSym] },
+  get [Symbol.toStringTag] () { return 'Pino' },
   [lsCacheSym]: initialLsCache,
   [writeSym]: write,
   [asJsonSym]: asJson,
@@ -83,11 +86,32 @@ function child (bindings, options) {
   if (!bindings) {
     throw Error('missing bindings for child Pino')
   }
-  options = options || {} // default options to empty object
   const serializers = this[serializersSym]
   const formatters = this[formattersSym]
   const instance = Object.create(this)
 
+  // If an `options` object was not supplied, we can improve
+  // the performance of child creation by skipping
+  // the checks for set options and simply return
+  // a baseline instance.
+  if (options == null) {
+    if (instance[formattersSym].bindings !== resetChildingsFormatter) {
+      instance[formattersSym] = buildFormatters(
+        formatters.level,
+        resetChildingsFormatter,
+        formatters.log
+      )
+    }
+
+    instance[chindingsSym] = asChindings(instance, bindings)
+
+    if (this.onChild !== noop) {
+      this.onChild(instance)
+    }
+
+    return instance
+  }
+
   if (options.hasOwnProperty('serializers') === true) {
     instance[serializersSym] = Object.create(null)
 
@@ -145,8 +169,10 @@ function child (bindings, options) {
   }
 
   instance[chindingsSym] = asChindings(instance, bindings)
-  const childLevel = options.level || this.level
-  instance[setLevelSym](childLevel)
+  if ((options.level !== undefined && options.level !== this.level) || options.hasOwnProperty('customLevels')) {
+    const childLevel = options.level || this.level
+    instance[setLevelSym](childLevel)
+  }
   this.onChild(instance)
   return instance
 }
@@ -163,7 +189,6 @@ function bindings () {
 function setBindings (newBindings) {
   const chindings = asChindings(this, newBindings)
   this[chindingsSym] = chindings
-  delete this[parsedChindingsSym]
 }
 
 /**
@@ -185,6 +210,7 @@ function write (_obj, msg, num) {
   const messageKey = this[messageKeySym]
   const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy
   let obj
+  const streamWriteHook = this[hooksSym].streamWrite
 
   if (_obj === undefined || _obj === null) {
     obj = {}
@@ -214,11 +240,9 @@ function write (_obj, msg, num) {
     stream.lastTime = t.slice(this[timeSliceIndexSym])
     stream.lastLogger = this // for child loggers
   }
-  stream.write(s)
+  stream.write(streamWriteHook ? streamWriteHook(s) : s)
 }
 
-function noop () {}
-
 function flush (cb) {
   if (cb != null && typeof cb !== 'function') {
     throw Error('callback must be a function')

package/node_modules/pino/lib/redaction.js

@@ -1,19 +1,16 @@
 'use strict'
 
-const fastRedact = require('fast-redact')
+const Redact = require('@pinojs/redact')
 const { redactFmtSym, wildcardFirstSym } = require('./symbols')
-const { rx, validator } = fastRedact
 
-const validate = validator({
-  ERR_PATHS_MUST_BE_STRINGS: () => 'pino – redacted paths must be strings',
-  ERR_INVALID_PATH: (s) => `pino – redact paths array contains an invalid path (${s})`
-})
+// Custom rx regex equivalent to fast-redact's rx
+const rx = /[^.[\]]+|\[([^[\]]*?)\]/g
 
 const CENSOR = '[Redacted]'
 const strict = false // TODO should this be configurable?
 
 function redaction (opts, serialize) {
-  const { paths, censor } = handle(opts)
+  const { paths, censor, remove } = handle(opts)
 
   const shape = paths.reduce((o, str) => {
     rx.lastIndex = 0
@@ -73,7 +70,7 @@ function redaction (opts, serialize) {
   // provides top level redaction for instances where
   // an object is interpolated into the msg string
   const result = {
-    [redactFmtSym]: fastRedact({ paths, censor, serialize, strict })
+    [redactFmtSym]: Redact({ paths, censor, serialize, strict, remove })
   }
 
   const topCensor = (...args) => {
@@ -90,11 +87,12 @@ function redaction (opts, serialize) {
             return censor(value, [k, ...path])
           }
         : censor
-      o[k] = fastRedact({
+      o[k] = Redact({
         paths: shape[k],
         censor: wrappedCensor,
         serialize,
-        strict
+        strict,
+        remove
       })
     }
     return o
@@ -104,15 +102,13 @@ function redaction (opts, serialize) {
 function handle (opts) {
   if (Array.isArray(opts)) {
     opts = { paths: opts, censor: CENSOR }
-    validate(opts)
     return opts
   }
   let { paths, censor = CENSOR, remove } = opts
   if (Array.isArray(paths) === false) { throw Error('pino – redact must contain an array of strings') }
   if (remove === true) censor = undefined
-  validate({ paths, censor })
 
-  return { paths, censor }
+  return { paths, censor, remove }
 }
 
 module.exports = redaction

package/node_modules/pino/lib/time.js

@@ -8,4 +8,32 @@ const unixTime = () => `,"time":${Math.round(Date.now() / 1000.0)}`
 
 const isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"` // using Date.now() for testability
 
-module.exports = { nullTime, epochTime, unixTime, isoTime }
+const NS_PER_MS = 1_000_000n
+const NS_PER_SEC = 1_000_000_000n
+
+const startWallTimeNs = BigInt(Date.now()) * NS_PER_MS
+const startHrTime = process.hrtime.bigint()
+
+const isoTimeNano = () => {
+  const elapsedNs = process.hrtime.bigint() - startHrTime
+  const currentTimeNs = startWallTimeNs + elapsedNs
+
+  const secondsSinceEpoch = currentTimeNs / NS_PER_SEC
+  const nanosWithinSecond = currentTimeNs % NS_PER_SEC
+
+  const msSinceEpoch = Number(secondsSinceEpoch * 1000n + nanosWithinSecond / 1_000_000n)
+  const date = new Date(msSinceEpoch)
+
+  const year = date.getUTCFullYear()
+  const month = (date.getUTCMonth() + 1).toString().padStart(2, '0')
+  const day = date.getUTCDate().toString().padStart(2, '0')
+  const hours = date.getUTCHours().toString().padStart(2, '0')
+  const minutes = date.getUTCMinutes().toString().padStart(2, '0')
+  const seconds = date.getUTCSeconds().toString().padStart(2, '0')
+
+  return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond
+    .toString()
+    .padStart(9, '0')}Z"`
+}
+
+module.exports = { nullTime, epochTime, unixTime, isoTime, isoTimeNano }