@webpieces/bunyan 0.4.396 → 0.4.397

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/bunyan",
-  "version": "0.4.396",
+  "version": "0.4.397",
   "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",
@@ -23,8 +23,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@webpieces/core-util": "0.4.396",
-    "@webpieces/core-context": "0.4.396",
+    "@webpieces/core-util": "0.4.397",
+    "@webpieces/core-context": "0.4.397",
     "bunyan": "1.8.15",
     "@google-cloud/logging-bunyan": "5.1.0",
     "@types/bunyan": "1.8.11"

package/src/BunyanLogger.js

@@ -8,21 +8,18 @@ const LoggedError_1 = require("./LoggedError");
 const MISSING_CONTEXT_MESSAGE = 'Log emitted OUTSIDE RequestContext.run(...) — every request must be wrapped in ' +
     'RequestContext.run() by a server filter. That filter appears to be missing: correlation ' +
     'fields (requestId, tenant, ...) will be absent from logs until it is added. Reported once.';
-// 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');
-}
+/**
+ * The error, whole. There is deliberately NO size guard here any more.
+ *
+ * This used to truncate an error over 100KB down to 5 stack frames and a 100-character message, to
+ * keep one giant stack from blowing past Cloud Logging's per-entry limit. That traded the wrong
+ * thing away: a stack trace big enough to trip the limit is precisely the one worth reading, and it
+ * arrived pre-shredded. The GCP stream now SPLITS an oversized record across several complete
+ * records instead (see ChunkingRawStream), so the whole stack survives and nothing is lost — which
+ * makes truncating here strictly harmful.
+ */
 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));
