@webpieces/winston 0.4.396 → 0.4.397

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/winston",
-  "version": "0.4.396",
+  "version": "0.4.397",
   "description": "Node-only winston LoggerFactory backends for webpieces: Console (local pretty) + GCP (Cloud Run stdout JSON), 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",
     "winston": "3.11.0",
     "logform": "2.7.0",
     "safe-stable-stringify": "2.5.0"

package/src/ChunkingConsoleTransport.d.ts

@@ -0,0 +1,48 @@
+import { transports } from 'winston';
+import type { TransformableInfo } from 'logform';
+/**
+ * ChunkingConsoleTransport - a winston Console transport that SPLITS an oversized record into
+ * several complete records instead of letting GCP silently drop it.
+ *
+ * WHY A TRANSPORT, not the WinstonLogger wrapper — two reasons, both decisive:
+ *
+ * 1. COVERAGE. WinstonFactoryBase sets `handleExceptions: true` / `handleRejections: true`, and
+ *    those lines are emitted by winston itself, bypassing WinstonLogger entirely. An uncaught
+ *    exception carrying a huge stack trace is exactly the log you cannot afford to lose, so the
+ *    guard has to sit below the wrapper.
+ * 2. EXACT MEASUREMENT. A transport runs AFTER the format chain, so `info[MESSAGE]` is the fully
+ *    rendered line — envelope and all (severity, svcName, requestId, tenantId, the `api` tag). We
+ *    measure the real thing rather than estimating the caller's contribution and hoping.
+ *
+ * WHY IT RE-SERIALIZES rather than slicing `info[MESSAGE]`: a fragment of a JSON line is not valid
+ * JSON, so the logging agent would file each piece as an unparsed `textPayload` and every structured
+ * field would be lost. Each emitted piece must be a COMPLETE, parseable record — so we chunk the
+ * oversized FIELDS and rebuild N records, each tagged with a shared {@link LogChunkInfo}.
+ *
+ * GCP-ONLY: wired in by WinstonGcpFactory. WinstonConsoleFactory keeps a plain Console transport —
+ * a dev terminal has no size limit and splitting there would only hurt readability.
+ *
+ * The common case is untouched: a record within budget goes straight to `super.log` and is
+ * byte-identical to what it was before this class existed.
+ */
+export declare class ChunkingConsoleTransport extends transports.Console {
+    private readonly budgetBytes;
+    constructor(budgetBytes?: number);
+    log(info: TransformableInfo, callback: () => void): void;
+    /**
+     * Hand one finished record to the real Console transport. winston types `log` as optional on the
+     * base, so we resolve it once here rather than sprinkling `?.` at the call sites — and if it were
+     * ever truly absent we still fire the callback, because swallowing it would hang the logger.
+     */
+    private writeThrough;
+    /** Split the oversized record's fields and emit one complete record per piece. */
+    private logChunked;
+    /**
+     * Rebuild one complete record: every original field, with `message`/`errStack` replaced by this
+     * piece and a `logChunk` tag added, re-serialized exactly the way format.json() would (same
+     * safe-stable-stringify, so circular refs stay "[Circular]").
+     */
+    private buildRecord;
+    /** The fully-rendered line the format chain produced (what a transport writes). */
+    private rendered;
+}

