@webpieces/bunyan 0.3.307

package/README.md

@@ -0,0 +1,44 @@
+# @webpieces/bunyan
+
+Node-only [bunyan](https://github.com/trentm/node-bunyan) backends for the webpieces
+pluggable logging seam (`LoggerFactory` → `Logger` from `@webpieces/core-util`).
+
+Two factories, both auto-enriching every line with the logged context keys registered in
+`HeaderRegistry`:
+
+- **`BunyanConsoleFactory`** — local dev: human-readable, greppable text to stdout,
+  `[LEVEL][time][ctx tags]: message` + multi-line error details.
+- **`BunyanGcpFactory`** — GCP: streams to Cloud Logging via
+  [`@google-cloud/logging-bunyan`](https://github.com/googleapis/nodejs-logging-bunyan),
+  which owns the numeric-level→severity mapping and structured payload. Registered context
+  keys ride along as payload fields. This mirrors the tested-in-GCP `trytami` service.
+
+## Usage
+
+```ts
+import { LogManager, HeaderRegistry } from '@webpieces/core-util';
+import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
+import { RequestContextReader } from '@webpieces/core-context';
+
+const reader = new RequestContextReader();
+const loggerFactory = process.env.K_SERVICE
+    ? new BunyanGcpFactory(reader)
+    : new BunyanConsoleFactory(reader);
+
+// Typically you pass loggerFactory to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...)),
+// which calls HeaderRegistry.configure(...) then LogManager.setFactory(loggerFactory) for you.
+```
+
+The `ContextReader` is a **constructor argument** (the node `RequestContextReader` lives in
+`@webpieces/core-context`) so this package depends only on `@webpieces/core-util` — not on
+any node context package.
+
+`BunyanGcpFactory` sends to the Cloud Logging API and needs GCP Application Default
+Credentials on the instance (automatic on Cloud Run), exactly as the source service runs.
+
+## Options
+
+`new BunyanGcpFactory(reader, new BunyanFactoryOptions(level, serviceName))`:
+
+- `level` — minimum webpieces level to emit (default `'info'`).
+- `serviceName` — the bunyan logger `name` (default `'webpieces'`), surfaced in the payload.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@webpieces/bunyan",
+  "version": "0.3.307",
+  "description": "Node-only bunyan LoggerFactory backends for webpieces: Console (local pretty) + GCP (@google-cloud/logging-bunyan), auto-enriched with HeaderRegistry context keys",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "author": "Dean Hiller",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deanhiller/webpieces-ts.git",
+    "directory": "packages/logging/bunyan"
+  },
+  "keywords": [
+    "webpieces",
+    "bunyan",
+    "logging",
+    "gcp",
+    "cloud-logging"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@webpieces/core-util": "0.3.307",
+    "bunyan": "1.8.15",
+    "@google-cloud/logging-bunyan": "5.1.0",
+    "@types/bunyan": "1.8.11"
+  }
+}

package/src/BunyanConsoleFactory.d.ts

@@ -0,0 +1,15 @@
+import type { ContextReader } from '@webpieces/core-util';
+import { BunyanFactoryBase } from './BunyanFactoryBase';
+import { BunyanFactoryOptions } from './BunyanFactoryOptions';
+/**
+ * BunyanConsoleFactory - the LOCAL developer backend. Human-readable, greppable
+ * text to stdout (`[LEVEL][time][ctx tags]: message`) with the registered context
+ * keys as tags — same enrichment as the GCP backend, different rendering. Mirrors
+ * the tested trytami local console stream.
+ *
+ * @param reader the environment's ContextReader (on a node server, a
+ *   `RequestContextReader` from @webpieces/core-context).
+ */
+export declare class BunyanConsoleFactory extends BunyanFactoryBase {
+    constructor(reader: ContextReader, opts?: BunyanFactoryOptions);
+}

package/src/BunyanConsoleFactory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunyanConsoleFactory = void 0;
+const BunyanFactoryBase_1 = require("./BunyanFactoryBase");
+const BunyanFactoryOptions_1 = require("./BunyanFactoryOptions");
+const streams_1 = require("./streams");
+/**
+ * BunyanConsoleFactory - the LOCAL developer backend. Human-readable, greppable
+ * text to stdout (`[LEVEL][time][ctx tags]: message`) with the registered context
+ * keys as tags — same enrichment as the GCP backend, different rendering. Mirrors
+ * the tested trytami local console stream.
+ *
+ * @param reader the environment's ContextReader (on a node server, a
+ *   `RequestContextReader` from @webpieces/core-context).
+ */
+class BunyanConsoleFactory extends BunyanFactoryBase_1.BunyanFactoryBase {
+    constructor(reader, opts = new BunyanFactoryOptions_1.BunyanFactoryOptions()) {
+        super(reader, opts.serviceName, [(0, streams_1.createConsoleStream)(opts.level)]);
+    }
+}
+exports.BunyanConsoleFactory = BunyanConsoleFactory;
+//# sourceMappingURL=BunyanConsoleFactory.js.map