+    return new LoggedError_1.LoggedError(err.name, err.message, err.stack);
 }
 /**
  * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per

package/src/BunyanLogger.js.map

@@ -1 +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 type { Logger as WpLogger } from '@webpieces/core-util';\nimport { RequestContext } from '@webpieces/core-context';\nimport { LoggedError } from './LoggedError';\n\n// A log line with no active RequestContext = a missing request-wrapping server\n// filter. We report that once (below), never on every line.\nconst MISSING_CONTEXT_MESSAGE =\n    'Log emitted OUTSIDE RequestContext.run(...) — every request must be wrapped in ' +\n    'RequestContext.run() by a server filter. That filter appears to be missing: correlation ' +\n    'fields (requestId, tenant, ...) will be absent from logs until it is added. Reported once.';\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 reads\n * the logged HeaderRegistry keys DIRECTLY from the active {@link RequestContext}\n * (secured values masked) into the bunyan fields object, and normalizes an optional\n * Error into `err: { name, message, stack }` — matching the tested trytami AppLogger.\n * The GCP stream then serializes those fields into the structured log payload.\n *\n * This context-reading is INLINED here (and duplicated in the winston logger) on\n * purpose: it must run ONLY when a bunyan/winston backend is installed, never for\n * the plain ConsoleLogger — so it does not belong on RequestContext.\n */\nexport class BunyanLogger implements WpLogger {\n    // One-shot latch (see MISSING_CONTEXT_MESSAGE) — flips true after the first\n    // out-of-context line so we report the missing filter exactly once, not per line.\n    private reportedMissingContext = false;\n\n    constructor(private readonly bunyan: Logger) {}\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    private buildFields(err?: Error): Record<string, string | object | LoggedError> {\n        const fields: Record<string, string | object | LoggedError> = {};\n        if (!RequestContext.isActive()) {\n            this.reportMissingContextOnce();\n            return fields;\n        }\n\n        // ONE loop, in HeaderRegistry.buildStructuredLogFields — the registry owns the keys and each\n        // ContextKey masks its own value. Values may be OBJECTS (the `api` tag), so an object-valued key\n        // nests into the structured payload (bunyan's GCP stream serializes fields) rather than being\n        // dropped by the string-only buildLogFields.\n        RequestContext.buildStructuredLogFields().forEach((value: string | object, name: string) => {\n            fields[name] = value;\n        });\n        if (err) {\n            fields['err'] = normalizeError(err);\n        }\n        return fields;\n    }\n\n    // Report the missing request-wrapping filter once. Uses the RAW bunyan logger\n    // (not buildFields()), so there is no re-entrancy — just a single extra line.\n    private reportMissingContextOnce(): void {\n        if (this.reportedMissingContext) {\n            return;\n        }\n        this.reportedMissingContext = true;\n        this.bunyan.error(MISSING_CONTEXT_MESSAGE);\n    }\n}\n"]}
+{"version":3,"file":"BunyanLogger.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanLogger.ts"],"names":[],"mappings":";;;AAEA,0DAAyD;AACzD,+CAA4C;AAE5C,+EAA+E;AAC/E,4DAA4D;AAC5D,MAAM,uBAAuB,GACzB,iFAAiF;IACjF,0FAA0F;IAC1F,4FAA4F,CAAC;AAEjG;;;;;;;;;GASG;AACH,SAAS,cAAc,CAAC,GAAU;IAC9B,OAAO,IAAI,yBAAW,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAa,YAAY;IAKQ;IAJ7B,4EAA4E;IAC5E,kFAAkF;IAC1E,sBAAsB,GAAG,KAAK,CAAC;IAEvC,YAA6B,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;IAE/C,KAAK,CAAC,OAAe,EAAE,GAAW;QAC9B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAW;QAC9B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAW;QAC7B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAW;QAC7B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAW;QAC9B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAEO,WAAW,CAAC,GAAW;QAC3B,MAAM,MAAM,GAAkD,EAAE,CAAC;QACjE,IAAI,CAAC,6BAAc,CAAC,QAAQ,EAAE,EAAE,CAAC;YAC7B,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,6FAA6F;QAC7F,iGAAiG;QACjG,8FAA8F;QAC9F,6CAA6C;QAC7C,6BAAc,CAAC,wBAAwB,EAAE,CAAC,OAAO,CAAC,CAAC,KAAsB,EAAE,IAAY,EAAE,EAAE;YACvF,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QACzB,CAAC,CAAC,CAAC;QACH,IAAI,GAAG,EAAE,CAAC;YACN,MAAM,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QACxC,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,8EAA8E;IAC9E,8EAA8E;IACtE,wBAAwB;QAC5B,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC9B,OAAO;QACX,CAAC;QACD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IAC/C,CAAC;CACJ;AAxDD,oCAwDC","sourcesContent":["import type Logger from 'bunyan';\nimport type { Logger as WpLogger } from '@webpieces/core-util';\nimport { RequestContext } from '@webpieces/core-context';\nimport { LoggedError } from './LoggedError';\n\n// A log line with no active RequestContext = a missing request-wrapping server\n// filter. We report that once (below), never on every line.\nconst MISSING_CONTEXT_MESSAGE =\n    'Log emitted OUTSIDE RequestContext.run(...) — every request must be wrapped in ' +\n    'RequestContext.run() by a server filter. That filter appears to be missing: correlation ' +\n    'fields (requestId, tenant, ...) will be absent from logs until it is added. Reported once.';\n\n/**\n * The error, whole. There is deliberately NO size guard here any more.\n *\n * This used to truncate an error over 100KB down to 5 stack frames and a 100-character message, to\n * keep one giant stack from blowing past Cloud Logging's per-entry limit. That traded the wrong\n * thing away: a stack trace big enough to trip the limit is precisely the one worth reading, and it\n * arrived pre-shredded. The GCP stream now SPLITS an oversized record across several complete\n * records instead (see ChunkingRawStream), so the whole stack survives and nothing is lost — which\n * makes truncating here strictly harmful.\n */\nfunction normalizeError(err: Error): LoggedError {\n    return new LoggedError(err.name, err.message, err.stack);\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 reads\n * the logged HeaderRegistry keys DIRECTLY from the active {@link RequestContext}\n * (secured values masked) into the bunyan fields object, and normalizes an optional\n * Error into `err: { name, message, stack }` — matching the tested trytami AppLogger.\n * The GCP stream then serializes those fields into the structured log payload.\n *\n * This context-reading is INLINED here (and duplicated in the winston logger) on\n * purpose: it must run ONLY when a bunyan/winston backend is installed, never for\n * the plain ConsoleLogger — so it does not belong on RequestContext.\n */\nexport class BunyanLogger implements WpLogger {\n    // One-shot latch (see MISSING_CONTEXT_MESSAGE) — flips true after the first\n    // out-of-context line so we report the missing filter exactly once, not per line.\n    private reportedMissingContext = false;\n\n    constructor(private readonly bunyan: Logger) {}\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    private buildFields(err?: Error): Record<string, string | object | LoggedError> {\n        const fields: Record<string, string | object | LoggedError> = {};\n        if (!RequestContext.isActive()) {\n            this.reportMissingContextOnce();\n            return fields;\n        }\n\n        // ONE loop, in HeaderRegistry.buildStructuredLogFields — the registry owns the keys and each\n        // ContextKey masks its own value. Values may be OBJECTS (the `api` tag), so an object-valued key\n        // nests into the structured payload (bunyan's GCP stream serializes fields) rather than being\n        // dropped by the string-only buildLogFields.\n        RequestContext.buildStructuredLogFields().forEach((value: string | object, name: string) => {\n            fields[name] = value;\n        });\n        if (err) {\n            fields['err'] = normalizeError(err);\n        }\n        return fields;\n    }\n\n    // Report the missing request-wrapping filter once. Uses the RAW bunyan logger\n    // (not buildFields()), so there is no re-entrancy — just a single extra line.\n    private reportMissingContextOnce(): void {\n        if (this.reportedMissingContext) {\n            return;\n        }\n        this.reportedMissingContext = true;\n        this.bunyan.error(MISSING_CONTEXT_MESSAGE);\n    }\n}\n"]}