package/src/ChunkingConsoleTransport.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChunkingConsoleTransport = void 0;
+const winston_1 = require("winston");
+const safe_stable_stringify_1 = require("safe-stable-stringify");
+const core_util_1 = require("@webpieces/core-util");
+// winston's own symbol (not a DI token): it holds the FINAL rendered line — what format.json()
+// produced and what a transport actually writes — as distinct from the `message` string PROPERTY,
+// which is the caller's text. We need both: the symbol to measure, the property to re-chunk.
+// webpieces-disable no-symbol-di-tokens -- winston's documented internal record key (Symbol.for('message')), not a DI token
+const MESSAGE = Symbol.for('message');
+/**
+ * ChunkingConsoleTransport - a winston Console transport that SPLITS an oversized record into
+ * several complete records instead of letting GCP silently drop it.
+ *
+ * WHY A TRANSPORT, not the WinstonLogger wrapper — two reasons, both decisive:
+ *
+ * 1. COVERAGE. WinstonFactoryBase sets `handleExceptions: true` / `handleRejections: true`, and
+ *    those lines are emitted by winston itself, bypassing WinstonLogger entirely. An uncaught
+ *    exception carrying a huge stack trace is exactly the log you cannot afford to lose, so the
+ *    guard has to sit below the wrapper.
+ * 2. EXACT MEASUREMENT. A transport runs AFTER the format chain, so `info[MESSAGE]` is the fully
+ *    rendered line — envelope and all (severity, svcName, requestId, tenantId, the `api` tag). We
+ *    measure the real thing rather than estimating the caller's contribution and hoping.
+ *
+ * WHY IT RE-SERIALIZES rather than slicing `info[MESSAGE]`: a fragment of a JSON line is not valid
+ * JSON, so the logging agent would file each piece as an unparsed `textPayload` and every structured
+ * field would be lost. Each emitted piece must be a COMPLETE, parseable record — so we chunk the
+ * oversized FIELDS and rebuild N records, each tagged with a shared {@link LogChunkInfo}.
+ *
+ * GCP-ONLY: wired in by WinstonGcpFactory. WinstonConsoleFactory keeps a plain Console transport —
+ * a dev terminal has no size limit and splitting there would only hurt readability.
+ *
+ * The common case is untouched: a record within budget goes straight to `super.log` and is
+ * byte-identical to what it was before this class existed.
+ */
+class ChunkingConsoleTransport extends winston_1.transports.Console {
+    budgetBytes;
+    constructor(budgetBytes = core_util_1.GCP_LOG_BUDGET_BYTES) {
+        super();
+        this.budgetBytes = budgetBytes;
+    }
+    log(info, callback) {
+        const rendered = this.rendered(info);
+        if (core_util_1.LogChunker.byteLength(rendered) <= this.budgetBytes) {
+            // The overwhelmingly common path — unchanged behaviour, no extra work beyond one measure.
+            this.writeThrough(info, callback);
+            return;
+        }
+        this.logChunked(info, rendered, callback);
+    }
+    /**
+     * Hand one finished record to the real Console transport. winston types `log` as optional on the
+     * base, so we resolve it once here rather than sprinkling `?.` at the call sites — and if it were
+     * ever truly absent we still fire the callback, because swallowing it would hang the logger.
+     */
+    writeThrough(info, callback) {
+        const parentLog = super.log;
+        if (!parentLog) {
+            callback();
+            return;
+        }
+        parentLog.call(this, info, callback);
+    }
+    /** Split the oversized record's fields and emit one complete record per piece. */
+    logChunked(info, rendered, callback) {
+        const message = typeof info.message === 'string' ? info.message : String(info.message ?? '');
+        const stack = typeof info['errStack'] === 'string' ? info['errStack'] : undefined;
+        const budgets = core_util_1.LogChunker.chunkBudgets(core_util_1.LogChunker.byteLength(rendered), 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);
+        for (let index = 0; index < total; index++) {
+            const piece = this.buildRecord(info, messageChunks[index] ?? '', stack === undefined ? undefined : (stackChunks[index] ?? ''), new core_util_1.LogChunkInfo(uid, index, total));
+            // Only the LAST piece completes the write; winston expects exactly one callback per log().
+            this.writeThrough(piece, index === total - 1 ? callback : () => undefined);
+        }
+    }
+    /**
+     * Rebuild one complete record: every original field, with `message`/`errStack` replaced by this
+     * piece and a `logChunk` tag added, re-serialized exactly the way format.json() would (same
+     * safe-stable-stringify, so circular refs stay "[Circular]").
+     */
+    buildRecord(info, messageChunk, stackChunk, chunkInfo) {
+        const fields = {};
+        // Object.keys skips winston's symbol keys, so this is exactly the set format.json() serializes.
+        for (const key of Object.keys(info)) {
+            fields[key] = info[key];
+        }
+        fields['message'] = messageChunk;
+        if (stackChunk !== undefined) {
+            fields['errStack'] = stackChunk;
+        }
+        fields['logChunk'] = chunkInfo;
+        // Object.assign copies own enumerable SYMBOL keys too, so winston's LEVEL symbol (which the
+        // Console transport reads) survives; then we overwrite the rendered line with this piece's.
+        const piece = Object.assign({}, info, fields);
+        piece[MESSAGE] = (0, safe_stable_stringify_1.stringify)(fields) ?? '';
+        return piece;
+    }
+    /** The fully-rendered line the format chain produced (what a transport writes). */
+    rendered(info) {
+        const message = info[MESSAGE];
+        return typeof message === 'string' ? message : String(message ?? '');
+    }
+}
+exports.ChunkingConsoleTransport = ChunkingConsoleTransport;
+//# sourceMappingURL=ChunkingConsoleTransport.js.map