package/src/BunyanConsoleFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunyanConsoleFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanConsoleFactory.ts"],"names":[],"mappings":";;;AACA,2DAAwD;AACxD,iEAA8D;AAC9D,uCAAgD;AAEhD;;;;;;;;GAQG;AACH,MAAa,oBAAqB,SAAQ,qCAAiB;IACvD,YAAY,MAAqB,EAAE,OAA6B,IAAI,2CAAoB,EAAE;QACtF,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,IAAA,6BAAmB,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvE,CAAC;CACJ;AAJD,oDAIC","sourcesContent":["import type { ContextReader } from '@webpieces/core-util';\nimport { BunyanFactoryBase } from './BunyanFactoryBase';\nimport { BunyanFactoryOptions } from './BunyanFactoryOptions';\nimport { createConsoleStream } from './streams';\n\n/**\n * BunyanConsoleFactory - the LOCAL developer backend. Human-readable, greppable\n * text to stdout (`[LEVEL][time][ctx tags]: message`) with the registered context\n * keys as tags — same enrichment as the GCP backend, different rendering. Mirrors\n * the tested trytami local console stream.\n *\n * @param reader the environment's ContextReader (on a node server, a\n *   `RequestContextReader` from @webpieces/core-context).\n */\nexport class BunyanConsoleFactory extends BunyanFactoryBase {\n    constructor(reader: ContextReader, opts: BunyanFactoryOptions = new BunyanFactoryOptions()) {\n        super(reader, opts.serviceName, [createConsoleStream(opts.level)]);\n    }\n}\n"]}

package/src/BunyanFactoryBase.d.ts