package/src/ChunkingRawStream.d.ts

@@ -0,0 +1,52 @@
+import { Writable } from 'stream';
+type JsonValue = string | number | boolean | bigint | object | null | undefined;
+/**
+ * A bunyan record as it reaches a `type: 'raw'` stream: the standard fields (v, level, name, time,
+ * msg, err, ...) plus whatever context tags the logger injected. Values are whatever JSON holds.
+ */
+type BunyanRecord = Record<string, JsonValue>;
+/**
+ * ChunkingRawStream - sits between bunyan and the Cloud Logging stream, SPLITTING an oversized
+ * record into several complete records instead of letting it be rejected.
+ *
+ * WHY: Cloud Logging caps a LogEntry at 256 KiB, and on the API path an oversized entry fails the
+ * whole `entries.write` call — `INVALID_ARGUMENT: Log entry with size X exceeds maximum size of
+ * 256.0K` — which can take good entries batched alongside it down too. A 300KB stack trace or
+ * response body is not exotic; it is exactly what you most want to read.
+ *
+ * WHY NOT TRUNCATE (what this replaces): the previous guard cut a big error down to 5 stack frames.
+ * That kept the line under the limit by destroying its only useful content. Splitting keeps all of
+ * it, addressable by `jsonPayload.logChunk.uid`.
+ *
+ * WHY A STREAM WRAPPER, not the BunyanLogger: bunyan's own machinery (and anything else writing to
+ * the logger) reaches the stream directly, and the stream is where the size limit actually lives.
+ * `loggingBunyan.stream()` is `type: 'raw'`, so we receive the record OBJECT — no parsing needed,
+ * and rebuilding a piece is just a field swap.
+ *
+ * GCP-ONLY: wired in by {@link createGoogleCloudStream}. The local console stream is untouched — a
+ * dev terminal has no size limit, and splitting there would only hurt readability.
+ */
+export declare class ChunkingRawStream extends Writable {
+    private readonly target;
+    private readonly budgetBytes;
+    constructor(target: Writable, budgetBytes?: number);
+    _write(record: BunyanRecord, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    /** The record as-is when it fits; otherwise one complete record per chunk. */
+    private split;
+    /** One piece: every original field, with `msg`/`err.stack` replaced and a `logChunk` tag added. */
+    private buildRecord;
+    /**
+     * Serialized size of the record.
+     *
+     * Measured as JSON even though this path ships over gRPC/protobuf, where the true size differs.
+     * JSON over-counts (every key is spelled out, every string escaped), and over-counting is the
+     * safe direction: we chunk slightly sooner than strictly needed rather than one byte too late.
+     *
+     * The replacer is what makes this TOTAL, with no try/catch: a plain JSON.stringify throws on a
+     * circular value — real here, since request/response object cycles are exactly why the winston
+     * backend runs safe-stable-stringify — and on a bigint. A measurement that throws would take
+     * down the very log line this class exists to save.
+     */
+    private serializedBytes;
+}
+export {};

package/src/ChunkingRawStream.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkingRawStream = void 0;
+const stream_1 = require("stream");
+const core_util_1 = require("@webpieces/core-util");
+const LoggedError_1 = require("./LoggedError");
+/**
+ * ChunkingRawStream - sits between bunyan and the Cloud Logging stream, SPLITTING an oversized
+ * record into several complete records instead of letting it be rejected.
+ *
+ * WHY: Cloud Logging caps a LogEntry at 256 KiB, and on the API path an oversized entry fails the
+ * whole `entries.write` call — `INVALID_ARGUMENT: Log entry with size X exceeds maximum size of
+ * 256.0K` — which can take good entries batched alongside it down too. A 300KB stack trace or
+ * response body is not exotic; it is exactly what you most want to read.
+ *
+ * WHY NOT TRUNCATE (what this replaces): the previous guard cut a big error down to 5 stack frames.
+ * That kept the line under the limit by destroying its only useful content. Splitting keeps all of
+ * it, addressable by `jsonPayload.logChunk.uid`.
+ *
+ * WHY A STREAM WRAPPER, not the BunyanLogger: bunyan's own machinery (and anything else writing to
+ * the logger) reaches the stream directly, and the stream is where the size limit actually lives.
+ * `loggingBunyan.stream()` is `type: 'raw'`, so we receive the record OBJECT — no parsing needed,
+ * and rebuilding a piece is just a field swap.
+ *
+ * GCP-ONLY: wired in by {@link createGoogleCloudStream}. The local console stream is untouched — a
+ * dev terminal has no size limit, and splitting there would only hurt readability.
+ */
+class ChunkingRawStream extends stream_1.Writable {
+    target;
+    budgetBytes;
+    constructor(target, budgetBytes = core_util_1.GCP_LOG_BUDGET_BYTES) {
+        // objectMode: bunyan hands a raw stream the record OBJECT, not a serialized line.
+        super({ objectMode: true });
+        this.target = target;
+        this.budgetBytes = budgetBytes;
+    }
+    _write(record, _encoding, callback) {
+        for (const piece of this.split(record)) {
+            this.target.write(piece);
+        }
+        callback();
+    }
+    /** The record as-is when it fits; otherwise one complete record per chunk. */
+    split(record) {
+        const renderedBytes = this.serializedBytes(record);
+        if (renderedBytes <= this.budgetBytes) {
+            // The overwhelmingly common path — through untouched, no tag added.
+            return [record];
+        }
+        const message = typeof record['msg'] === 'string' ? record['msg'] : String(record['msg'] ?? '');
+        const err = record['err'];
+        const stack = err?.stack;
+        const budgets = core_util_1.LogChunker.chunkBudgets(renderedBytes, this.budgetBytes, message, stack ?? '');
+        const messageChunks = core_util_1.LogChunker.chunk(message, budgets.firstBudget);
+        const stackChunks = core_util_1.LogChunker.chunk(stack ?? '', budgets.secondBudget);
+        const uid = core_util_1.LogChunker.newUid();
+        const total = Math.max(messageChunks.length, stackChunks.length);
+        const pieces = [];
+        for (let index = 0; index < total; index++) {
+            pieces.push(this.buildRecord(record, messageChunks[index] ?? '', err === undefined ? undefined : new LoggedError_1.LoggedError(err.name, err.message, stackChunks[index] ?? ''), new core_util_1.LogChunkInfo(uid, index, total)));
+        }
+        return pieces;
+    }
+    /** One piece: every original field, with `msg`/`err.stack` replaced and a `logChunk` tag added. */
+    buildRecord(record, messageChunk, err, chunkInfo) {
+        const piece = Object.assign({}, record);
+        piece['msg'] = messageChunk;
+        piece['logChunk'] = chunkInfo;
+        if (err !== undefined) {
+            piece['err'] = err;
+        }
+        return piece;
+    }
+    /**
+     * Serialized size of the record.
+     *
+     * Measured as JSON even though this path ships over gRPC/protobuf, where the true size differs.
+     * JSON over-counts (every key is spelled out, every string escaped), and over-counting is the
+     * safe direction: we chunk slightly sooner than strictly needed rather than one byte too late.
+     *
+     * The replacer is what makes this TOTAL, with no try/catch: a plain JSON.stringify throws on a
+     * circular value — real here, since request/response object cycles are exactly why the winston
+     * backend runs safe-stable-stringify — and on a bigint. A measurement that throws would take
+     * down the very log line this class exists to save.
+     */
+    serializedBytes(record) {
+        const seen = new WeakSet();
+        const json = JSON.stringify(record, (_key, value) => {
+            if (typeof value === 'bigint') {
+                return value.toString();
+            }
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+            }
+            return value;
+        });
+        return core_util_1.LogChunker.byteLength(json);
+    }
+}
+exports.ChunkingRawStream = ChunkingRawStream;
+//# sourceMappingURL=ChunkingRawStream.js.map