package/src/ChunkingConsoleTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkingConsoleTransport.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/ChunkingConsoleTransport.ts"],"names":[],"mappings":"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","sourcesContent":["import { transports } from 'winston';\nimport type { TransformableInfo } from 'logform';\nimport { stringify as safeStringify } from 'safe-stable-stringify';\nimport { GCP_LOG_BUDGET_BYTES, LogChunker, LogChunkInfo } from '@webpieces/core-util';\n\n// winston's own symbol (not a DI token): it holds the FINAL rendered line — what format.json()\n// produced and what a transport actually writes — as distinct from the `message` string PROPERTY,\n// which is the caller's text. We need both: the symbol to measure, the property to re-chunk.\n// webpieces-disable no-symbol-di-tokens -- winston's documented internal record key (Symbol.for('message')), not a DI token\nconst MESSAGE = Symbol.for('message');\n\n// JSON-shaped value (the widest thing a winston record field can hold), used instead of\n// `any`/`unknown` which the code rules disallow. Mirrors the JsonValue in format.ts.\ntype JsonValue = string | number | boolean | bigint | object | null | undefined;\n\n/**\n * ChunkingConsoleTransport - a winston Console transport that SPLITS an oversized record into\n * several complete records instead of letting GCP silently drop it.\n *\n * WHY A TRANSPORT, not the WinstonLogger wrapper — two reasons, both decisive:\n *\n * 1. COVERAGE. WinstonFactoryBase sets `handleExceptions: true` / `handleRejections: true`, and\n *    those lines are emitted by winston itself, bypassing WinstonLogger entirely. An uncaught\n *    exception carrying a huge stack trace is exactly the log you cannot afford to lose, so the\n *    guard has to sit below the wrapper.\n * 2. EXACT MEASUREMENT. A transport runs AFTER the format chain, so `info[MESSAGE]` is the fully\n *    rendered line — envelope and all (severity, svcName, requestId, tenantId, the `api` tag). We\n *    measure the real thing rather than estimating the caller's contribution and hoping.\n *\n * WHY IT RE-SERIALIZES rather than slicing `info[MESSAGE]`: a fragment of a JSON line is not valid\n * JSON, so the logging agent would file each piece as an unparsed `textPayload` and every structured\n * field would be lost. Each emitted piece must be a COMPLETE, parseable record — so we chunk the\n * oversized FIELDS and rebuild N records, each tagged with a shared {@link LogChunkInfo}.\n *\n * GCP-ONLY: wired in by WinstonGcpFactory. WinstonConsoleFactory keeps a plain Console transport —\n * a dev terminal has no size limit and splitting there would only hurt readability.\n *\n * The common case is untouched: a record within budget goes straight to `super.log` and is\n * byte-identical to what it was before this class existed.\n */\nexport class ChunkingConsoleTransport extends transports.Console {\n    private readonly budgetBytes: number;\n\n    constructor(budgetBytes: number = GCP_LOG_BUDGET_BYTES) {\n        super();\n        this.budgetBytes = budgetBytes;\n    }\n\n    override log(info: TransformableInfo, callback: () => void): void {\n        const rendered = this.rendered(info);\n        if (LogChunker.byteLength(rendered) <= this.budgetBytes) {\n            // The overwhelmingly common path — unchanged behaviour, no extra work beyond one measure.\n            this.writeThrough(info, callback);\n            return;\n        }\n        this.logChunked(info, rendered, callback);\n    }\n\n    /**\n     * Hand one finished record to the real Console transport. winston types `log` as optional on the\n     * base, so we resolve it once here rather than sprinkling `?.` at the call sites — and if it were\n     * ever truly absent we still fire the callback, because swallowing it would hang the logger.\n     */\n    private writeThrough(info: TransformableInfo, callback: () => void): void {\n        const parentLog = super.log;\n        if (!parentLog) {\n            callback();\n            return;\n        }\n        parentLog.call(this, info, callback);\n    }\n\n    /** Split the oversized record's fields and emit one complete record per piece. */\n    private logChunked(info: TransformableInfo, rendered: string, callback: () => void): void {\n        const message = typeof info.message === 'string' ? info.message : String(info.message ?? '');\n        const stack = typeof info['errStack'] === 'string' ? info['errStack'] : undefined;\n\n        const budgets = LogChunker.chunkBudgets(\n            LogChunker.byteLength(rendered), this.budgetBytes, message, stack ?? '',\n        );\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        for (let index = 0; index < total; index++) {\n            const piece = this.buildRecord(\n                info,\n                messageChunks[index] ?? '',\n                stack === undefined ? undefined : (stackChunks[index] ?? ''),\n                new LogChunkInfo(uid, index, total),\n            );\n            // Only the LAST piece completes the write; winston expects exactly one callback per log().\n            this.writeThrough(piece, index === total - 1 ? callback : (): void => undefined);\n        }\n    }\n\n    /**\n     * Rebuild one complete record: every original field, with `message`/`errStack` replaced by this\n     * piece and a `logChunk` tag added, re-serialized exactly the way format.json() would (same\n     * safe-stable-stringify, so circular refs stay \"[Circular]\").\n     */\n    private buildRecord(\n        info: TransformableInfo,\n        messageChunk: string,\n        stackChunk: string | undefined,\n        chunkInfo: LogChunkInfo,\n    ): TransformableInfo {\n        const fields: Record<string, JsonValue> = {};\n        // Object.keys skips winston's symbol keys, so this is exactly the set format.json() serializes.\n        for (const key of Object.keys(info)) {\n            fields[key] = (info as Record<string, JsonValue>)[key];\n        }\n        fields['message'] = messageChunk;\n        if (stackChunk !== undefined) {\n            fields['errStack'] = stackChunk;\n        }\n        fields['logChunk'] = chunkInfo;\n\n        // Object.assign copies own enumerable SYMBOL keys too, so winston's LEVEL symbol (which the\n        // Console transport reads) survives; then we overwrite the rendered line with this piece's.\n        const piece = Object.assign({}, info, fields) as TransformableInfo;\n        (piece as Record<symbol, JsonValue>)[MESSAGE] = safeStringify(fields) ?? '';\n        return piece;\n    }\n\n    /** The fully-rendered line the format chain produced (what a transport writes). */\n    private rendered(info: TransformableInfo): string {\n        const message = (info as Record<symbol, JsonValue>)[MESSAGE];\n        return typeof message === 'string' ? message : String(message ?? '');\n    }\n}\n"]}