@@ -0,0 +1,16 @@
+import Logger from 'bunyan';
+import type { ContextReader, Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';
+/**
+ * BunyanFactoryBase - shared plumbing for the bunyan {@link LoggerFactory}
+ * backends. Builds ONE underlying bunyan logger with the caller-chosen stream,
+ * then hands out a cached {@link BunyanLogger} per name (each a bunyan child
+ * carrying `loggerName`, wrapping the shared ContextReader). Subclasses differ
+ * only in the stream they pass up (GCP vs local console).
+ */
+export declare abstract class BunyanFactoryBase implements LoggerFactory {
+    private readonly reader;
+    private readonly base;
+    private readonly loggers;
+    protected constructor(reader: ContextReader, name: string, streams: Logger.Stream[]);
+    getLogger(name: string): WpLogger;
+}

package/src/BunyanFactoryBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunyanFactoryBase = void 0;
+const tslib_1 = require("tslib");
+const bunyan_1 = tslib_1.__importDefault(require("bunyan"));
+const BunyanLogger_1 = require("./BunyanLogger");
+/**
+ * BunyanFactoryBase - shared plumbing for the bunyan {@link LoggerFactory}
+ * backends. Builds ONE underlying bunyan logger with the caller-chosen stream,
+ * then hands out a cached {@link BunyanLogger} per name (each a bunyan child
+ * carrying `loggerName`, wrapping the shared ContextReader). Subclasses differ
+ * only in the stream they pass up (GCP vs local console).
+ */
+class BunyanFactoryBase {
+    reader;
+    base;
+    loggers = new Map();
+    constructor(reader, name, streams) {
+        this.reader = reader;
+        this.base = bunyan_1.default.createLogger({ name, streams });
+    }
+    getLogger(name) {
+        let logger = this.loggers.get(name);
+        if (!logger) {
+            logger = new BunyanLogger_1.BunyanLogger(this.base.child({ loggerName: name }), this.reader);
+            this.loggers.set(name, logger);
+        }
+        return logger;
+    }
+}
+exports.BunyanFactoryBase = BunyanFactoryBase;
+//# sourceMappingURL=BunyanFactoryBase.js.map

package/src/BunyanFactoryBase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunyanFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryBase.ts"],"names":[],"mappings":";;;;AAAA,4DAA4B;AAE5B,iDAA8C;AAE9C;;;;;;GAMG;AACH,MAAsB,iBAAiB;IAKd;IAJJ,IAAI,CAAS;IACb,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEvD,YACqB,MAAqB,EACtC,IAAY,EACZ,OAAwB;QAFP,WAAM,GAAN,MAAM,CAAe;QAItC,IAAI,CAAC,IAAI,GAAG,gBAAM,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;IACvD,CAAC;IAED,SAAS,CAAC,IAAY;QAClB,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,GAAG,IAAI,2BAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAC9E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AApBD,8CAoBC","sourcesContent":["import Logger from 'bunyan';\nimport type { ContextReader, Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';\nimport { BunyanLogger } from './BunyanLogger';\n\n/**\n * BunyanFactoryBase - shared plumbing for the bunyan {@link LoggerFactory}\n * backends. Builds ONE underlying bunyan logger with the caller-chosen stream,\n * then hands out a cached {@link BunyanLogger} per name (each a bunyan child\n * carrying `loggerName`, wrapping the shared ContextReader). Subclasses differ\n * only in the stream they pass up (GCP vs local console).\n */\nexport abstract class BunyanFactoryBase implements LoggerFactory {\n    private readonly base: Logger;\n    private readonly loggers = new Map<string, WpLogger>();\n\n    protected constructor(\n        private readonly reader: ContextReader,\n        name: string,\n        streams: Logger.Stream[],\n    ) {\n        this.base = Logger.createLogger({ name, streams });\n    }\n\n    getLogger(name: string): WpLogger {\n        let logger = this.loggers.get(name);\n        if (!logger) {\n            logger = new BunyanLogger(this.base.child({ loggerName: name }), this.reader);\n            this.loggers.set(name, logger);\n        }\n        return logger;\n    }\n}\n"]}

package/src/BunyanFactoryOptions.d.ts

@@ -0,0 +1,24 @@
+import type { LogLevel } from '@webpieces/core-util';
+/**
+ * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
+ *
+ * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare
+ * `new BunyanGcpFactory(reader)` uses the defaults.
+ */
+export declare class BunyanFactoryOptions {
+    /** Minimum webpieces level to emit. Defaults to 'info'. */
+    readonly level: LogLevel;
+    /**
+     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
+     * payload). Defaults to 'webpieces'.
+     */
+    readonly serviceName: string;
+    constructor(
+    /** Minimum webpieces level to emit. Defaults to 'info'. */
+    level?: LogLevel, 
+    /**
+     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
+     * payload). Defaults to 'webpieces'.
+     */
+    serviceName?: string);
+}

package/src/BunyanFactoryOptions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunyanFactoryOptions = void 0;
+/**
+ * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
+ *
+ * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare
+ * `new BunyanGcpFactory(reader)` uses the defaults.
+ */
+class BunyanFactoryOptions {
+    level;
+    serviceName;
+    constructor(
+    /** Minimum webpieces level to emit. Defaults to 'info'. */
+    level = 'info', 
+    /**
+     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
+     * payload). Defaults to 'webpieces'.
+     */
+    serviceName = 'webpieces') {
+        this.level = level;
+        this.serviceName = serviceName;
+    }
+}
+exports.BunyanFactoryOptions = BunyanFactoryOptions;
+//# sourceMappingURL=BunyanFactoryOptions.js.map

package/src/BunyanFactoryOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunyanFactoryOptions.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryOptions.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACH,MAAa,oBAAoB;IAGT;IAKA;IAPpB;IACI,2DAA2D;IAC3C,QAAkB,MAAM;IACxC;;;OAGG;IACa,cAAsB,WAAW;QALjC,UAAK,GAAL,KAAK,CAAmB;QAKxB,gBAAW,GAAX,WAAW,CAAsB;IAClD,CAAC;CACP;AAVD,oDAUC","sourcesContent":["import type { LogLevel } from '@webpieces/core-util';\n\n/**\n * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.\n *\n * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare\n * `new BunyanGcpFactory(reader)` uses the defaults.\n */\nexport class BunyanFactoryOptions {\n    constructor(\n        /** Minimum webpieces level to emit. Defaults to 'info'. */\n        public readonly level: LogLevel = 'info',\n        /**\n         * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON\n         * payload). Defaults to 'webpieces'.\n         */\n        public readonly serviceName: string = 'webpieces',\n    ) {}\n}\n"]}

package/src/BunyanGcpFactory.d.ts

@@ -0,0 +1,17 @@
+import type { ContextReader } from '@webpieces/core-util';
+import { BunyanFactoryBase } from './BunyanFactoryBase';
+import { BunyanFactoryOptions } from './BunyanFactoryOptions';
+/**
+ * BunyanGcpFactory - the GCP backend. Streams to Cloud Logging via
+ * @google-cloud/logging-bunyan (which owns the numeric-level→severity mapping,
+ * msg→message, trace/httpRequest fields). Registered context keys ride along as
+ * structured payload fields. This matches the tested-in-GCP trytami service
+ * exactly. Requires GCP Application Default Credentials on the instance.
+ *
+ * @param reader the environment's ContextReader — on a node server pass
+ *   `new RequestContextReader()` from @webpieces/core-context. Keeping it a
+ *   constructor arg is why this package depends only on @webpieces/core-util.
+ */
+export declare class BunyanGcpFactory extends BunyanFactoryBase {
+    constructor(reader: ContextReader, opts?: BunyanFactoryOptions);
+}

package/src/BunyanGcpFactory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunyanGcpFactory = void 0;
+const BunyanFactoryBase_1 = require("./BunyanFactoryBase");
+const BunyanFactoryOptions_1 = require("./BunyanFactoryOptions");
+const streams_1 = require("./streams");
+/**
+ * BunyanGcpFactory - the GCP backend. Streams to Cloud Logging via
+ * @google-cloud/logging-bunyan (which owns the numeric-level→severity mapping,
+ * msg→message, trace/httpRequest fields). Registered context keys ride along as
+ * structured payload fields. This matches the tested-in-GCP trytami service
+ * exactly. Requires GCP Application Default Credentials on the instance.
+ *
+ * @param reader the environment's ContextReader — on a node server pass
+ *   `new RequestContextReader()` from @webpieces/core-context. Keeping it a
+ *   constructor arg is why this package depends only on @webpieces/core-util.
+ */
+class BunyanGcpFactory extends BunyanFactoryBase_1.BunyanFactoryBase {
+    constructor(reader, opts = new BunyanFactoryOptions_1.BunyanFactoryOptions()) {
+        super(reader, opts.serviceName, [(0, streams_1.createGoogleCloudStream)(opts.level)]);
+    }
+}
+exports.BunyanGcpFactory = BunyanGcpFactory;
+//# sourceMappingURL=BunyanGcpFactory.js.map

package/src/BunyanGcpFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunyanGcpFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanGcpFactory.ts"],"names":[],"mappings":";;;AACA,2DAAwD;AACxD,iEAA8D;AAC9D,uCAAoD;AAEpD;;;;;;;;;;GAUG;AACH,MAAa,gBAAiB,SAAQ,qCAAiB;IACnD,YAAY,MAAqB,EAAE,OAA6B,IAAI,2CAAoB,EAAE;QACtF,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,IAAA,iCAAuB,EAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC3E,CAAC;CACJ;AAJD,4CAIC","sourcesContent":["import type { ContextReader } from '@webpieces/core-util';\nimport { BunyanFactoryBase } from './BunyanFactoryBase';\nimport { BunyanFactoryOptions } from './BunyanFactoryOptions';\nimport { createGoogleCloudStream } from './streams';\n\n/**\n * BunyanGcpFactory - the GCP backend. Streams to Cloud Logging via\n * @google-cloud/logging-bunyan (which owns the numeric-level→severity mapping,\n * msg→message, trace/httpRequest fields). Registered context keys ride along as\n * structured payload fields. This matches the tested-in-GCP trytami service\n * exactly. Requires GCP Application Default Credentials on the instance.\n *\n * @param reader the environment's ContextReader — on a node server pass\n *   `new RequestContextReader()` from @webpieces/core-context. Keeping it a\n *   constructor arg is why this package depends only on @webpieces/core-util.\n */\nexport class BunyanGcpFactory extends BunyanFactoryBase {\n    constructor(reader: ContextReader, opts: BunyanFactoryOptions = new BunyanFactoryOptions()) {\n        super(reader, opts.serviceName, [createGoogleCloudStream(opts.level)]);\n    }\n}\n"]}

package/src/BunyanLogger.d.ts

@@ -0,0 +1,23 @@
+import type Logger from 'bunyan';
+import type { ContextReader, Logger as WpLogger } from '@webpieces/core-util';
+/**
+ * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per
+ * name, created as a bunyan child carrying `loggerName`). On every call it merges
+ * the logged HeaderRegistry context keys (read through the ContextReader, secured
+ * values masked) into the bunyan fields object, and normalizes an optional Error
+ * into `err: { name, message, stack }` — matching the tested trytami AppLogger.
+ * The GCP stream then serializes those fields into the structured log payload.
+ */
+export declare class BunyanLogger implements WpLogger {
+    private readonly bunyan;
+    private readonly reader;
+    private readonly headerMethods;
+    private loggedKeys?;
+    constructor(bunyan: Logger, reader: ContextReader);
+    trace(message: string, err?: Error): void;
+    debug(message: string, err?: Error): void;
+    info(message: string, err?: Error): void;
+    warn(message: string, err?: Error): void;
+    error(message: string, err?: Error): void;
+    private buildFields;
+}

package/src/BunyanLogger.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunyanLogger = void 0;
+const core_util_1 = require("@webpieces/core-util");
+const LoggedError_1 = require("./LoggedError");
+// Above this serialized size the error is truncated, so one giant stack can't
+// blow up a log line (ported from the tested trytami AppLogger).
+const MAX_ERR_SERIALIZED = 100_000;
+function truncateStack(stack, maxLines = 5) {
+    if (!stack) {
+        return '';
+    }
+    return stack.split('\n').slice(0, maxLines).join('\n');
+}
+function normalizeError(err) {
+    const full = new LoggedError_1.LoggedError(err.name, err.message, err.stack);
+    if (JSON.stringify({ err: full }).length <= MAX_ERR_SERIALIZED) {
+        return full;
+    }
+    return new LoggedError_1.LoggedError(`error too long: ${err.name}`, err.message.substring(0, 100), truncateStack(err.stack, 5));
+}
+/**
+ * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per
+ * name, created as a bunyan child carrying `loggerName`). On every call it merges
+ * the logged HeaderRegistry context keys (read through the ContextReader, secured
+ * values masked) into the bunyan fields object, and normalizes an optional Error
+ * into `err: { name, message, stack }` — matching the tested trytami AppLogger.
+ * The GCP stream then serializes those fields into the structured log payload.
+ */
+class BunyanLogger {
+    bunyan;
+    reader;
+    headerMethods = new core_util_1.HeaderMethods();
+    loggedKeys;
+    constructor(bunyan, reader) {
+        this.bunyan = bunyan;
+        this.reader = reader;
+    }
+    trace(message, err) {
+        this.bunyan.trace(this.buildFields(err), message);
+    }
+    debug(message, err) {
+        this.bunyan.debug(this.buildFields(err), message);
+    }
+    info(message, err) {
+        this.bunyan.info(this.buildFields(err), message);
+    }
+    warn(message, err) {
+        this.bunyan.warn(this.buildFields(err), message);
+    }
+    error(message, err) {
+        this.bunyan.error(this.buildFields(err), message);
+    }
+    // Registry keys are read LAZILY (first log) — a LoggerFactory is built before
+    // setupRuntime calls HeaderRegistry.configure.
+    buildFields(err) {
+        if (!this.loggedKeys) {
+            this.loggedKeys = core_util_1.HeaderRegistry.get().getLoggedKeys();
+        }
+        const fields = {};
+        const logMap = this.headerMethods.buildSecureMapForLogs(this.loggedKeys, this.reader);
+        logMap.forEach((value, name) => {
+            fields[name] = value;
+        });
+        if (err) {
+            fields['err'] = normalizeError(err);
+        }
+        return fields;
+    }
+}
+exports.BunyanLogger = BunyanLogger;
+//# sourceMappingURL=BunyanLogger.js.map

package/src/BunyanLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BunyanLogger.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanLogger.ts"],"names":[],"mappings":"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","sourcesContent":["import type Logger from 'bunyan';\nimport { HeaderMethods, HeaderRegistry } from '@webpieces/core-util';\nimport type { ContextKey, ContextReader, Logger as WpLogger } from '@webpieces/core-util';\nimport { LoggedError } from './LoggedError';\n\n// Above this serialized size the error is truncated, so one giant stack can't\n// blow up a log line (ported from the tested trytami AppLogger).\nconst MAX_ERR_SERIALIZED = 100_000;\n\nfunction truncateStack(stack: string | undefined, maxLines = 5): string {\n    if (!stack) {\n        return '';\n    }\n    return stack.split('\\n').slice(0, maxLines).join('\\n');\n}\n\nfunction normalizeError(err: Error): LoggedError {\n    const full = new LoggedError(err.name, err.message, err.stack);\n    if (JSON.stringify({ err: full }).length <= MAX_ERR_SERIALIZED) {\n        return full;\n    }\n    return new LoggedError(\n        `error too long: ${err.name}`,\n        err.message.substring(0, 100),\n        truncateStack(err.stack, 5),\n    );\n}\n\n/**\n * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per\n * name, created as a bunyan child carrying `loggerName`). On every call it merges\n * the logged HeaderRegistry context keys (read through the ContextReader, secured\n * values masked) into the bunyan fields object, and normalizes an optional Error\n * into `err: { name, message, stack }` — matching the tested trytami AppLogger.\n * The GCP stream then serializes those fields into the structured log payload.\n */\nexport class BunyanLogger implements WpLogger {\n    private readonly headerMethods = new HeaderMethods();\n    private loggedKeys?: ContextKey[];\n\n    constructor(\n        private readonly bunyan: Logger,\n        private readonly reader: ContextReader,\n    ) {}\n\n    trace(message: string, err?: Error): void {\n        this.bunyan.trace(this.buildFields(err), message);\n    }\n\n    debug(message: string, err?: Error): void {\n        this.bunyan.debug(this.buildFields(err), message);\n    }\n\n    info(message: string, err?: Error): void {\n        this.bunyan.info(this.buildFields(err), message);\n    }\n\n    warn(message: string, err?: Error): void {\n        this.bunyan.warn(this.buildFields(err), message);\n    }\n\n    error(message: string, err?: Error): void {\n        this.bunyan.error(this.buildFields(err), message);\n    }\n\n    // Registry keys are read LAZILY (first log) — a LoggerFactory is built before\n    // setupRuntime calls HeaderRegistry.configure.\n    private buildFields(err?: Error): Record<string, string | LoggedError> {\n        if (!this.loggedKeys) {\n            this.loggedKeys = HeaderRegistry.get().getLoggedKeys();\n        }\n        const fields: Record<string, string | LoggedError> = {};\n        const logMap = this.headerMethods.buildSecureMapForLogs(this.loggedKeys, this.reader);\n        logMap.forEach((value: string, name: string) => {\n            fields[name] = value;\n        });\n        if (err) {\n            fields['err'] = normalizeError(err);\n        }\n        return fields;\n    }\n}\n"]}

package/src/LoggedError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * LoggedError - the serialized shape of an Error as it appears in a bunyan log
+ * record's `err` field. Data-only structure → a class, per CLAUDE.md. Produced by
+ * BunyanLogger's error normalization and read back by the console formatter.
+ */
+export declare class LoggedError {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string | undefined;
+    constructor(name: string, message: string, stack?: string | undefined);
+}

package/src/LoggedError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggedError = void 0;
+/**
+ * LoggedError - the serialized shape of an Error as it appears in a bunyan log
+ * record's `err` field. Data-only structure → a class, per CLAUDE.md. Produced by
+ * BunyanLogger's error normalization and read back by the console formatter.
+ */
+class LoggedError {
+    name;
+    message;
+    stack;
+    constructor(name, message, stack) {
+        this.name = name;
+        this.message = message;
+        this.stack = stack;
+    }
+}
+exports.LoggedError = LoggedError;
+//# sourceMappingURL=LoggedError.js.map

package/src/LoggedError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggedError.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/LoggedError.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,MAAa,WAAW;IAEA;IACA;IACA;IAHpB,YACoB,IAAY,EACZ,OAAe,EACf,KAAc;QAFd,SAAI,GAAJ,IAAI,CAAQ;QACZ,YAAO,GAAP,OAAO,CAAQ;QACf,UAAK,GAAL,KAAK,CAAS;IAC/B,CAAC;CACP;AAND,kCAMC","sourcesContent":["/**\n * LoggedError - the serialized shape of an Error as it appears in a bunyan log\n * record's `err` field. Data-only structure → a class, per CLAUDE.md. Produced by\n * BunyanLogger's error normalization and read back by the console formatter.\n */\nexport class LoggedError {\n    constructor(\n        public readonly name: string,\n        public readonly message: string,\n        public readonly stack?: string,\n    ) {}\n}\n"]}

package/src/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @webpieces/bunyan
+ *
+ * Node-only bunyan {@link LoggerFactory} backends for webpieces. Install one at
+ * startup via `LogManager.setFactory(...)`:
+ *
+ * ```ts
+ * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
+ * import { RequestContextReader } from '@webpieces/core-context';
+ *
+ * const reader = new RequestContextReader();
+ * const loggerFactory = process.env.K_SERVICE
+ *   ? new BunyanGcpFactory(reader)      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(reader); // local → pretty console
+ * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
+ * ```
+ *
+ * Both backends auto-enrich every line with the logged context keys from
+ * HeaderRegistry. This package depends only on @webpieces/core-util (+ bunyan +
+ * @google-cloud/logging-bunyan); the node RequestContextReader is passed in.
+ *
+ * @packageDocumentation
+ */
+export { BunyanGcpFactory } from './BunyanGcpFactory';
+export { BunyanConsoleFactory } from './BunyanConsoleFactory';
+export { BunyanFactoryOptions } from './BunyanFactoryOptions';
+export { BunyanLogger } from './BunyanLogger';
+export { createGoogleCloudStream, createConsoleStream } from './streams';
+export { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';

package/src/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleStream = exports.createGoogleCloudStream = exports.BunyanLogger = exports.BunyanFactoryOptions = exports.BunyanConsoleFactory = exports.BunyanGcpFactory = void 0;
+/**
+ * @webpieces/bunyan
+ *
+ * Node-only bunyan {@link LoggerFactory} backends for webpieces. Install one at
+ * startup via `LogManager.setFactory(...)`:
+ *
+ * ```ts
+ * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
+ * import { RequestContextReader } from '@webpieces/core-context';
+ *
+ * const reader = new RequestContextReader();
+ * const loggerFactory = process.env.K_SERVICE
+ *   ? new BunyanGcpFactory(reader)      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(reader); // local → pretty console
+ * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
+ * ```
+ *
+ * Both backends auto-enrich every line with the logged context keys from
+ * HeaderRegistry. This package depends only on @webpieces/core-util (+ bunyan +
+ * @google-cloud/logging-bunyan); the node RequestContextReader is passed in.
+ *
+ * @packageDocumentation
+ */
+var BunyanGcpFactory_1 = require("./BunyanGcpFactory");
+Object.defineProperty(exports, "BunyanGcpFactory", { enumerable: true, get: function () { return BunyanGcpFactory_1.BunyanGcpFactory; } });
+var BunyanConsoleFactory_1 = require("./BunyanConsoleFactory");
+Object.defineProperty(exports, "BunyanConsoleFactory", { enumerable: true, get: function () { return BunyanConsoleFactory_1.BunyanConsoleFactory; } });
+var BunyanFactoryOptions_1 = require("./BunyanFactoryOptions");
+Object.defineProperty(exports, "BunyanFactoryOptions", { enumerable: true, get: function () { return BunyanFactoryOptions_1.BunyanFactoryOptions; } });
+var BunyanLogger_1 = require("./BunyanLogger");
+Object.defineProperty(exports, "BunyanLogger", { enumerable: true, get: function () { return BunyanLogger_1.BunyanLogger; } });
+var streams_1 = require("./streams");
+Object.defineProperty(exports, "createGoogleCloudStream", { enumerable: true, get: function () { return streams_1.createGoogleCloudStream; } });
+Object.defineProperty(exports, "createConsoleStream", { enumerable: true, get: function () { return streams_1.createConsoleStream; } });
+var levels_1 = require("./levels");
+Object.defineProperty(exports, "LEVEL_TO_BUNYAN", { enumerable: true, get: function () { return levels_1.LEVEL_TO_BUNYAN; } });
+Object.defineProperty(exports, "logLevelToBunyanLevel", { enumerable: true, get: function () { return levels_1.logLevelToBunyanLevel; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA;AAC7B,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA;AAC7B,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,qCAAyE;AAAhE,kHAAA,uBAAuB,OAAA;AAAE,8GAAA,mBAAmB,OAAA;AACrD,mCAAkE;AAAzD,yGAAA,eAAe,OAAA;AAAE,+GAAA,qBAAqB,OAAA","sourcesContent":["/**\n * @webpieces/bunyan\n *\n * Node-only bunyan {@link LoggerFactory} backends for webpieces. Install one at\n * startup via `LogManager.setFactory(...)`:\n *\n * ```ts\n * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';\n * import { RequestContextReader } from '@webpieces/core-context';\n *\n * const reader = new RequestContextReader();\n * const loggerFactory = process.env.K_SERVICE\n *   ? new BunyanGcpFactory(reader)      // Cloud Logging via @google-cloud/logging-bunyan\n *   : new BunyanConsoleFactory(reader); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * Both backends auto-enrich every line with the logged context keys from\n * HeaderRegistry. This package depends only on @webpieces/core-util (+ bunyan +\n * @google-cloud/logging-bunyan); the node RequestContextReader is passed in.\n *\n * @packageDocumentation\n */\nexport { BunyanGcpFactory } from './BunyanGcpFactory';\nexport { BunyanConsoleFactory } from './BunyanConsoleFactory';\nexport { BunyanFactoryOptions } from './BunyanFactoryOptions';\nexport { BunyanLogger } from './BunyanLogger';\nexport { createGoogleCloudStream, createConsoleStream } from './streams';\nexport { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';\n"]}

package/src/levels.d.ts

@@ -0,0 +1,9 @@
+import type { LogLevel } from '@webpieces/core-util';
+/**
+ * webpieces LogLevel → bunyan numeric level. webpieces has no `fatal`; its 5
+ * levels map onto bunyan TRACE(10)/DEBUG(20)/INFO(30)/WARN(40)/ERROR(50).
+ * @google-cloud/logging-bunyan turns these into GCP severities
+ * (10/20→DEBUG, 30→INFO, 40→WARNING, 50→ERROR).
+ */
+export declare const LEVEL_TO_BUNYAN: Record<LogLevel, number>;
+export declare function logLevelToBunyanLevel(level: LogLevel): number;

package/src/levels.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEVEL_TO_BUNYAN = void 0;
+exports.logLevelToBunyanLevel = logLevelToBunyanLevel;
+const tslib_1 = require("tslib");
+const bunyan_1 = tslib_1.__importDefault(require("bunyan"));
+/**
+ * webpieces LogLevel → bunyan numeric level. webpieces has no `fatal`; its 5
+ * levels map onto bunyan TRACE(10)/DEBUG(20)/INFO(30)/WARN(40)/ERROR(50).
+ * @google-cloud/logging-bunyan turns these into GCP severities
+ * (10/20→DEBUG, 30→INFO, 40→WARNING, 50→ERROR).
+ */
+exports.LEVEL_TO_BUNYAN = {
+    trace: bunyan_1.default.TRACE,
+    debug: bunyan_1.default.DEBUG,
+    info: bunyan_1.default.INFO,
+    warn: bunyan_1.default.WARN,
+    error: bunyan_1.default.ERROR,
+};
+function logLevelToBunyanLevel(level) {
+    return exports.LEVEL_TO_BUNYAN[level];
+}
+//# sourceMappingURL=levels.js.map

package/src/levels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"levels.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/levels.ts"],"names":[],"mappings":";;;AAiBA,sDAEC;;AAnBD,4DAA4B;AAG5B;;;;;GAKG;AACU,QAAA,eAAe,GAA6B;IACrD,KAAK,EAAE,gBAAM,CAAC,KAAK;IACnB,KAAK,EAAE,gBAAM,CAAC,KAAK;IACnB,IAAI,EAAE,gBAAM,CAAC,IAAI;IACjB,IAAI,EAAE,gBAAM,CAAC,IAAI;IACjB,KAAK,EAAE,gBAAM,CAAC,KAAK;CACtB,CAAC;AAEF,SAAgB,qBAAqB,CAAC,KAAe;IACjD,OAAO,uBAAe,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC","sourcesContent":["import Logger from 'bunyan';\nimport type { LogLevel } from '@webpieces/core-util';\n\n/**\n * webpieces LogLevel → bunyan numeric level. webpieces has no `fatal`; its 5\n * levels map onto bunyan TRACE(10)/DEBUG(20)/INFO(30)/WARN(40)/ERROR(50).\n * @google-cloud/logging-bunyan turns these into GCP severities\n * (10/20→DEBUG, 30→INFO, 40→WARNING, 50→ERROR).\n */\nexport const LEVEL_TO_BUNYAN: Record<LogLevel, number> = {\n    trace: Logger.TRACE,\n    debug: Logger.DEBUG,\n    info: Logger.INFO,\n    warn: Logger.WARN,\n    error: Logger.ERROR,\n};\n\nexport function logLevelToBunyanLevel(level: LogLevel): number {\n    return LEVEL_TO_BUNYAN[level];\n}\n"]}

package/src/streams.d.ts

@@ -0,0 +1,11 @@
+import Logger from 'bunyan';
+import type { LogLevel } from '@webpieces/core-util';
+/**
+ * The GCP stream: delegates ALL structured-JSON formatting (numeric level → GCP
+ * severity, msg→message, trace/httpRequest fields, stripping name/hostname/pid)
+ * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
+ * Sends to the Cloud Logging API (needs ADC on the instance).
+ */
+export declare function createGoogleCloudStream(level: LogLevel): Logger.Stream;
+/** The local dev stream: human-readable text to stdout via {@link writeConsole}. */
+export declare function createConsoleStream(level: LogLevel): Logger.Stream;

package/src/streams.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGoogleCloudStream = createGoogleCloudStream;
+exports.createConsoleStream = createConsoleStream;
+const tslib_1 = require("tslib");
+const stream_1 = require("stream");
+const bunyan_1 = tslib_1.__importDefault(require("bunyan"));
+const logging_bunyan_1 = require("@google-cloud/logging-bunyan");
+const levels_1 = require("./levels");
+// bunyan record fields that are structural / rendered specially, so they are not
+// shown as context tags in the local console line.
+const BUNYAN_STD_FIELDS = new Set([
+    'v',
+    'level',
+    'name',
+    'hostname',
+    'pid',
+    'time',
+    'msg',
+    'src',
+    'err',
+    'loggerName',
+]);
+function formatTime(iso) {
+    if (typeof iso !== 'string') {
+        return '';
+    }
+    // ISO 8601 "2026-07-08T12:34:56.789Z" → "12:34:56.789"
+    const timePart = iso.split('T')[1];
+    return timePart ? timePart.replace('Z', '') : iso;
+}
+/**
+ * Render one bunyan JSON line as a human-readable, greppable console line:
+ * `[LEVEL][time][ctx tags]: message` plus multi-line error details. Ported from
+ * the tested trytami writeConsole, generalized: every non-structural field
+ * (i.e. the injected context keys) becomes a `key:value` tag.
+ */
+function writeConsole(line) {
+    const obj = JSON.parse(line);
+    const levelName = (bunyan_1.default.nameFromLevel[obj['level']] ?? 'info').toUpperCase().padEnd(5);
+    const time = formatTime(obj['time']);
+    const tags = [];
+    if (obj['loggerName']) {
+        tags.push(`logger:${String(obj['loggerName'])}`);
+    }
+    for (const key of Object.keys(obj)) {
+        if (BUNYAN_STD_FIELDS.has(key)) {
+            continue;
+        }
+        tags.push(`${key}:${String(obj[key])}`);
+    }
+    const tagStr = tags.length > 0 ? tags.join(', ') : 'no-context';
+    let message = `[${levelName}][${time}][${tagStr}]: ${String(obj['msg'] ?? '')}`;
+    const err = obj['err'];
+    if (err) {
+        message += `\nError Details:`;
+        message += `\n  Message: ${err.message}`;
+        message += `\n  Name: ${err.name}`;
+        if (err.stack) {
+            message += `\n  Stack Trace:\n${err.stack}`;
+        }
+    }
+    // This IS a logging backend (the console sink); direct stdout is intentional.
+    console.log(message);
+}
+/**
+ * The GCP stream: delegates ALL structured-JSON formatting (numeric level → GCP
+ * severity, msg→message, trace/httpRequest fields, stripping name/hostname/pid)
+ * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
+ * Sends to the Cloud Logging API (needs ADC on the instance).
+ */
+function createGoogleCloudStream(level) {
+    const loggingBunyan = new logging_bunyan_1.LoggingBunyan();
+    return loggingBunyan.stream((0, levels_1.logLevelToBunyanLevel)(level));
+}
+/** The local dev stream: human-readable text to stdout via {@link writeConsole}. */
+function createConsoleStream(level) {
+    const writable = new stream_1.Writable({
+        write(chunk, _encoding, callback) {
+            writeConsole(chunk.toString());
+            callback();
+        },
+    });
+    return {
+        name: 'console',
+        level: (0, levels_1.logLevelToBunyanLevel)(level),
+        stream: writable,
+    };
+}
+//# sourceMappingURL=streams.js.map

package/src/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/streams.ts"],"names":[],"mappings":"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","sourcesContent":["import { Writable } from 'stream';\nimport Logger from 'bunyan';\nimport { LoggingBunyan } from '@google-cloud/logging-bunyan';\nimport type { LogLevel } from '@webpieces/core-util';\nimport { logLevelToBunyanLevel } from './levels';\nimport { LoggedError } from './LoggedError';\n\n// A parsed bunyan JSON record: standard fields plus arbitrary injected context\n// tags. Values are whatever JSON holds.\ntype JsonValue = string | number | boolean | object | null;\ntype BunyanRecord = Record<string, JsonValue>;\n\n// bunyan record fields that are structural / rendered specially, so they are not\n// shown as context tags in the local console line.\nconst BUNYAN_STD_FIELDS = new Set<string>([\n    'v',\n    'level',\n    'name',\n    'hostname',\n    'pid',\n    'time',\n    'msg',\n    'src',\n    'err',\n    'loggerName',\n]);\n\nfunction formatTime(iso: JsonValue): string {\n    if (typeof iso !== 'string') {\n        return '';\n    }\n    // ISO 8601 \"2026-07-08T12:34:56.789Z\" → \"12:34:56.789\"\n    const timePart = iso.split('T')[1];\n    return timePart ? timePart.replace('Z', '') : iso;\n}\n\n/**\n * Render one bunyan JSON line as a human-readable, greppable console line:\n * `[LEVEL][time][ctx tags]: message` plus multi-line error details. Ported from\n * the tested trytami writeConsole, generalized: every non-structural field\n * (i.e. the injected context keys) becomes a `key:value` tag.\n */\nfunction writeConsole(line: string): void {\n    const obj: BunyanRecord = JSON.parse(line);\n    const levelName = (Logger.nameFromLevel[obj['level'] as number] ?? 'info').toUpperCase().padEnd(5);\n    const time = formatTime(obj['time']);\n\n    const tags: string[] = [];\n    if (obj['loggerName']) {\n        tags.push(`logger:${String(obj['loggerName'])}`);\n    }\n    for (const key of Object.keys(obj)) {\n        if (BUNYAN_STD_FIELDS.has(key)) {\n            continue;\n        }\n        tags.push(`${key}:${String(obj[key])}`);\n    }\n    const tagStr = tags.length > 0 ? tags.join(', ') : 'no-context';\n\n    let message = `[${levelName}][${time}][${tagStr}]: ${String(obj['msg'] ?? '')}`;\n\n    const err = obj['err'] as LoggedError | undefined;\n    if (err) {\n        message += `\\nError Details:`;\n        message += `\\n  Message: ${err.message}`;\n        message += `\\n  Name: ${err.name}`;\n        if (err.stack) {\n            message += `\\n  Stack Trace:\\n${err.stack}`;\n        }\n    }\n\n    // This IS a logging backend (the console sink); direct stdout is intentional.\n    console.log(message);\n}\n\n/**\n * The GCP stream: delegates ALL structured-JSON formatting (numeric level → GCP\n * severity, msg→message, trace/httpRequest fields, stripping name/hostname/pid)\n * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.\n * Sends to the Cloud Logging API (needs ADC on the instance).\n */\nexport function createGoogleCloudStream(level: LogLevel): Logger.Stream {\n    const loggingBunyan = new LoggingBunyan();\n    return loggingBunyan.stream(logLevelToBunyanLevel(level));\n}\n\n/** The local dev stream: human-readable text to stdout via {@link writeConsole}. */\nexport function createConsoleStream(level: LogLevel): Logger.Stream {\n    const writable = new Writable({\n        write(chunk: Buffer | string, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {\n            writeConsole(chunk.toString());\n            callback();\n        },\n    });\n    return {\n        name: 'console',\n        level: logLevelToBunyanLevel(level),\n        stream: writable,\n    };\n}\n"]}