package/src/ChunkingRawStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkingRawStream.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/ChunkingRawStream.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAClC,oDAAsF;AACtF,+CAA4C;AAa5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,iBAAkB,SAAQ,iBAAQ;IAC1B,MAAM,CAAW;IACjB,WAAW,CAAS;IAErC,YAAY,MAAgB,EAAE,cAAsB,gCAAoB;QACpE,kFAAkF;QAClF,KAAK,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACnC,CAAC;IAEQ,MAAM,CACX,MAAoB,EACpB,SAAyB,EACzB,QAAwC;QAExC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QACD,QAAQ,EAAE,CAAC;IACf,CAAC;IAED,8EAA8E;IACtE,KAAK,CAAC,MAAoB;QAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,aAAa,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACpC,oEAAoE;YACpE,OAAO,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,OAAO,GAAG,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAChG,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAA4B,CAAC;QACrD,MAAM,KAAK,GAAG,GAAG,EAAE,KAAK,CAAC;QAEzB,MAAM,OAAO,GAAG,sBAAU,CAAC,YAAY,CAAC,aAAa,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC;QAC/F,MAAM,aAAa,GAAG,sBAAU,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QACrE,MAAM,WAAW,GAAG,sBAAU,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QAExE,MAAM,GAAG,GAAG,sBAAU,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QACjE,MAAM,MAAM,GAAmB,EAAE,CAAC;QAClC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;YACzC,MAAM,CAAC,IAAI,CACP,IAAI,CAAC,WAAW,CACZ,MAAM,EACN,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,EAC1B,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,yBAAW,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAChG,IAAI,wBAAY,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,CACtC,CACJ,CAAC;QACN,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,mGAAmG;IAC3F,WAAW,CACf,MAAoB,EACpB,YAAoB,EACpB,GAA4B,EAC5B,SAAuB;QAEvB,MAAM,KAAK,GAAiB,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QACtD,KAAK,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC;QAC5B,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QAC9B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACpB,KAAK,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC;QACvB,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;OAWG;IACK,eAAe,CAAC,MAAoB;QACxC,MAAM,IAAI,GAAG,IAAI,OAAO,EAAU,CAAC;QACnC,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,KAAgB,EAAa,EAAE;YAC9E,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC5B,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC5B,CAAC;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC9C,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;oBAClB,OAAO,YAAY,CAAC;gBACxB,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACpB,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,OAAO,sBAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;CACJ;AAlGD,8CAkGC","sourcesContent":["import { Writable } from 'stream';\nimport { GCP_LOG_BUDGET_BYTES, LogChunker, LogChunkInfo } from '@webpieces/core-util';\nimport { LoggedError } from './LoggedError';\n\n// JSON-shaped value (the widest thing a record field can hold), used instead of `any`/`unknown`\n// which the code rules disallow. Mirrors the JsonValue in streams.ts, plus bigint — which\n// JSON.stringify refuses outright, so serializedBytes below must be able to see and rewrite it.\ntype JsonValue = string | number | boolean | bigint | object | null | undefined;\n\n/**\n * A bunyan record as it reaches a `type: 'raw'` stream: the standard fields (v, level, name, time,\n * msg, err, ...) plus whatever context tags the logger injected. Values are whatever JSON holds.\n */\ntype BunyanRecord = Record<string, JsonValue>;\n\n/**\n * ChunkingRawStream - sits between bunyan and the Cloud Logging stream, SPLITTING an oversized\n * record into several complete records instead of letting it be rejected.\n *\n * WHY: Cloud Logging caps a LogEntry at 256 KiB, and on the API path an oversized entry fails the\n * whole `entries.write` call — `INVALID_ARGUMENT: Log entry with size X exceeds maximum size of\n * 256.0K` — which can take good entries batched alongside it down too. A 300KB stack trace or\n * response body is not exotic; it is exactly what you most want to read.\n *\n * WHY NOT TRUNCATE (what this replaces): the previous guard cut a big error down to 5 stack frames.\n * That kept the line under the limit by destroying its only useful content. Splitting keeps all of\n * it, addressable by `jsonPayload.logChunk.uid`.\n *\n * WHY A STREAM WRAPPER, not the BunyanLogger: bunyan's own machinery (and anything else writing to\n * the logger) reaches the stream directly, and the stream is where the size limit actually lives.\n * `loggingBunyan.stream()` is `type: 'raw'`, so we receive the record OBJECT — no parsing needed,\n * and rebuilding a piece is just a field swap.\n *\n * GCP-ONLY: wired in by {@link createGoogleCloudStream}. The local console stream is untouched — a\n * dev terminal has no size limit, and splitting there would only hurt readability.\n */\nexport class ChunkingRawStream extends Writable {\n    private readonly target: Writable;\n    private readonly budgetBytes: number;\n\n    constructor(target: Writable, budgetBytes: number = GCP_LOG_BUDGET_BYTES) {\n        // objectMode: bunyan hands a raw stream the record OBJECT, not a serialized line.\n        super({ objectMode: true });\n        this.target = target;\n        this.budgetBytes = budgetBytes;\n    }\n\n    override _write(\n        record: BunyanRecord,\n        _encoding: BufferEncoding,\n        callback: (error?: Error | null) => void,\n    ): void {\n        for (const piece of this.split(record)) {\n            this.target.write(piece);\n        }\n        callback();\n    }\n\n    /** The record as-is when it fits; otherwise one complete record per chunk. */\n    private split(record: BunyanRecord): BunyanRecord[] {\n        const renderedBytes = this.serializedBytes(record);\n        if (renderedBytes <= this.budgetBytes) {\n            // The overwhelmingly common path — through untouched, no tag added.\n            return [record];\n        }\n\n        const message = typeof record['msg'] === 'string' ? record['msg'] : String(record['msg'] ?? '');\n        const err = record['err'] as LoggedError | undefined;\n        const stack = err?.stack;\n\n        const budgets = LogChunker.chunkBudgets(renderedBytes, this.budgetBytes, message, stack ?? '');\n        const messageChunks = LogChunker.chunk(message, budgets.firstBudget);\n        const stackChunks = LogChunker.chunk(stack ?? '', budgets.secondBudget);\n\n        const uid = LogChunker.newUid();\n        const total = Math.max(messageChunks.length, stackChunks.length);\n        const pieces: BunyanRecord[] = [];\n        for (let index = 0; index < total; index++) {\n            pieces.push(\n                this.buildRecord(\n                    record,\n                    messageChunks[index] ?? '',\n                    err === undefined ? undefined : new LoggedError(err.name, err.message, stackChunks[index] ?? ''),\n                    new LogChunkInfo(uid, index, total),\n                ),\n            );\n        }\n        return pieces;\n    }\n\n    /** One piece: every original field, with `msg`/`err.stack` replaced and a `logChunk` tag added. */\n    private buildRecord(\n        record: BunyanRecord,\n        messageChunk: string,\n        err: LoggedError | undefined,\n        chunkInfo: LogChunkInfo,\n    ): BunyanRecord {\n        const piece: BunyanRecord = Object.assign({}, record);\n        piece['msg'] = messageChunk;\n        piece['logChunk'] = chunkInfo;\n        if (err !== undefined) {\n            piece['err'] = err;\n        }\n        return piece;\n    }\n\n    /**\n     * Serialized size of the record.\n     *\n     * Measured as JSON even though this path ships over gRPC/protobuf, where the true size differs.\n     * JSON over-counts (every key is spelled out, every string escaped), and over-counting is the\n     * safe direction: we chunk slightly sooner than strictly needed rather than one byte too late.\n     *\n     * The replacer is what makes this TOTAL, with no try/catch: a plain JSON.stringify throws on a\n     * circular value — real here, since request/response object cycles are exactly why the winston\n     * backend runs safe-stable-stringify — and on a bigint. A measurement that throws would take\n     * down the very log line this class exists to save.\n     */\n    private serializedBytes(record: BunyanRecord): number {\n        const seen = new WeakSet<object>();\n        const json = JSON.stringify(record, (_key: string, value: JsonValue): JsonValue => {\n            if (typeof value === 'bigint') {\n                return value.toString();\n            }\n            if (typeof value === 'object' && value !== null) {\n                if (seen.has(value)) {\n                    return '[Circular]';\n                }\n                seen.add(value);\n            }\n            return value;\n        });\n        return LogChunker.byteLength(json);\n    }\n}\n"]}