package/src/WinstonFactoryBase.d.ts

@@ -1,3 +1,4 @@
+import type Transport from 'winston-transport';
 import type { Format } from 'logform';
 import type { Logger, LoggerFactory } from '@webpieces/core-util';
 /**
@@ -17,6 +18,12 @@ import type { Logger, LoggerFactory } from '@webpieces/core-util';
 export declare abstract class WinstonFactoryBase implements LoggerFactory {
     private readonly base;
     private readonly loggers;
-    protected constructor(finalFormat: Format);
+    /**
+     * @param transport - the sink to write through. Defaults to a plain Console; the GCP subclass
+     *   passes a {@link ChunkingConsoleTransport} instead, because only there does a per-entry size
+     *   limit exist. Taking the whole transport (rather than a size knob) keeps the size limit a fact
+     *   about the SINK, which is where it actually lives — a dev terminal has no such limit.
+     */
+    protected constructor(finalFormat: Format, transport?: Transport);
     getLogger(name: string): Logger;
 }

package/src/WinstonFactoryBase.js

@@ -21,7 +21,13 @@ const WinstonLogger_1 = require("./WinstonLogger");
 class WinstonFactoryBase {
     base;
     loggers = new Map();
-    constructor(finalFormat) {
+    /**
+     * @param transport - the sink to write through. Defaults to a plain Console; the GCP subclass
+     *   passes a {@link ChunkingConsoleTransport} instead, because only there does a per-entry size
+     *   limit exist. Taking the whole transport (rather than a size knob) keeps the size limit a fact
+     *   about the SINK, which is where it actually lives — a dev terminal has no such limit.
+     */
+    constructor(finalFormat, transport) {
         // Read at STARTUP (this ctor runs while booting), so a forgotten ServiceInfo.setInfo(...)
         // fails the deploy rather than shipping logs that cannot say which build emitted them.
         const defaultMeta = {
@@ -32,7 +38,7 @@ class WinstonFactoryBase {
         this.base = (0, winston_1.createLogger)({
             format: finalFormat,
             defaultMeta: defaultMeta,
-            transports: [new winston_1.transports.Console()],
+            transports: [transport ?? new winston_1.transports.Console()],
             handleExceptions: true,
             handleRejections: true,
         });

package/src/WinstonFactoryBase.js.map

@@ -1 +1 @@
-{"version":3,"file":"WinstonFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonFactoryBase.ts"],"names":[],"mappings":";;;AAAA,qCAAmD;AAInD,oDAAmD;AACnD,mDAAgD;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAsB,kBAAkB;IACnB,IAAI,CAAc;IAClB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD,YAAsB,WAAmB;QACrC,0FAA0F;QAC1F,uFAAuF;QACvF,MAAM,WAAW,GAA2B;YACxC,OAAO,EAAE,uBAAW,CAAC,OAAO,EAAE;YAC9B,OAAO,EAAE,uBAAW,CAAC,UAAU,EAAE;SACpC,CAAC;QAEF,+EAA+E;QAC/E,IAAI,CAAC,IAAI,GAAG,IAAA,sBAAY,EAAC;YACrB,MAAM,EAAE,WAAW;YACnB,WAAW,EAAE,WAAW;YACxB,UAAU,EAAE,CAAC,IAAI,oBAAU,CAAC,OAAO,EAAE,CAAC;YACtC,gBAAgB,EAAE,IAAI;YACtB,gBAAgB,EAAE,IAAI;SACzB,CAAC,CAAC;IACP,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,6BAAa,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AA9BD,gDA8BC","sourcesContent":["import { createLogger, transports } from 'winston';\nimport type { Logger as WinstonBase } from 'winston';\nimport type { Format } from 'logform';\nimport type { Logger, LoggerFactory } from '@webpieces/core-util';\nimport { ServiceInfo } from '@webpieces/core-util';\nimport { WinstonLogger } from './WinstonLogger';\n\n/**\n * WinstonFactoryBase - shared plumbing for the winston {@link LoggerFactory}\n * backends. Builds ONE underlying winston logger (a single `Console` transport,\n * handleExceptions/Rejections on) with the caller-chosen format stack, then hands\n * out a cached {@link WinstonLogger} per name (each a winston child carrying\n * `loggerName`). Subclasses differ only in the format stack they pass up.\n *\n * Every line carries `svcName` + `version` from {@link ServiceInfo}. Neither used to be a property\n * of the SERVICE: winston has no mandatory logger name (so this backend emitted none — a winston\n * service was distinguishable only by GCP's own resource labels), and the version lived here as an\n * optional `svcGitHash` factory option that bunyan had no counterpart for. Both now come from the\n * ONE {@link ServiceInfo}, so the fields on your logs no longer depend on which logging library the\n * app happened to pick. `version` is opaque — whatever string the app used to identify its build.\n */\nexport abstract class WinstonFactoryBase implements LoggerFactory {\n    private readonly base: WinstonBase;\n    private readonly loggers = new Map<string, Logger>();\n\n    protected constructor(finalFormat: Format) {\n        // Read at STARTUP (this ctor runs while booting), so a forgotten ServiceInfo.setInfo(...)\n        // fails the deploy rather than shipping logs that cannot say which build emitted them.\n        const defaultMeta: Record<string, string> = {\n            svcName: ServiceInfo.getName(),\n            version: ServiceInfo.getVersion(),\n        };\n\n        // No level set — we do NOT filter; that is winston's job (defaults to 'info').\n        this.base = createLogger({\n            format: finalFormat,\n            defaultMeta: defaultMeta,\n            transports: [new transports.Console()],\n            handleExceptions: true,\n            handleRejections: true,\n        });\n    }\n\n    getLogger(name: string): Logger {\n        let logger = this.loggers.get(name);\n        if (!logger) {\n            logger = new WinstonLogger(this.base.child({ loggerName: name }));\n            this.loggers.set(name, logger);\n        }\n        return logger;\n    }\n}\n"]}
+{"version":3,"file":"WinstonFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonFactoryBase.ts"],"names":[],"mappings":";;;AAAA,qCAAmD;AAKnD,oDAAmD;AACnD,mDAAgD;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAsB,kBAAkB;IACnB,IAAI,CAAc;IAClB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD;;;;;OAKG;IACH,YAAsB,WAAmB,EAAE,SAAqB;QAC5D,0FAA0F;QAC1F,uFAAuF;QACvF,MAAM,WAAW,GAA2B;YACxC,OAAO,EAAE,uBAAW,CAAC,OAAO,EAAE;YAC9B,OAAO,EAAE,uBAAW,CAAC,UAAU,EAAE;SACpC,CAAC;QAEF,+EAA+E;QAC/E,IAAI,CAAC,IAAI,GAAG,IAAA,sBAAY,EAAC;YACrB,MAAM,EAAE,WAAW;YACnB,WAAW,EAAE,WAAW;YACxB,UAAU,EAAE,CAAC,SAAS,IAAI,IAAI,oBAAU,CAAC,OAAO,EAAE,CAAC;YACnD,gBAAgB,EAAE,IAAI;YACtB,gBAAgB,EAAE,IAAI;SACzB,CAAC,CAAC;IACP,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,6BAAa,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ;AApCD,gDAoCC","sourcesContent":["import { createLogger, transports } from 'winston';\nimport type { Logger as WinstonBase } from 'winston';\nimport type Transport from 'winston-transport';\nimport type { Format } from 'logform';\nimport type { Logger, LoggerFactory } from '@webpieces/core-util';\nimport { ServiceInfo } from '@webpieces/core-util';\nimport { WinstonLogger } from './WinstonLogger';\n\n/**\n * WinstonFactoryBase - shared plumbing for the winston {@link LoggerFactory}\n * backends. Builds ONE underlying winston logger (a single `Console` transport,\n * handleExceptions/Rejections on) with the caller-chosen format stack, then hands\n * out a cached {@link WinstonLogger} per name (each a winston child carrying\n * `loggerName`). Subclasses differ only in the format stack they pass up.\n *\n * Every line carries `svcName` + `version` from {@link ServiceInfo}. Neither used to be a property\n * of the SERVICE: winston has no mandatory logger name (so this backend emitted none — a winston\n * service was distinguishable only by GCP's own resource labels), and the version lived here as an\n * optional `svcGitHash` factory option that bunyan had no counterpart for. Both now come from the\n * ONE {@link ServiceInfo}, so the fields on your logs no longer depend on which logging library the\n * app happened to pick. `version` is opaque — whatever string the app used to identify its build.\n */\nexport abstract class WinstonFactoryBase implements LoggerFactory {\n    private readonly base: WinstonBase;\n    private readonly loggers = new Map<string, Logger>();\n\n    /**\n     * @param transport - the sink to write through. Defaults to a plain Console; the GCP subclass\n     *   passes a {@link ChunkingConsoleTransport} instead, because only there does a per-entry size\n     *   limit exist. Taking the whole transport (rather than a size knob) keeps the size limit a fact\n     *   about the SINK, which is where it actually lives — a dev terminal has no such limit.\n     */\n    protected constructor(finalFormat: Format, transport?: Transport) {\n        // Read at STARTUP (this ctor runs while booting), so a forgotten ServiceInfo.setInfo(...)\n        // fails the deploy rather than shipping logs that cannot say which build emitted them.\n        const defaultMeta: Record<string, string> = {\n            svcName: ServiceInfo.getName(),\n            version: ServiceInfo.getVersion(),\n        };\n\n        // No level set — we do NOT filter; that is winston's job (defaults to 'info').\n        this.base = createLogger({\n            format: finalFormat,\n            defaultMeta: defaultMeta,\n            transports: [transport ?? new transports.Console()],\n            handleExceptions: true,\n            handleRejections: true,\n        });\n    }\n\n    getLogger(name: string): Logger {\n        let logger = this.loggers.get(name);\n        if (!logger) {\n            logger = new WinstonLogger(this.base.child({ loggerName: name }));\n            this.loggers.set(name, logger);\n        }\n        return logger;\n    }\n}\n"]}

package/src/WinstonGcpFactory.d.ts

@@ -10,6 +10,12 @@ import { WinstonFactoryBase } from './WinstonFactoryBase';
  *
  * The service name + version come from {@link ServiceInfo}, which startup must have populated
  * (this constructor reads them); they are NOT factory options.
+ *
+ * Writes through a {@link ChunkingConsoleTransport} rather than a plain Console, because THIS is the
+ * backend with a size limit: Cloud Logging caps a LogEntry at 256 KiB and — critically — an
+ * oversized jsonPayload entry is DROPPED, not truncated, with no error raised anywhere. A big
+ * response body or stack trace would simply never appear. The transport splits such a record into
+ * several complete, parseable records sharing a `jsonPayload.logChunk.uid`.
  */
 export declare class WinstonGcpFactory extends WinstonFactoryBase {
     constructor();

package/src/WinstonGcpFactory.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonGcpFactory = void 0;
 const winston_1 = require("winston");
 const WinstonFactoryBase_1 = require("./WinstonFactoryBase");
+const ChunkingConsoleTransport_1 = require("./ChunkingConsoleTransport");
 const format_1 = require("./format");
 /**
  * WinstonGcpFactory - the GCP/Cloud Run backend. Emits flat JSON to stdout; the
@@ -15,10 +16,16 @@ const format_1 = require("./format");
  *
  * The service name + version come from {@link ServiceInfo}, which startup must have populated
  * (this constructor reads them); they are NOT factory options.
+ *
+ * Writes through a {@link ChunkingConsoleTransport} rather than a plain Console, because THIS is the
+ * backend with a size limit: Cloud Logging caps a LogEntry at 256 KiB and — critically — an
+ * oversized jsonPayload entry is DROPPED, not truncated, with no error raised anywhere. A big
+ * response body or stack trace would simply never appear. The transport splits such a record into
+ * several complete, parseable records sharing a `jsonPayload.logChunk.uid`.
  */
 class WinstonGcpFactory extends WinstonFactoryBase_1.WinstonFactoryBase {
     constructor() {
-        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.json()));
+        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.json()), new ChunkingConsoleTransport_1.ChunkingConsoleTransport());
     }
 }
 exports.WinstonGcpFactory = WinstonGcpFactory;

