@ddd-ts-kit/pino 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,273 @@
-# Temporary Holding Version
+# @ddd-ts-kit/pino
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The kernel `Logger` port on [pino](https://getpino.io): JSON lines on the standard output, the
+correlation fields of the work in progress on every line, credentials redacted, a flush for the
+shutdown. Nothing in `domain/` or `application/` imports this package, or logs anything: the
+composition root binds the adapter, and infrastructure, presentation and the aspects write
+through the port.
+
+```
+npm i @ddd-ts-kit/pino pino
+npm i -D pino-pretty        # only for the pretty format
+```
+
+Written against pino 10. `pino-pretty` 13 is an optional peer: it is loaded only when the
+`pretty` format is asked for.
+
+## Composition root
+
+```ts
+// platform/observability/create-logger.ts
+import type { ExecutionScope, LogLevel } from '@ddd-ts-kit/kernel';
+import { createPinoLogger, type PinoLogger } from '@ddd-ts-kit/pino';
+import { traceLogFields } from '@ddd-ts-kit/tracing';
+
+export interface LogSettings {
+  readonly level: LogLevel; // LOG_LEVEL
+  readonly format: 'json' | 'pretty'; // LOG_FORMAT
+  readonly service: string;
+  readonly environment: string;
+  readonly scrubMessages: boolean; // LOG_SCRUB_MESSAGES
+}
+
+export function createLogger(scope: ExecutionScope, settings: LogSettings): PinoLogger {
+  return createPinoLogger({ ...settings, fields: () => traceLogFields(scope) });
+}
+```
+
+```ts
+// main.ts
+import { tracing } from '@/platform/tracing.js'; // first
+import { AsyncLocalStorageExecutionScope } from '@ddd-ts-kit/kernel';
+import { createApplication, kernelModule } from '@ddd-ts-kit/di';
+
+const scope = new AsyncLocalStorageExecutionScope();
+const logger = createLogger(scope, config.log);
+
+const app = createApplication({
+  modules: [kernelModule({ executionScope: scope, logger }), ...contexts],
+});
+
+process.once('SIGTERM', () => void shutdown());
+
+async function shutdown(): Promise<void> {
+  await app.stop(); // flushes the error reporter, then the logger, last
+  await tracing.shutdown();
+}
+```
+
+`init --logger pino` writes this `create-logger.ts` (it answers a `NoopLogger` when given no
+settings, which is how the tools and the tests stay silent); `platform/lay-foundations.ts`
+calls it once and `composeApplication` hands the logger to `kernelModule({ logger })`.
+
+One line of the application, as it is written:
+
+```json
+{"level":"info","time":"2026-03-01T10:00:00.000Z","service":"shop-api","environment":"production","correlationId":"9f2c","origin":"http","actorId":"user-1","tenantId":"acme","trace_id":"4bf92f3577b34da6a3ce929d0e0e4736","span_id":"00f067aa0ba902b7","context":"shipping","message":"order shipped"}
+```
+
+**Correlation.** `fields` is read at each line that is written, through the pino `mixin`: no
+call site passes an id. `traceLogFields(scope)` answers the trace and span ids inside a span,
+and inside the execution scope the correlation id, the causation id, the origin, the actor and
+the tenant. This package does not depend on the tracing package: any `() => LogFields` fits,
+`() => logFieldsOf(scope.current())` included. A function that throws gives no field, never a
+lost line. The fields of the line win over `fields`, which win over those of a child: pino
+writes the bindings of a child first and what the mixin answers after them, so a key given
+by both is written twice and a JSON parser reads the one of `fields`. `StdoutLogger` orders
+them the same way; `@ddd-ts-kit/winston` does not (there a child wins over `fields`). Do not
+bind in a child a key that `fields` answers.
+
+**An instance of your own.** The project that already configures pino keeps doing so, and
+takes the pieces it wants:
+
+```ts
+import { CREDENTIAL_KEYS } from '@ddd-ts-kit/kernel';
+import { pino } from 'pino';
+import { PinoLogger, correlationMixin, credentialRedaction } from '@ddd-ts-kit/pino';
+
+const instance = pino({
+  mixin: correlationMixin(() => traceLogFields(scope)),
+  redact: credentialRedaction([...CREDENTIAL_KEYS, 'iban']),
+});
+
+const logger = new PinoLogger(instance);
+```
+
+`createPinoLogger` writes `level` by its name and the message under `message`, like the
+`StdoutLogger` of the aspects package and like `@ddd-ts-kit/winston`: one dashboard reads the
+three. An instance of your own keeps the keys you gave it (`msg` and a numeric level by default).
+
+## Development mode
+
+```ts
+createPinoLogger({ level: 'debug', format: 'pretty', fields: () => traceLogFields(scope) });
+```
+
+```
+[10:00:00.000] INFO: order shipped
+    service: "shop-api"
+    correlationId: "9f2c"
+    context: "shipping"
+```
+
+The `pretty` format is the transport pino documents for `pino-pretty`: it runs in a worker
+thread, so it takes a file descriptor or a path as `destination`, not a stream, and `flush()`
+waits for the worker. For pretty lines on a stream of your own, build the instance on
+`pino-pretty` used as a stream, `pino(options, pretty({ destination }))`, and wrap it in
+`new PinoLogger(instance)`. Keep it out of production: choose the format from configuration
+(`LOG_FORMAT=pretty` in `.env`, `json` everywhere else).
+
+## Privacy
+
+Log lines are where personal data leaks: they are written everywhere, read by everyone and kept
+for long. Three things are done in the adapter, so that no call site has to remember them. The
+list of credential keys, the description of an error and the two markers (`CREDENTIAL_KEYS`,
+`describeError`, `REDACTED`, `SCRUBBED_MESSAGE`) are those of the kernel, shared by every
+logger of the port.
+
+**Credentials are redacted** by pino's own `redact`, in the fields of a line, of a child and of
+`fields` alike. The value of these keys is replaced by `[redacted]`, at the top of a line and
+one level below (`headers.authorization`, `body.password`):
+
+`password`, `authorization`, `cookie`, `set-cookie`, `token`, `secret`, `apiKey`, `api_key`,
+`access_token`, `refresh_token`, `accessToken`, `refreshToken`, `client_secret`
+
+`redact: ['iban', 'ssn']` adds to the list. Names are matched exactly, case included, and
+nothing is looked for deeper than one level: log the part you mean, not a whole request.
+
+**An error passed as a field** (`logger.error('payment failed', { error })`: the `LogValue` of
+the port admits an `Error`) is written as `describeError` of the kernel describes it, the same
+from every logger of the port: its class as `type`, its `code` when
+it is a `DomainError`, its `message`, its own `stack`, then its `cause` the same way, up to
+eight deep. Each error of a chain is written once: pino's standard serializer of the `err` key
+would fold every cause into the message and the stack of the first, so the adapter turns it off
+for the lines that go through the port. Errors are looked for among the fields of the line, not
+inside nested objects.
+
+**Messages of unexpected errors can be dropped.** The message of an error is the first place
+where personal data shows up: a driver quotes the row it refused. The default keeps it, because
+a log line that says `[message removed]` costs every investigation. With one option only the
+messages the project wrote itself survive, those of its `DomainError`s; class, code, stack and
+cause remain for the others, and the stack loses its first line, which repeats the message:
+
+```ts
+createPinoLogger({ scrubMessages: true }); // or new PinoLogger(instance, { scrubMessages: true })
+```
+
+This is the `scrubMessages` every logger of the port takes (`StdoutLogger`, pino, winston,
+`InMemoryLogger`) and the one of `@ddd-ts-kit/sentry`, with the same rule, the same
+`SCRUBBED_MESSAGE` and the same trade-off: turn it on when the logs leave your hands or when no
+operator should read that data there. What the message of a log line itself says stays yours:
+write `order shipped` and put the identifiers in fields.
+
+The kit itself never hands an error to a logger: the `logged` aspect, `loggingMiddleware` and
+the job scheduler write `errorType` and `errorCode` only (`identifyError` of the kernel), never
+a message, whatever `scrubMessages` says, and the error goes to the `ErrorReporter`. The
+description above is for the error your own code chooses to log:
+`logger.error('payment failed', { error })`.
+
+## Levels
+
+| Port | pino | |
+|---|---|---|
+| `debug` | `debug` (20) | |
+| `info` | `info` (30) | the default threshold |
+| `warn` | `warn` (40) | |
+| `error` | `error` (50) | |
+
+The port has no `trace` and no `fatal`: nothing written through it uses them. A line below the
+threshold costs one comparison: its fields are not read, and `fields` is not called. The
+threshold of an instance changed while running (`instance.level = 'debug'`) is followed by the
+adapter and by its children. `isLevelEnabled(level)` answers that threshold: ask it before
+building fields that cost.
+
+`child(fields)` is a pino child: the fields are serialized once, when the child is created,
+and cost nothing per line. A key bound twice (by a child and by its parent, by a child and by
+`fields`, or by any of them and by the line) is written twice on the line, as pino does; a
+JSON parser reads the last one, in this order: `service`, `environment` and `base`, the
+children from the oldest to the closest, `fields`, the line. `level` and `time` are the
+exception: a field of that name is dropped,
+so that no field forges the header of a line.
+
+## Flush
+
+`flush(): Promise<void>` resolves once what pino buffered was handed to its destination: the
+worker of a transport, or the buffer of an asynchronous destination. It never rejects.
+`app.stop()` calls it, last, after the modules stopped and the error reporter was flushed:
+stopping logs too. Without the application of the di package, call it yourself at that place.
+
+The port calls a flush once, at shutdown, and leaves what is logged afterwards unspecified.
+Here the logger stays usable: a line logged after the flush is written like the others, and
+with `asynchronous: true` it waits in the buffer for pino's exit hook.
+
+## Performance
+
+By default every line is written to the standard output before the call returns. Nothing is
+ever lost, and a slow reader of the standard output slows the application down.
+
+`asynchronous: true` buffers 4 KiB and writes off the hot path (`pino.destination({ sync:
+false })`), which is what makes pino fast under load. The price is what a dead process had not
+written yet. `flush()` writes the buffer, and so does pino's own exit hook on `process.exit`
+and on an uncaught exception. A signal that ends the process with no handler (`SIGKILL`, the
+out-of-memory killer, a `SIGTERM` nobody listens to) loses up to 4 KiB of the most recent
+lines, the ones that would have explained it; so does an exit in the first instants, before
+the destination is open. Keep the default unless logging shows up in a profile.
+
+A line costs one object copy of its fields (errors described, header keys dropped), then pino:
+about 3 microseconds in all where `@ddd-ts-kit/winston` takes 7 (Node 24, a child, four
+correlation fields, three fields, a sink that discards).
+Redaction is compiled by pino: a lookup per credential key at the top of the line, and one
+wildcard pass for the level below, whose censor looks at the name of each key. A wildcard path
+per key would be the obvious way to write it and costs ten times more: measured on pino 10,
+thirteen of them take a line from about one microsecond to about nine. Log calls never throw: fields that cannot be read or serialized
+(a getter that throws) give the line without them, marked `logError: "unserializable fields"`.
+
+## Which one
+
+Take `StdoutLogger` of the aspects package when JSON lines on the standard output are all you
+need: no dependency, the same line shape. Take pino when logging volume matters, when the
+framework already speaks pino (Fastify), or when you want its transports. Take
+`@ddd-ts-kit/winston` when the team already runs winston transports and formats. The three
+implement one port and are held by one contract suite: swapping is one line of the composition
+root.
+
+## NestJS
+
+Nest has its own `LoggerService`, used by the framework for its own messages and by
+`new Logger(context)` in Nest classes. Application code of the kit never needs it: handlers and
+adapters receive the kernel `Logger`. To send what Nest itself logs through the same instance,
+hand it a bridge of a few lines; the kit ships none, since it would bind this package to Nest:
+
+```ts
+const nest = logger.child({ context: 'nest' });
+const bridge: LoggerService = {
+  log: (message: unknown) => nest.info(String(message)),
+  warn: (message: unknown) => nest.warn(String(message)),
+  error: (message: unknown) => nest.error(String(message)),
+  debug: (message: unknown) => nest.debug(String(message)),
+};
+
+const app = await NestFactory.create(AppModule, { logger: bridge });
+```
+
+`nestjs-pino` is the alternative when Nest classes log a lot: give it the pino instance you
+built, and wrap the same instance in `new PinoLogger(instance)` for the kit.
+
+## In a test
+
+Nothing of this package: the test application binds `InMemoryLogger` of the kernel, and its
+`entries` are data. To hold another adapter of the port to the same behaviour, run the contract:
+
+```ts
+import { loggerContract } from '@ddd-ts-kit/testing/contracts';
+
+loggerContract({ describe, it, expect, beforeEach }, {
+  name: 'PinoLogger',
+  createLogger: (setup) => { // { level, fields, scrubMessages }
+    const written: string[] = [];
+    const logger = createPinoLogger({ ...setup, destination: { write: (line) => written.push(line) } });
+
+    return { logger, lines: () => written.map((line) => lineOf(JSON.parse(line))) }; // { level, message, fields }
+  },
+});
+```

package/dist/correlation/correlation-mixin.d.ts

@@ -0,0 +1,7 @@
+import type { LogFields } from '@ddd-ts-kit/kernel';
+/**
+ * A pino `mixin` reading the fields of the work in progress at each line that is written. A
+ * source that throws (no active span, no execution context) gives no field, never a lost line.
+ */
+export declare function correlationMixin(fields: () => LogFields): () => LogFields;
+//# sourceMappingURL=correlation-mixin.d.ts.map

package/dist/correlation/correlation-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-mixin.d.ts","sourceRoot":"","sources":["../../src/correlation/correlation-mixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,SAAS,GAAG,MAAM,SAAS,CASzE"}

package/dist/correlation/correlation-mixin.js

@@ -0,0 +1,16 @@
+/**
+ * A pino `mixin` reading the fields of the work in progress at each line that is written. A
+ * source that throws (no active span, no execution context) gives no field, never a lost line.
+ */
+export function correlationMixin(fields) {
+    return () => {
+        try {
+            // A copy: pino merges the fields of the line into the object the mixin answers.
+            return { ...fields() };
+        }
+        catch {
+            return {};
+        }
+    };
+}
+//# sourceMappingURL=correlation-mixin.js.map

package/dist/correlation/correlation-mixin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-mixin.js","sourceRoot":"","sources":["../../src/correlation/correlation-mixin.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAuB;IACtD,OAAO,GAAG,EAAE;QACV,IAAI,CAAC;YACH,gFAAgF;YAChF,OAAO,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/create-pino-logger.d.ts

@@ -0,0 +1,41 @@
+import { type LogFields, type LogLevel } from '@ddd-ts-kit/kernel';
+import { type DestinationStream } from 'pino';
+import { PinoLogger, type PinoLoggerOptions } from './pino-logger.js';
+export interface CreatePinoLoggerOptions extends PinoLoggerOptions {
+    /** Entries below it are not written. Default `info`. */
+    readonly level?: LogLevel;
+    /**
+     * `json`: one JSON object per line, what a container platform collects. `pretty`: lines for
+     * a human, through the `pino-pretty` transport, which must then be installed. Default `json`.
+     */
+    readonly format?: 'json' | 'pretty';
+    /** Written on every line as `service`. */
+    readonly service?: string;
+    /** Written on every line as `environment`. */
+    readonly environment?: string;
+    /** Added to every line next to `service` and `environment`: version, region. */
+    readonly base?: LogFields;
+    /**
+     * Read at each line that is written: correlation fields of the work in progress, such as
+     * `traceLogFields` of the tracing package or `logFieldsOf` of the current execution context.
+     */
+    readonly fields?: () => LogFields;
+    /** Field names hidden in addition to `CREDENTIAL_KEYS`, at the top of a line and one level below. */
+    readonly redact?: readonly string[];
+    /**
+     * Buffers the lines and writes them off the hot path. Default `false`: every line is
+     * written before the call returns. See "Performance" in the README for what a crash loses.
+     */
+    readonly asynchronous?: boolean;
+    /**
+     * A stream, a file descriptor or a path. Default: the standard output. The `pretty` format
+     * runs in a worker thread and takes a descriptor or a path only.
+     */
+    readonly destination?: DestinationStream | number | string;
+}
+/**
+ * A `PinoLogger` on a pino instance with the defaults of the kit: `time` in ISO 8601, `level`
+ * by its name, `message`, then the fields; credentials redacted; errors described once.
+ */
+export declare function createPinoLogger(options?: CreatePinoLoggerOptions): PinoLogger;
+//# sourceMappingURL=create-pino-logger.d.ts.map

package/dist/create-pino-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pino-logger.d.ts","sourceRoot":"","sources":["../src/create-pino-logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAQ,KAAK,iBAAiB,EAAsB,MAAM,MAAM,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,MAAM,WAAW,uBAAwB,SAAQ,iBAAiB;IAChE,wDAAwD;IACxD,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,gFAAgF;IAChF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,SAAS,CAAC;IAClC,qGAAqG;IACrG,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,GAAG,MAAM,GAAG,MAAM,CAAC;CAC5D;AAKD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,UAAU,CAOlF"}

package/dist/create-pino-logger.js

@@ -0,0 +1,58 @@
+import { CREDENTIAL_KEYS } from '@ddd-ts-kit/kernel';
+import { pino } from 'pino';
+import { correlationMixin } from './correlation/correlation-mixin.js';
+import { PinoLogger } from './pino-logger.js';
+import { credentialRedaction } from './redaction/credential-redaction.js';
+const STANDARD_OUTPUT = 1;
+const BUFFERED_BYTES = 4096;
+/**
+ * A `PinoLogger` on a pino instance with the defaults of the kit: `time` in ISO 8601, `level`
+ * by its name, `message`, then the fields; credentials redacted; errors described once.
+ */
+export function createPinoLogger(options = {}) {
+    const instance = pino(pinoOptions(options), options.format === 'pretty' ? prettyTransport(options) : destinationOf(options));
+    return new PinoLogger(instance, options.scrubMessages === undefined ? {} : { scrubMessages: options.scrubMessages });
+}
+function pinoOptions(options) {
+    return {
+        level: options.level ?? 'info',
+        messageKey: 'message',
+        timestamp: pino.stdTimeFunctions.isoTime,
+        base: baseFields(options),
+        formatters: { level: (label) => ({ level: label }) },
+        redact: credentialRedaction([...CREDENTIAL_KEYS, ...(options.redact ?? [])]),
+        ...(options.fields === undefined ? {} : { mixin: correlationMixin(options.fields) }),
+    };
+}
+function baseFields(options) {
+    return {
+        ...(options.service === undefined ? {} : { service: options.service }),
+        ...(options.environment === undefined ? {} : { environment: options.environment }),
+        ...options.base,
+    };
+}
+function prettyTransport(options) {
+    if (typeof options.destination === 'object') {
+        throw new TypeError('The pretty format writes to a file descriptor or a path: pino-pretty runs in a worker thread');
+    }
+    return pino.transport({
+        target: 'pino-pretty',
+        options: {
+            destination: options.destination ?? STANDARD_OUTPUT,
+            messageKey: 'message',
+            translateTime: 'SYS:HH:MM:ss.l',
+            sync: options.asynchronous !== true,
+        },
+    });
+}
+function destinationOf(options) {
+    if (typeof options.destination === 'object') {
+        return options.destination;
+    }
+    return pino.destination({
+        dest: options.destination ?? STANDARD_OUTPUT,
+        sync: options.asynchronous !== true,
+        ...(options.asynchronous === true ? { minLength: BUFFERED_BYTES } : {}),
+    });
+}
+//# sourceMappingURL=create-pino-logger.js.map

package/dist/create-pino-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pino-logger.js","sourceRoot":"","sources":["../src/create-pino-logger.ts"],"names":[],"mappings":"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"}

package/dist/fields/line-fields.d.ts

@@ -0,0 +1,8 @@
+import { type DescribeErrorOptions, type LogFields, type LogValue } from '@ddd-ts-kit/kernel';
+/**
+ * The fields as pino receives them: errors described, and no key that would forge the header.
+ * pino writes `level` and `time` before the fields: a field of that name would be a second key
+ * of the line, and the last one is read.
+ */
+export declare function lineFields(fields: LogFields, options: DescribeErrorOptions): Record<string, LogValue>;
+//# sourceMappingURL=line-fields.d.ts.map

package/dist/fields/line-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-fields.d.ts","sourceRoot":"","sources":["../../src/fields/line-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAIrG"}

package/dist/fields/line-fields.js

@@ -0,0 +1,11 @@
+import { describeErrorFields } from '@ddd-ts-kit/kernel';
+/**
+ * The fields as pino receives them: errors described, and no key that would forge the header.
+ * pino writes `level` and `time` before the fields: a field of that name would be a second key
+ * of the line, and the last one is read.
+ */
+export function lineFields(fields, options) {
+    const { level: _level, time: _time, ...line } = describeErrorFields(fields, options);
+    return line;
+}
+//# sourceMappingURL=line-fields.js.map

package/dist/fields/line-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-fields.js","sourceRoot":"","sources":["../../src/fields/line-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAA4D,MAAM,oBAAoB,CAAC;AAEnH;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,MAAiB,EAAE,OAA6B;IACzE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAErF,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { correlationMixin } from './correlation/correlation-mixin.js';
+export { createPinoLogger, type CreatePinoLoggerOptions } from './create-pino-logger.js';
+export { PinoLogger, type PinoLoggerOptions } from './pino-logger.js';
+export { credentialRedaction, type CredentialRedaction } from './redaction/credential-redaction.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACzF,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { correlationMixin } from './correlation/correlation-mixin.js';
+export { createPinoLogger } from './create-pino-logger.js';
+export { PinoLogger } from './pino-logger.js';
+export { credentialRedaction } from './redaction/credential-redaction.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAgC,MAAM,yBAAyB,CAAC;AACzF,OAAO,EAAE,UAAU,EAA0B,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAA4B,MAAM,qCAAqC,CAAC"}

package/dist/pino-logger.d.ts

@@ -0,0 +1,36 @@
+import { type LogFields, type LogLevel, type Logger } from '@ddd-ts-kit/kernel';
+import type { Logger as Pino } from 'pino';
+export interface PinoLoggerOptions {
+    /**
+     * Writes `SCRUBBED_MESSAGE` for the message of every logged error that is not a
+     * `DomainError`. Default `false`: see "Privacy" in the README for the trade-off.
+     */
+    readonly scrubMessages?: boolean;
+}
+/**
+ * The `Logger` port on a pino instance: the levels of the port are those of pino, a child is
+ * a pino child, and what the instance was configured with (mixin, redaction, destination)
+ * applies to every line. `createPinoLogger` builds one with the defaults of the kit; build it
+ * yourself around an instance you configured.
+ */
+export declare class PinoLogger implements Logger {
+    private readonly options;
+    private readonly pino;
+    constructor(pino: Pino, options?: PinoLoggerOptions);
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+    child(fields: LogFields): PinoLogger;
+    /** The threshold of the instance, followed when it changes while running. */
+    isLevelEnabled(level: LogLevel): boolean;
+    /**
+     * Resolves once what pino buffered was handed to its destination. Never rejects, and the
+     * logger stays usable: an entry logged afterwards is written like the others.
+     */
+    flush(): Promise<void>;
+    private nativeChild;
+    private write;
+    private writeWithoutFields;
+}
+//# sourceMappingURL=pino-logger.d.ts.map

package/dist/pino-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino-logger.d.ts","sourceRoot":"","sources":["../src/pino-logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,KAAK,EAAE,MAAM,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAG3C,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAKD;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,MAAM;IAKrC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAO;IAE5B,YACE,IAAI,EAAE,IAAI,EACO,OAAO,GAAE,iBAAsB,EAGjD;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAE/C;IAED,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAE9C;IAED,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAE9C;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAE/C;IAED,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAMnC;IAED,6EAA6E;IAC7E,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAEvC;IAED;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAUrB;IAED,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,KAAK;IAYb,OAAO,CAAC,kBAAkB;CAO3B"}

package/dist/pino-logger.js

@@ -0,0 +1,91 @@
+import { UNWRITABLE_FIELDS } from '@ddd-ts-kit/kernel';
+import { lineFields } from './fields/line-fields.js';
+/** Children of an instance the adapter already prepared: they are adopted as they are. */
+const adopted = new WeakSet();
+/**
+ * The `Logger` port on a pino instance: the levels of the port are those of pino, a child is
+ * a pino child, and what the instance was configured with (mixin, redaction, destination)
+ * applies to every line. `createPinoLogger` builds one with the defaults of the kit; build it
+ * yourself around an instance you configured.
+ */
+export class PinoLogger {
+    options;
+    pino;
+    constructor(pino, options = {}) {
+        this.options = options;
+        this.pino = adopted.has(pino) ? pino : describingErrorsItself(pino);
+    }
+    debug(message, fields) {
+        this.write('debug', message, fields);
+    }
+    info(message, fields) {
+        this.write('info', message, fields);
+    }
+    warn(message, fields) {
+        this.write('warn', message, fields);
+    }
+    error(message, fields) {
+        this.write('error', message, fields);
+    }
+    child(fields) {
+        const child = this.nativeChild(fields);
+        adopted.add(child);
+        return new PinoLogger(child, this.options);
+    }
+    /** The threshold of the instance, followed when it changes while running. */
+    isLevelEnabled(level) {
+        return this.pino.isLevelEnabled(level);
+    }
+    /**
+     * Resolves once what pino buffered was handed to its destination. Never rejects, and the
+     * logger stays usable: an entry logged afterwards is written like the others.
+     */
+    flush() {
+        return new Promise((resolve) => {
+            try {
+                this.pino.flush(() => {
+                    resolve();
+                });
+            }
+            catch {
+                resolve();
+            }
+        });
+    }
+    nativeChild(fields) {
+        try {
+            return this.pino.child(lineFields(fields, this.options));
+        }
+        catch {
+            return this.pino.child(UNWRITABLE_FIELDS);
+        }
+    }
+    write(level, message, fields = {}) {
+        if (!this.isLevelEnabled(level)) {
+            return;
+        }
+        try {
+            this.pino[level](lineFields(fields, this.options), message);
+        }
+        catch {
+            this.writeWithoutFields(level, message);
+        }
+    }
+    writeWithoutFields(level, message) {
+        try {
+            this.pino[level](UNWRITABLE_FIELDS, message);
+        }
+        catch {
+            return;
+        }
+    }
+}
+/**
+ * The adapter describes errors before pino sees them. Left in place, the standard serializer
+ * of the `err` key would take that description for an error and describe it a second time,
+ * folding the causes into one message and one stack.
+ */
+function describingErrorsItself(pino) {
+    return pino.child({}, { serializers: { err: (description) => description } });
+}
+//# sourceMappingURL=pino-logger.js.map

package/dist/pino-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino-logger.js","sourceRoot":"","sources":["../src/pino-logger.ts"],"names":[],"mappings":"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"}

package/dist/redaction/credential-redaction.d.ts

@@ -0,0 +1,13 @@
+/** A value for the `redact` option of pino. */
+export interface CredentialRedaction {
+    readonly paths: string[];
+    censor(value: unknown, path: readonly string[]): unknown;
+}
+/**
+ * The pino `redact` option hiding the given keys at the top of a line and one level below, in
+ * the fields of an entry, of a child and of the mixin alike. Names are matched exactly, case
+ * included. The level below is one wildcard path whose censor looks at the name of the key:
+ * a wildcard path per key would cost pino as many passes over each line.
+ */
+export declare function credentialRedaction(keys?: readonly string[]): CredentialRedaction;
+//# sourceMappingURL=credential-redaction.d.ts.map

package/dist/redaction/credential-redaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-redaction.d.ts","sourceRoot":"","sources":["../../src/redaction/credential-redaction.ts"],"names":[],"mappings":"AAEA,+CAA+C;AAC/C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC;CAC1D;AAID;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,SAAS,MAAM,EAAoB,GAAG,mBAAmB,CAOlG"}

package/dist/redaction/credential-redaction.js

@@ -0,0 +1,16 @@
+import { CREDENTIAL_KEYS, REDACTED } from '@ddd-ts-kit/kernel';
+const ONE_LEVEL_BELOW = '*.*';
+/**
+ * The pino `redact` option hiding the given keys at the top of a line and one level below, in
+ * the fields of an entry, of a child and of the mixin alike. Names are matched exactly, case
+ * included. The level below is one wildcard path whose censor looks at the name of the key:
+ * a wildcard path per key would cost pino as many passes over each line.
+ */
+export function credentialRedaction(keys = CREDENTIAL_KEYS) {
+    const hidden = new Set(keys);
+    return {
+        paths: [...[...hidden].map((key) => `["${key}"]`), ONE_LEVEL_BELOW],
+        censor: (value, path) => (hidden.has(path.at(-1) ?? '') ? REDACTED : value),
+    };
+}
+//# sourceMappingURL=credential-redaction.js.map

package/dist/redaction/credential-redaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-redaction.js","sourceRoot":"","sources":["../../src/redaction/credential-redaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAQ/D,MAAM,eAAe,GAAG,KAAK,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAI,GAAsB,eAAe;IAC3E,MAAM,MAAM,GAAwB,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IAElD,OAAO;QACL,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,eAAe,CAAC;QACnE,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;KAC5E,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@ddd-ts-kit/pino",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Adapter of the kernel Logger port on pino, with trace and execution correlation on every line.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gbourgeat/ddd-ts-kit.git",
+    "directory": "packages/pino"
+  },
+  "homepage": "https://github.com/gbourgeat/ddd-ts-kit/tree/main/packages/pino#readme",
+  "bugs": "https://github.com/gbourgeat/ddd-ts-kit/issues",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@ddd-ts-kit/kernel": "0.1.1"
+  },
+  "devDependencies": {
+    "@ddd-ts-kit/testing": "0.1.1",
+    "pino": "^10.4.0",
+    "pino-pretty": "^13.2.0"
+  },
+  "peerDependencies": {
+    "pino": "^10.4.0",
+    "pino-pretty": "^13.2.0"
+  },
+  "peerDependenciesMeta": {
+    "pino-pretty": {
+      "optional": true
+    }
+  }
+}