package/src/index.d.ts

@@ -36,4 +36,5 @@ export { BunyanGcpFactory } from './BunyanGcpFactory';
 export { BunyanConsoleFactory } from './BunyanConsoleFactory';
 export { BunyanLogger } from './BunyanLogger';
 export { createGoogleCloudStream, createConsoleStream } from './streams';
+export { ChunkingRawStream } from './ChunkingRawStream';
 export { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';

package/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleStream = exports.createGoogleCloudStream = exports.BunyanLogger = exports.BunyanConsoleFactory = exports.BunyanGcpFactory = void 0;
+exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.ChunkingRawStream = exports.createConsoleStream = exports.createGoogleCloudStream = exports.BunyanLogger = exports.BunyanConsoleFactory = exports.BunyanGcpFactory = void 0;
 /**
  * @webpieces/bunyan
  *
@@ -44,6 +44,8 @@ Object.defineProperty(exports, "BunyanLogger", { enumerable: true, get: function
 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 ChunkingRawStream_1 = require("./ChunkingRawStream");
+Object.defineProperty(exports, "ChunkingRawStream", { enumerable: true, get: function () { return ChunkingRawStream_1.ChunkingRawStream; } });
 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; } });

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,+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 { ServiceInfo } from '@webpieces/core-util';\n * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';\n *\n * ServiceInfo.setInfo('my-service', '2.1.0');  // FIRST — the factories read it in their constructor\n * const loggerFactory = process.env.K_SERVICE\n *   ? new BunyanGcpFactory()      // Cloud Logging via @google-cloud/logging-bunyan\n *   : new BunyanConsoleFactory(); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * BREAKING (was `new BunyanFactoryOptions('my-service')` passed to each factory): the service name\n * moved to `ServiceInfo.setInfo(...)` in @webpieces/core-util, because it is a fact about the\n * SERVICE, not about bunyan — winston needs the same name, and so does `requestIdSource`. Migration:\n * delete the `BunyanFactoryOptions` import, call `ServiceInfo.setInfo(<the same string>, <version>)`\n * before building the factory, and drop the ctor argument. A forgotten call throws at startup.\n *\n * NEW: every line now also carries `version` (the second setInfo arg) — this backend could not stamp\n * a build version before. It is opaque: a git SHA, a semver tag, a CI build number, whatever\n * identifies your build.\n *\n * Both backends auto-enrich every line with the logged context keys, read\n * DIRECTLY from the active RequestContext (@webpieces/core-context) on each line —\n * no ContextReader is threaded in. There is no level knob: bunyan filters at its\n * own default.\n *\n * @packageDocumentation\n */\nexport { BunyanGcpFactory } from './BunyanGcpFactory';\nexport { BunyanConsoleFactory } from './BunyanConsoleFactory';\nexport { BunyanLogger } from './BunyanLogger';\nexport { createGoogleCloudStream, createConsoleStream } from './streams';\nexport { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA;AAC7B,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AACrB,qCAAyE;AAAhE,kHAAA,uBAAuB,OAAA;AAAE,8GAAA,mBAAmB,OAAA;AACrD,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,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 { ServiceInfo } from '@webpieces/core-util';\n * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';\n *\n * ServiceInfo.setInfo('my-service', '2.1.0');  // FIRST — the factories read it in their constructor\n * const loggerFactory = process.env.K_SERVICE\n *   ? new BunyanGcpFactory()      // Cloud Logging via @google-cloud/logging-bunyan\n *   : new BunyanConsoleFactory(); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * BREAKING (was `new BunyanFactoryOptions('my-service')` passed to each factory): the service name\n * moved to `ServiceInfo.setInfo(...)` in @webpieces/core-util, because it is a fact about the\n * SERVICE, not about bunyan — winston needs the same name, and so does `requestIdSource`. Migration:\n * delete the `BunyanFactoryOptions` import, call `ServiceInfo.setInfo(<the same string>, <version>)`\n * before building the factory, and drop the ctor argument. A forgotten call throws at startup.\n *\n * NEW: every line now also carries `version` (the second setInfo arg) — this backend could not stamp\n * a build version before. It is opaque: a git SHA, a semver tag, a CI build number, whatever\n * identifies your build.\n *\n * Both backends auto-enrich every line with the logged context keys, read\n * DIRECTLY from the active RequestContext (@webpieces/core-context) on each line —\n * no ContextReader is threaded in. There is no level knob: bunyan filters at its\n * own default.\n *\n * @packageDocumentation\n */\nexport { BunyanGcpFactory } from './BunyanGcpFactory';\nexport { BunyanConsoleFactory } from './BunyanConsoleFactory';\nexport { BunyanLogger } from './BunyanLogger';\nexport { createGoogleCloudStream, createConsoleStream } from './streams';\nexport { ChunkingRawStream } from './ChunkingRawStream';\nexport { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';\n"]}

package/src/streams.d.ts

@@ -5,6 +5,11 @@ import Logger from 'bunyan';
  * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
  * Sends to the Cloud Logging API (needs ADC on the instance).
  *
+ * Records pass through a {@link ChunkingRawStream} first, because Cloud Logging caps a LogEntry at
+ * 256 KiB and rejects the whole `entries.write` call when one entry exceeds it — so a single fat
+ * response body or stack trace can take a batch of good entries down with it. Oversized records are
+ * SPLIT into several complete records sharing a `logChunk.uid` rather than lost or truncated.
+ *
  * We do NOT filter by level — that is bunyan's job. The stream is created at
  * bunyan's default level ('info'); there is no webpieces level knob.
  */

package/src/streams.js

@@ -6,6 +6,7 @@ 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 ChunkingRawStream_1 = require("./ChunkingRawStream");
 // bunyan record fields that are structural / rendered specially, so they are not
 // shown as context tags in the local console line.
 //
@@ -75,13 +76,25 @@ function writeConsole(line) {
  * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
  * Sends to the Cloud Logging API (needs ADC on the instance).
  *
+ * Records pass through a {@link ChunkingRawStream} first, because Cloud Logging caps a LogEntry at
+ * 256 KiB and rejects the whole `entries.write` call when one entry exceeds it — so a single fat
+ * response body or stack trace can take a batch of good entries down with it. Oversized records are
+ * SPLIT into several complete records sharing a `logChunk.uid` rather than lost or truncated.
+ *
  * We do NOT filter by level — that is bunyan's job. The stream is created at
  * bunyan's default level ('info'); there is no webpieces level knob.
  */
 // webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories
 function createGoogleCloudStream() {
     const loggingBunyan = new logging_bunyan_1.LoggingBunyan();
-    return loggingBunyan.stream('info');
+    // stream('info') returns { level, type: 'raw', stream: loggingBunyan } — we keep bunyan's raw
+    // contract and only interpose on the stream it writes records to.
+    const gcp = loggingBunyan.stream('info');
+    return {
+        level: gcp.level,
+        type: 'raw',
+        stream: new ChunkingRawStream_1.ChunkingRawStream(loggingBunyan),
+    };
 }
 /**
  * The local dev stream: human-readable text to stdout via {@link writeConsole}.

package/src/streams.js.map

@@ -1 +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 { 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.\n//\n// `name` (the service) and `version` (the build) are ServiceInfo base fields riding on EVERY\n// record. They earn their keep in GCP, where you filter across many services and deploys, but\n// locally each service logs to its own place and you can check git yourself — so as a tag on every\n// single line they are pure noise. Listing them here is the bunyan twin of winston's\n// LOCAL_STRUCTURAL_KEYS; GCP still gets both (that stream does its own formatting).\nconst BUNYAN_STD_FIELDS = new Set<string>([\n    'v',\n    'level',\n    'name',\n    'version',\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 *\n * We do NOT filter by level — that is bunyan's job. The stream is created at\n * bunyan's default level ('info'); there is no webpieces level knob.\n */\n// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories\nexport function createGoogleCloudStream(): Logger.Stream {\n    const loggingBunyan = new LoggingBunyan();\n    return loggingBunyan.stream('info');\n}\n\n/**\n * The local dev stream: human-readable text to stdout via {@link writeConsole}.\n * No level is set — bunyan filters at its own default ('info').\n */\n// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories\nexport function createConsoleStream(): 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        stream: writable,\n    };\n}\n"]}
+{"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 { LoggedError } from './LoggedError';\nimport { ChunkingRawStream } from './ChunkingRawStream';\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.\n//\n// `name` (the service) and `version` (the build) are ServiceInfo base fields riding on EVERY\n// record. They earn their keep in GCP, where you filter across many services and deploys, but\n// locally each service logs to its own place and you can check git yourself — so as a tag on every\n// single line they are pure noise. Listing them here is the bunyan twin of winston's\n// LOCAL_STRUCTURAL_KEYS; GCP still gets both (that stream does its own formatting).\nconst BUNYAN_STD_FIELDS = new Set<string>([\n    'v',\n    'level',\n    'name',\n    'version',\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 *\n * Records pass through a {@link ChunkingRawStream} first, because Cloud Logging caps a LogEntry at\n * 256 KiB and rejects the whole `entries.write` call when one entry exceeds it — so a single fat\n * response body or stack trace can take a batch of good entries down with it. Oversized records are\n * SPLIT into several complete records sharing a `logChunk.uid` rather than lost or truncated.\n *\n * We do NOT filter by level — that is bunyan's job. The stream is created at\n * bunyan's default level ('info'); there is no webpieces level knob.\n */\n// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories\nexport function createGoogleCloudStream(): Logger.Stream {\n    const loggingBunyan = new LoggingBunyan();\n    // stream('info') returns { level, type: 'raw', stream: loggingBunyan } — we keep bunyan's raw\n    // contract and only interpose on the stream it writes records to.\n    const gcp = loggingBunyan.stream('info');\n    return {\n        level: gcp.level,\n        type: 'raw',\n        stream: new ChunkingRawStream(loggingBunyan),\n    };\n}\n\n/**\n * The local dev stream: human-readable text to stdout via {@link writeConsole}.\n * No level is set — bunyan filters at its own default ('info').\n */\n// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories\nexport function createConsoleStream(): 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        stream: writable,\n    };\n}\n"]}