package/src/WinstonGcpFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"WinstonGcpFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonGcpFactory.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AACjC,6DAA0D;AAC1D,qCAAiF;AAEjF;;;;;;;;;;;GAWG;AACH,MAAa,iBAAkB,SAAQ,uCAAkB;IACrD;QACI,KAAK,CACD,gBAAM,CAAC,OAAO,CACV,IAAA,yBAAgB,GAAE,EAClB,IAAA,4BAAmB,GAAE,EACrB,IAAA,uBAAc,GAAE,EAChB,gBAAM,CAAC,IAAI,EAAE,CAChB,CACJ,CAAC;IACN,CAAC;CACJ;AAXD,8CAWC","sourcesContent":["import { format } from 'winston';\nimport { WinstonFactoryBase } from './WinstonFactoryBase';\nimport { bigIntSafeFormat, injectContextFormat, severityFormat } from './format';\n\n/**\n * WinstonGcpFactory - the GCP/Cloud Run backend. Emits flat JSON to stdout; the\n * Cloud Run / GKE logging agent natively parses it — `severity` + `message` lift\n * onto the LogEntry and every registered context key lands at top-level\n * jsonPayload.<name> (requestId, tenantId, …), filterable directly. There is NO\n * @google-cloud transport — correlation rides the webpieces context, read\n * DIRECTLY from RequestContext on each line. This matches the tested-in-GCP\n * onetablet/monorepo-nx1 core logger exactly.\n *\n * The service name + version come from {@link ServiceInfo}, which startup must have populated\n * (this constructor reads them); they are NOT factory options.\n */\nexport class WinstonGcpFactory extends WinstonFactoryBase {\n    constructor() {\n        super(\n            format.combine(\n                bigIntSafeFormat(),\n                injectContextFormat(),\n                severityFormat(),\n                format.json(),\n            ),\n        );\n    }\n}\n"]}
+{"version":3,"file":"WinstonGcpFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonGcpFactory.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AACjC,6DAA0D;AAC1D,yEAAsE;AACtE,qCAAiF;AAEjF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,iBAAkB,SAAQ,uCAAkB;IACrD;QACI,KAAK,CACD,gBAAM,CAAC,OAAO,CACV,IAAA,yBAAgB,GAAE,EAClB,IAAA,4BAAmB,GAAE,EACrB,IAAA,uBAAc,GAAE,EAChB,gBAAM,CAAC,IAAI,EAAE,CAChB,EACD,IAAI,mDAAwB,EAAE,CACjC,CAAC;IACN,CAAC;CACJ;AAZD,8CAYC","sourcesContent":["import { format } from 'winston';\nimport { WinstonFactoryBase } from './WinstonFactoryBase';\nimport { ChunkingConsoleTransport } from './ChunkingConsoleTransport';\nimport { bigIntSafeFormat, injectContextFormat, severityFormat } from './format';\n\n/**\n * WinstonGcpFactory - the GCP/Cloud Run backend. Emits flat JSON to stdout; the\n * Cloud Run / GKE logging agent natively parses it — `severity` + `message` lift\n * onto the LogEntry and every registered context key lands at top-level\n * jsonPayload.<name> (requestId, tenantId, …), filterable directly. There is NO\n * @google-cloud transport — correlation rides the webpieces context, read\n * DIRECTLY from RequestContext on each line. This matches the tested-in-GCP\n * onetablet/monorepo-nx1 core logger exactly.\n *\n * The service name + version come from {@link ServiceInfo}, which startup must have populated\n * (this constructor reads them); they are NOT factory options.\n *\n * Writes through a {@link ChunkingConsoleTransport} rather than a plain Console, because THIS is the\n * backend with a size limit: Cloud Logging caps a LogEntry at 256 KiB and — critically — an\n * oversized jsonPayload entry is DROPPED, not truncated, with no error raised anywhere. A big\n * response body or stack trace would simply never appear. The transport splits such a record into\n * several complete, parseable records sharing a `jsonPayload.logChunk.uid`.\n */\nexport class WinstonGcpFactory extends WinstonFactoryBase {\n    constructor() {\n        super(\n            format.combine(\n                bigIntSafeFormat(),\n                injectContextFormat(),\n                severityFormat(),\n                format.json(),\n            ),\n            new ChunkingConsoleTransport(),\n        );\n    }\n}\n"]}

package/src/index.d.ts

@@ -33,5 +33,6 @@
  */
 export { WinstonGcpFactory } from './WinstonGcpFactory';
 export { WinstonConsoleFactory } from './WinstonConsoleFactory';
+export { ChunkingConsoleTransport } from './ChunkingConsoleTransport';
 export { WinstonLogger, LEVEL_TO_WINSTON } from './WinstonLogger';
 export { LEVEL_TO_SEVERITY, bigIntSafeFormat, injectContextFormat, severityFormat, localPrettyFormat, } from './format';

package/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localPrettyFormat = exports.severityFormat = exports.injectContextFormat = exports.bigIntSafeFormat = exports.LEVEL_TO_SEVERITY = exports.LEVEL_TO_WINSTON = exports.WinstonLogger = exports.WinstonConsoleFactory = exports.WinstonGcpFactory = void 0;
+exports.localPrettyFormat = exports.severityFormat = exports.injectContextFormat = exports.bigIntSafeFormat = exports.LEVEL_TO_SEVERITY = exports.LEVEL_TO_WINSTON = exports.WinstonLogger = exports.ChunkingConsoleTransport = exports.WinstonConsoleFactory = exports.WinstonGcpFactory = void 0;
 /**
  * @webpieces/winston
  *
@@ -38,6 +38,8 @@ var WinstonGcpFactory_1 = require("./WinstonGcpFactory");
 Object.defineProperty(exports, "WinstonGcpFactory", { enumerable: true, get: function () { return WinstonGcpFactory_1.WinstonGcpFactory; } });
 var WinstonConsoleFactory_1 = require("./WinstonConsoleFactory");
 Object.defineProperty(exports, "WinstonConsoleFactory", { enumerable: true, get: function () { return WinstonConsoleFactory_1.WinstonConsoleFactory; } });
+var ChunkingConsoleTransport_1 = require("./ChunkingConsoleTransport");
+Object.defineProperty(exports, "ChunkingConsoleTransport", { enumerable: true, get: function () { return ChunkingConsoleTransport_1.ChunkingConsoleTransport; } });
 var WinstonLogger_1 = require("./WinstonLogger");
 Object.defineProperty(exports, "WinstonLogger", { enumerable: true, get: function () { return WinstonLogger_1.WinstonLogger; } });
 Object.defineProperty(exports, "LEVEL_TO_WINSTON", { enumerable: true, get: function () { return WinstonLogger_1.LEVEL_TO_WINSTON; } });

package/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,iDAAkE;AAAzD,8GAAA,aAAa,OAAA;AAAE,iHAAA,gBAAgB,OAAA;AACxC,mCAMkB;AALd,2GAAA,iBAAiB,OAAA;AACjB,0GAAA,gBAAgB,OAAA;AAChB,6GAAA,mBAAmB,OAAA;AACnB,wGAAA,cAAc,OAAA;AACd,2GAAA,iBAAiB,OAAA","sourcesContent":["/**\n * @webpieces/winston\n *\n * Node-only winston {@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 { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';\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 WinstonGcpFactory()      // Cloud Run → stdout JSON\n *   : new WinstonConsoleFactory(); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * BREAKING (was `new WinstonFactoryOptions(svcGitHash)` passed to each factory): the version moved\n * to `ServiceInfo.setInfo(name, version)` in @webpieces/core-util, because it is a fact about the\n * SERVICE, not about winston — bunyan needs the same version and previously could not stamp one at\n * all. It is also no longer presumed to be a git SHA: `version` is opaque, so a project deploying\n * semver or CI build numbers is no longer misdescribed. Migration: delete the `WinstonFactoryOptions`\n * import, call `ServiceInfo.setInfo(<name>, <the same hash>)` before building the factory, and drop\n * the ctor argument. A forgotten call throws at startup. Note the field renamed `svcGitHash` →\n * `version`, so GCP log filters/alerts on `jsonPayload.svcGitHash` must be updated.\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. Every line also carries `svcName` + `version` from ServiceInfo,\n * though neither renders in the LOCAL pretty format (you know your own service, and can check git).\n *\n * @packageDocumentation\n */\nexport { WinstonGcpFactory } from './WinstonGcpFactory';\nexport { WinstonConsoleFactory } from './WinstonConsoleFactory';\nexport { WinstonLogger, LEVEL_TO_WINSTON } from './WinstonLogger';\nexport {\n    LEVEL_TO_SEVERITY,\n    bigIntSafeFormat,\n    injectContextFormat,\n    severityFormat,\n    localPrettyFormat,\n} from './format';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,uEAAsE;AAA7D,oIAAA,wBAAwB,OAAA;AACjC,iDAAkE;AAAzD,8GAAA,aAAa,OAAA;AAAE,iHAAA,gBAAgB,OAAA;AACxC,mCAMkB;AALd,2GAAA,iBAAiB,OAAA;AACjB,0GAAA,gBAAgB,OAAA;AAChB,6GAAA,mBAAmB,OAAA;AACnB,wGAAA,cAAc,OAAA;AACd,2GAAA,iBAAiB,OAAA","sourcesContent":["/**\n * @webpieces/winston\n *\n * Node-only winston {@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 { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';\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 WinstonGcpFactory()      // Cloud Run → stdout JSON\n *   : new WinstonConsoleFactory(); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * BREAKING (was `new WinstonFactoryOptions(svcGitHash)` passed to each factory): the version moved\n * to `ServiceInfo.setInfo(name, version)` in @webpieces/core-util, because it is a fact about the\n * SERVICE, not about winston — bunyan needs the same version and previously could not stamp one at\n * all. It is also no longer presumed to be a git SHA: `version` is opaque, so a project deploying\n * semver or CI build numbers is no longer misdescribed. Migration: delete the `WinstonFactoryOptions`\n * import, call `ServiceInfo.setInfo(<name>, <the same hash>)` before building the factory, and drop\n * the ctor argument. A forgotten call throws at startup. Note the field renamed `svcGitHash` →\n * `version`, so GCP log filters/alerts on `jsonPayload.svcGitHash` must be updated.\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. Every line also carries `svcName` + `version` from ServiceInfo,\n * though neither renders in the LOCAL pretty format (you know your own service, and can check git).\n *\n * @packageDocumentation\n */\nexport { WinstonGcpFactory } from './WinstonGcpFactory';\nexport { WinstonConsoleFactory } from './WinstonConsoleFactory';\nexport { ChunkingConsoleTransport } from './ChunkingConsoleTransport';\nexport { WinstonLogger, LEVEL_TO_WINSTON } from './WinstonLogger';\nexport {\n    LEVEL_TO_SEVERITY,\n    bigIntSafeFormat,\n    injectContextFormat,\n    severityFormat,\n    localPrettyFormat,\n} from './format';\n"]}