@webpieces/winston 0.4.395 → 0.4.396

package/README.md

@@ -16,26 +16,37 @@ Two factories, both auto-enriching every line with the logged context keys regis
 ## Usage
 
 ```ts
-import { LogManager, HeaderRegistry } from '@webpieces/core-util';
+import { ServiceInfo } from '@webpieces/core-util';
 import { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';
-import { RequestContextReader } from '@webpieces/core-context';
 
-const reader = new RequestContextReader();
+// FIRST: identify this service. Both factories read name+version in their CONSTRUCTOR, so this
+// must come before you build one — a forgotten call throws at startup rather than shipping logs
+// that cannot say which build emitted them.
+ServiceInfo.setInfo('my-service', '2.1.0');
+
 const loggerFactory = process.env.K_SERVICE
-    ? new WinstonGcpFactory(reader)
-    : new WinstonConsoleFactory(reader);
+    ? new WinstonGcpFactory()
+    : new WinstonConsoleFactory();
 
 // Typically you pass loggerFactory to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...)),
 // which calls HeaderRegistry.configure(...) then LogManager.setFactory(loggerFactory) for you.
 ```
 
-The `ContextReader` is a **constructor argument** (the node `RequestContextReader` lives in
-`@webpieces/core-context`) so this package depends only on `@webpieces/core-util` — not on
-any node context package.
+Both factories read the magic context **directly** from `RequestContext` on each line, so
+nothing is threaded in: there is no `ContextReader` constructor argument.
 
 ## Options
 
-`new WinstonGcpFactory(reader, new WinstonFactoryOptions(level, svcGitHash))`:
-
-- `level` — minimum webpieces level to emit (default `'info'`). `trace` maps to winston `silly`.
-- `svcGitHash` — when set, every line carries `jsonPayload.svcGitHash` (deployment filter).
+There are none — both factories take no arguments.
+
+- **Service name + version** — from `ServiceInfo.setInfo(...)` (see above), NOT factory options.
+  Every line carries `svcName` and `version`. They live in `@webpieces/core-util` because they
+  are facts about the SERVICE, not about winston: the bunyan backend reads the same values, and
+  `requestIdSource` reads the name (it records which service minted a request-id).
+- **`version` is opaque** — a git SHA, a semver tag, a CI build number, whatever identifies your
+  build. webpieces neither parses nor derives it; your app decides where it comes from.
+- **Local rendering** — neither `svcName` nor `version` renders in `WinstonConsoleFactory` output.
+  They earn their keep in GCP (filtering across many services and deploys); locally each service
+  logs to its own place and you can check git yourself, so on every line they are just noise.
+- **Level** — there is deliberately no knob. webpieces does not filter by level; winston filters
+  at its own default.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/winston",
-  "version": "0.4.395",
+  "version": "0.4.396",
   "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.395",
-    "@webpieces/core-context": "0.4.395",
+    "@webpieces/core-util": "0.4.396",
+    "@webpieces/core-context": "0.4.396",
     "winston": "3.11.0",
     "logform": "2.7.0",
     "safe-stable-stringify": "2.5.0"

package/src/WinstonConsoleFactory.d.ts

@@ -1,11 +1,15 @@
 import { WinstonFactoryBase } from './WinstonFactoryBase';
-import { WinstonFactoryOptions } from './WinstonFactoryOptions';
 /**
  * WinstonConsoleFactory - the LOCAL developer backend. Colorized single-line
  * pretty console output with the registered context keys as a bracketed prefix,
  * for human reading — same enrichment as the GCP backend, different rendering.
  * Matches the tested onetablet/monorepo-nx1 local logger.
+ *
+ * The service name + version come from {@link ServiceInfo} (this constructor reads them), but
+ * neither RENDERS locally: you already know which service you are running and can check git
+ * yourself, so they would be noise on every line. They still ship to GCP via the sibling
+ * {@link WinstonGcpFactory}. See LOCAL_STRUCTURAL_KEYS in ./format.
  */
 export declare class WinstonConsoleFactory extends WinstonFactoryBase {
-    constructor(opts?: WinstonFactoryOptions);
+    constructor();
 }

package/src/WinstonConsoleFactory.js

@@ -3,17 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonConsoleFactory = void 0;
 const winston_1 = require("winston");
 const WinstonFactoryBase_1 = require("./WinstonFactoryBase");
-const WinstonFactoryOptions_1 = require("./WinstonFactoryOptions");
 const format_1 = require("./format");
 /**
  * WinstonConsoleFactory - the LOCAL developer backend. Colorized single-line
  * pretty console output with the registered context keys as a bracketed prefix,
  * for human reading — same enrichment as the GCP backend, different rendering.
  * Matches the tested onetablet/monorepo-nx1 local logger.
+ *
+ * The service name + version come from {@link ServiceInfo} (this constructor reads them), but
+ * neither RENDERS locally: you already know which service you are running and can check git
+ * yourself, so they would be noise on every line. They still ship to GCP via the sibling
+ * {@link WinstonGcpFactory}. See LOCAL_STRUCTURAL_KEYS in ./format.
  */
 class WinstonConsoleFactory extends WinstonFactoryBase_1.WinstonFactoryBase {
-    constructor(opts = new WinstonFactoryOptions_1.WinstonFactoryOptions()) {
-        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.colorize(), (0, format_1.localPrettyFormat)()), opts);
+    constructor() {
+        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.colorize(), (0, format_1.localPrettyFormat)()));
     }
 }
 exports.WinstonConsoleFactory = WinstonConsoleFactory;

package/src/WinstonConsoleFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"WinstonConsoleFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonConsoleFactory.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AACjC,6DAA0D;AAC1D,mEAAgE;AAChE,qCAAoG;AAEpG;;;;;GAKG;AACH,MAAa,qBAAsB,SAAQ,uCAAkB;IACzD,YAAY,OAA8B,IAAI,6CAAqB,EAAE;QACjE,KAAK,CACD,gBAAM,CAAC,OAAO,CACV,IAAA,yBAAgB,GAAE,EAClB,IAAA,4BAAmB,GAAE,EACrB,IAAA,uBAAc,GAAE,EAChB,gBAAM,CAAC,QAAQ,EAAE,EACjB,IAAA,0BAAiB,GAAE,CACtB,EACD,IAAI,CACP,CAAC;IACN,CAAC;CACJ;AAbD,sDAaC","sourcesContent":["import { format } from 'winston';\nimport { WinstonFactoryBase } from './WinstonFactoryBase';\nimport { WinstonFactoryOptions } from './WinstonFactoryOptions';\nimport { bigIntSafeFormat, injectContextFormat, localPrettyFormat, severityFormat } from './format';\n\n/**\n * WinstonConsoleFactory - the LOCAL developer backend. Colorized single-line\n * pretty console output with the registered context keys as a bracketed prefix,\n * for human reading — same enrichment as the GCP backend, different rendering.\n * Matches the tested onetablet/monorepo-nx1 local logger.\n */\nexport class WinstonConsoleFactory extends WinstonFactoryBase {\n    constructor(opts: WinstonFactoryOptions = new WinstonFactoryOptions()) {\n        super(\n            format.combine(\n                bigIntSafeFormat(),\n                injectContextFormat(),\n                severityFormat(),\n                format.colorize(),\n                localPrettyFormat(),\n            ),\n            opts,\n        );\n    }\n}\n"]}
+{"version":3,"file":"WinstonConsoleFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonConsoleFactory.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AACjC,6DAA0D;AAC1D,qCAAoG;AAEpG;;;;;;;;;;GAUG;AACH,MAAa,qBAAsB,SAAQ,uCAAkB;IACzD;QACI,KAAK,CACD,gBAAM,CAAC,OAAO,CACV,IAAA,yBAAgB,GAAE,EAClB,IAAA,4BAAmB,GAAE,EACrB,IAAA,uBAAc,GAAE,EAChB,gBAAM,CAAC,QAAQ,EAAE,EACjB,IAAA,0BAAiB,GAAE,CACtB,CACJ,CAAC;IACN,CAAC;CACJ;AAZD,sDAYC","sourcesContent":["import { format } from 'winston';\nimport { WinstonFactoryBase } from './WinstonFactoryBase';\nimport { bigIntSafeFormat, injectContextFormat, localPrettyFormat, severityFormat } from './format';\n\n/**\n * WinstonConsoleFactory - the LOCAL developer backend. Colorized single-line\n * pretty console output with the registered context keys as a bracketed prefix,\n * for human reading — same enrichment as the GCP backend, different rendering.\n * Matches the tested onetablet/monorepo-nx1 local logger.\n *\n * The service name + version come from {@link ServiceInfo} (this constructor reads them), but\n * neither RENDERS locally: you already know which service you are running and can check git\n * yourself, so they would be noise on every line. They still ship to GCP via the sibling\n * {@link WinstonGcpFactory}. See LOCAL_STRUCTURAL_KEYS in ./format.\n */\nexport class WinstonConsoleFactory extends WinstonFactoryBase {\n    constructor() {\n        super(\n            format.combine(\n                bigIntSafeFormat(),\n                injectContextFormat(),\n                severityFormat(),\n                format.colorize(),\n                localPrettyFormat(),\n            ),\n        );\n    }\n}\n"]}

package/src/WinstonFactoryBase.d.ts

@@ -1,6 +1,5 @@
 import type { Format } from 'logform';
 import type { Logger, LoggerFactory } from '@webpieces/core-util';
-import { WinstonFactoryOptions } from './WinstonFactoryOptions';
 /**
  * WinstonFactoryBase - shared plumbing for the winston {@link LoggerFactory}
  * backends. Builds ONE underlying winston logger (a single `Console` transport,
@@ -8,15 +7,16 @@ import { WinstonFactoryOptions } from './WinstonFactoryOptions';
  * out a cached {@link WinstonLogger} per name (each a winston child carrying
  * `loggerName`). Subclasses differ only in the format stack they pass up.
  *
- * Every line carries `svcName` from {@link ServiceInfo}. Winston, unlike bunyan, has
- * NO mandatory logger name, so this backend used to emit no service name at all — a
- * winston service was distinguishable only by GCP's own resource labels. Now both
- * backends read the SAME {@link ServiceInfo}, so naming is a property of the service
- * rather than of the logging library the app happened to pick.
+ * Every line carries `svcName` + `version` from {@link ServiceInfo}. Neither used to be a property
+ * of the SERVICE: winston has no mandatory logger name (so this backend emitted none — a winston
+ * service was distinguishable only by GCP's own resource labels), and the version lived here as an
+ * optional `svcGitHash` factory option that bunyan had no counterpart for. Both now come from the
+ * ONE {@link ServiceInfo}, so the fields on your logs no longer depend on which logging library the
+ * app happened to pick. `version` is opaque — whatever string the app used to identify its build.
  */
 export declare abstract class WinstonFactoryBase implements LoggerFactory {
     private readonly base;
     private readonly loggers;
-    protected constructor(finalFormat: Format, opts: WinstonFactoryOptions);
+    protected constructor(finalFormat: Format);
     getLogger(name: string): Logger;
 }

package/src/WinstonFactoryBase.js

@@ -11,22 +11,23 @@ const WinstonLogger_1 = require("./WinstonLogger");
  * out a cached {@link WinstonLogger} per name (each a winston child carrying
  * `loggerName`). Subclasses differ only in the format stack they pass up.
  *
- * Every line carries `svcName` from {@link ServiceInfo}. Winston, unlike bunyan, has
- * NO mandatory logger name, so this backend used to emit no service name at all — a
- * winston service was distinguishable only by GCP's own resource labels. Now both
- * backends read the SAME {@link ServiceInfo}, so naming is a property of the service
- * rather than of the logging library the app happened to pick.
+ * Every line carries `svcName` + `version` from {@link ServiceInfo}. Neither used to be a property
+ * of the SERVICE: winston has no mandatory logger name (so this backend emitted none — a winston
+ * service was distinguishable only by GCP's own resource labels), and the version lived here as an
+ * optional `svcGitHash` factory option that bunyan had no counterpart for. Both now come from the
+ * ONE {@link ServiceInfo}, so the fields on your logs no longer depend on which logging library the
+ * app happened to pick. `version` is opaque — whatever string the app used to identify its build.
  */
 class WinstonFactoryBase {
     base;
     loggers = new Map();
-    constructor(finalFormat, opts) {
-        // Read at STARTUP (this ctor runs while booting), so a forgotten ServiceInfo.setName(...)
-        // fails the deploy rather than shipping unnamed logs.
-        const defaultMeta = { svcName: core_util_1.ServiceInfo.getName() };
-        if (opts.svcGitHash) {
-            defaultMeta['svcGitHash'] = opts.svcGitHash;
-        }
+    constructor(finalFormat) {
+        // 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 = {
+            svcName: core_util_1.ServiceInfo.getName(),
+            version: core_util_1.ServiceInfo.getVersion(),
+        };
         // No level set — we do NOT filter; that is winston's job (defaults to 'info').
         this.base = (0, winston_1.createLogger)({
             format: finalFormat,

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;AAGhD;;;;;;;;;;;;GAYG;AACH,MAAsB,kBAAkB;IACnB,IAAI,CAAc;IAClB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD,YAAsB,WAAmB,EAAE,IAA2B;QAClE,0FAA0F;QAC1F,sDAAsD;QACtD,MAAM,WAAW,GAA2B,EAAE,OAAO,EAAE,uBAAW,CAAC,OAAO,EAAE,EAAE,CAAC;QAC/E,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,WAAW,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QAChD,CAAC;QAED,+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';\nimport { WinstonFactoryOptions } from './WinstonFactoryOptions';\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` from {@link ServiceInfo}. Winston, unlike bunyan, has\n * NO mandatory logger name, so this backend used to emit no service name at all — a\n * winston service was distinguishable only by GCP's own resource labels. Now both\n * backends read the SAME {@link ServiceInfo}, so naming is a property of the service\n * rather than of the logging library the app happened to pick.\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, opts: WinstonFactoryOptions) {\n        // Read at STARTUP (this ctor runs while booting), so a forgotten ServiceInfo.setName(...)\n        // fails the deploy rather than shipping unnamed logs.\n        const defaultMeta: Record<string, string> = { svcName: ServiceInfo.getName() };\n        if (opts.svcGitHash) {\n            defaultMeta['svcGitHash'] = opts.svcGitHash;\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;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"]}

package/src/WinstonGcpFactory.d.ts

@@ -1,5 +1,4 @@
 import { WinstonFactoryBase } from './WinstonFactoryBase';
-import { WinstonFactoryOptions } from './WinstonFactoryOptions';
 /**
  * WinstonGcpFactory - the GCP/Cloud Run backend. Emits flat JSON to stdout; the
  * Cloud Run / GKE logging agent natively parses it — `severity` + `message` lift
@@ -8,7 +7,10 @@ import { WinstonFactoryOptions } from './WinstonFactoryOptions';
  * @google-cloud transport — correlation rides the webpieces context, read
  * DIRECTLY from RequestContext on each line. This matches the tested-in-GCP
  * onetablet/monorepo-nx1 core logger exactly.
+ *
+ * The service name + version come from {@link ServiceInfo}, which startup must have populated
+ * (this constructor reads them); they are NOT factory options.
  */
 export declare class WinstonGcpFactory extends WinstonFactoryBase {
-    constructor(opts?: WinstonFactoryOptions);
+    constructor();
 }

package/src/WinstonGcpFactory.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonGcpFactory = void 0;
 const winston_1 = require("winston");
 const WinstonFactoryBase_1 = require("./WinstonFactoryBase");
-const WinstonFactoryOptions_1 = require("./WinstonFactoryOptions");
 const format_1 = require("./format");
 /**
  * WinstonGcpFactory - the GCP/Cloud Run backend. Emits flat JSON to stdout; the
@@ -13,10 +12,13 @@ const format_1 = require("./format");
  * @google-cloud transport — correlation rides the webpieces context, read
  * DIRECTLY from RequestContext on each line. This matches the tested-in-GCP
  * onetablet/monorepo-nx1 core logger exactly.
+ *
+ * The service name + version come from {@link ServiceInfo}, which startup must have populated
+ * (this constructor reads them); they are NOT factory options.
  */
 class WinstonGcpFactory extends WinstonFactoryBase_1.WinstonFactoryBase {
-    constructor(opts = new WinstonFactoryOptions_1.WinstonFactoryOptions()) {
-        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.json()), opts);
+    constructor() {
+        super(winston_1.format.combine((0, format_1.bigIntSafeFormat)(), (0, format_1.injectContextFormat)(), (0, format_1.severityFormat)(), winston_1.format.json()));
     }
 }
 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,mEAAgE;AAChE,qCAAiF;AAEjF;;;;;;;;GAQG;AACH,MAAa,iBAAkB,SAAQ,uCAAkB;IACrD,YAAY,OAA8B,IAAI,6CAAqB,EAAE;QACjE,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,CACP,CAAC;IACN,CAAC;CACJ;AAZD,8CAYC","sourcesContent":["import { format } from 'winston';\nimport { WinstonFactoryBase } from './WinstonFactoryBase';\nimport { WinstonFactoryOptions } from './WinstonFactoryOptions';\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 */\nexport class WinstonGcpFactory extends WinstonFactoryBase {\n    constructor(opts: WinstonFactoryOptions = new WinstonFactoryOptions()) {\n        super(\n            format.combine(\n                bigIntSafeFormat(),\n                injectContextFormat(),\n                severityFormat(),\n                format.json(),\n            ),\n            opts,\n        );\n    }\n}\n"]}
+{"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"]}

package/src/format.js

@@ -106,7 +106,19 @@ function severityFormat() {
 }
 // Fields that are rendered specially (or not at all) by the local pretty format,
 // so they must not leak into the trailing "extra" JSON blob.
-const LOCAL_STRUCTURAL_KEYS = new Set(['level', 'message', 'severity', 'svcGitHash', 'loggerName']);
+//
+// `svcName` + `version` (the ServiceInfo defaultMeta fields) are here to be rendered NOT AT ALL:
+// they earn their keep in GCP, where you filter across many services and deploys, but locally each
+// service logs to its own place and you can check git yourself — so on every single line they are
+// pure noise. GCP still gets both (this set only affects localPrettyFormat).
+const LOCAL_STRUCTURAL_KEYS = new Set([
+    'level',
+    'message',
+    'severity',
+    'svcName',
+    'version',
+    'loggerName',
+]);
 /**
  * Local-only human format: `[loggerName] [requestId=… tenantId=…] level: message { …extra }`.
  * The registered context keys (already injected by injectContextFormat) render as

package/src/format.js.map

@@ -1 +1 @@
-{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/format.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The winston format layers that turn a raw webpieces log call into a\n * Cloud-Logging-ready structured record. Ported verbatim (behaviourally) from\n * the tested-in-GCP logger at\n * onetablet/monorepo-nx1 libraries/core-context/src/logger/format.ts, with the\n * one webpieces adaptation: context is read from the webpieces HeaderRegistry +\n * a ContextReader (rather than a hard-coded PLATFORM_HEADERS enum), so the exact\n * set of logged fields is whatever the app registered.\n *\n * Correlation rides the webpieces magic context (AsyncLocalStorage on the\n * server, via the ContextReader passed in) — NOT OpenTelemetry / trace-agent, so\n * nothing here imports a tracing agent.\n */\nimport { format } from 'winston';\nimport type { Format, TransformableInfo } from 'logform';\nimport { stringify as safeStringify } from 'safe-stable-stringify';\nimport { HeaderRegistry } from '@webpieces/core-util';\nimport type { ContextKey } from '@webpieces/core-util';\nimport { RequestContext } from '@webpieces/core-context';\n\n// JSON-shaped value (the widest thing a log field / replacer value can hold),\n// used instead of `any`/`unknown` which the code rules disallow.\ntype JsonValue = string | number | boolean | bigint | object | null | undefined;\n\n// winston level → GCP Cloud Logging severity. The Cloud Run / GKE logging agent\n// recognises top-level `severity` in stdout JSON; without this map it falls back\n// to \"DEFAULT\" which is unfilterable. webpieces `trace` maps onto winston `silly`\n// (see WinstonLogger), so both land at DEBUG severity.\nexport const LEVEL_TO_SEVERITY: Record<string, string> = {\n    silly: 'DEBUG',\n    verbose: 'DEBUG',\n    debug: 'DEBUG',\n    info: 'INFO',\n    warn: 'WARNING',\n    error: 'ERROR',\n};\n\n/**\n * Round-trip the record through safe-stable-stringify so circular references\n * (HTTP client/response cycles, request/response objects, framework execution\n * contexts) become \"[Circular]\" instead of crashing the log emit, and bigints\n * serialize as strings (JSON.stringify can't, and the bare safe-stringify output\n * wouldn't round-trip through JSON.parse). Symbol keys winston relies on are\n * untouched (JSON ignores them), so Object.assign only rewrites string fields.\n */\nexport function bigIntSafeFormat(): Format {\n    return format((info: TransformableInfo) => {\n        return Object.assign(\n            info,\n            JSON.parse(\n                // webpieces-disable no-any-unknown -- safe-stable-stringify's Replacer types the value as unknown\n                safeStringify(info, (_key: string, value: unknown) => {\n                    if (typeof value === 'bigint') {\n                        return value.toString();\n                    }\n                    return value;\n                })!,\n            ),\n        );\n    })();\n}\n\n/**\n * Inject every logged HeaderRegistry key present in the active RequestContext frame\n * into the record under its `name` (→ top-level jsonPayload.<name> in GCP, filterable\n * as jsonPayload.requestId, jsonPayload.tenantId, …). Values are read DIRECTLY from\n * RequestContext, secured keys masked via {@link ContextKey.maskIfSecured} — no\n * ContextReader. Caller-supplied fields on the record win on conflict. Runs on EVERY\n * winston call, including winston's own handleExceptions/handleRejections lines that\n * bypass the WinstonLogger wrapper.\n *\n * This mirrors the (duplicated, on purpose) inline logic in BunyanLogger: it must run\n * ONLY when a winston backend is installed, never for the plain ConsoleLogger. A log\n * line with no active RequestContext = a missing request-wrapping server filter; we\n * report that once (closure latch, via console.error so there is no re-entrancy back\n * into winston and no dependency on LogManager).\n */\n// webpieces-disable no-function-outside-class -- winston format(fn) factory; whole file is winston Format factories\nexport function injectContextFormat(): Format {\n    let reportedMissingContext = false;\n    return format((info: TransformableInfo) => {\n        if (RequestContext.isActive()) {\n            // ONE loop, in HeaderRegistry.buildStructuredLogFields. Values may be OBJECTS (the `api`\n            // tag), so an object-valued key nests into jsonPayload.<name> (winston JSON-serializes the\n            // whole record) rather than being dropped by the string-only buildLogFields. Caller-supplied\n            // fields win on conflict.\n            RequestContext.buildStructuredLogFields().forEach((value: string | object, name: string) => {\n                if (info[name] === undefined) {\n                    info[name] = value;\n                }\n            });\n        } else if (!reportedMissingContext) {\n            reportedMissingContext = true;\n            // This IS a logging backend; direct stderr for the framework-misconfig warning.\n            console.error(\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: ' +\n                    'correlation fields (requestId, tenant, ...) will be absent from logs. Reported once.',\n            );\n        }\n        return info;\n    })();\n}\n\n/**\n * Map the winston level onto a top-level `severity` field that the Cloud Logging\n * agent lifts onto the LogEntry.\n */\nexport function severityFormat(): Format {\n    return format((info: TransformableInfo) => {\n        info['severity'] = LEVEL_TO_SEVERITY[info.level] || info.level.toUpperCase();\n        return info;\n    })();\n}\n\n// Fields that are rendered specially (or not at all) by the local pretty format,\n// so they must not leak into the trailing \"extra\" JSON blob.\nconst LOCAL_STRUCTURAL_KEYS = new Set<string>(['level', 'message', 'severity', 'svcGitHash', 'loggerName']);\n\n/**\n * Local-only human format: `[loggerName] [requestId=… tenantId=…] level: message { …extra }`.\n * The registered context keys (already injected by injectContextFormat) render as\n * a bracketed prefix; anything else the caller attached renders as trailing JSON.\n * The set of context-key names is read lazily from the registry (first line).\n */\nexport function localPrettyFormat(): Format {\n    let contextNames: Set<string> | undefined;\n    return format.printf((info: TransformableInfo) => {\n        if (!contextNames) {\n            contextNames = new Set(HeaderRegistry.get().getLoggedKeys().map((k: ContextKey) => k.name));\n        }\n        // Only STRING context values render in the bracket prefix. An object-valued key (the `api`\n        // tag) would stringify to \"[object Object]\" here, so it is left out of the prefix and instead\n        // falls into the trailing JSON blob below (readable), while GCP still gets it nested.\n        const prefixBits: string[] = [];\n        for (const name of contextNames) {\n            const value = info[name];\n            if (value != null && typeof value === 'string') {\n                prefixBits.push(`${name}=${value}`);\n            }\n        }\n        const prefix = prefixBits.length ? `[${prefixBits.join(' ')}] ` : '';\n        const loggerName = info['loggerName'] ? `[${String(info['loggerName'])}] ` : '';\n\n        const rest: Record<string, JsonValue> = {};\n        for (const key of Object.keys(info)) {\n            if (LOCAL_STRUCTURAL_KEYS.has(key)) {\n                continue;\n            }\n            // A context key already shown in the bracket prefix (string value) is skipped; an\n            // object-valued context key (api) was NOT shown there, so let it render as trailing JSON.\n            if (contextNames.has(key) && typeof info[key] === 'string') {\n                continue;\n            }\n            rest[key] = info[key] as JsonValue;\n        }\n        const restStr = Object.keys(rest).length ? ` ${safeStringify(rest)}` : '';\n\n        return `${loggerName}${prefix}${info.level}: ${info.message}${restStr}`;\n    });\n}\n"]}
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/format.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The winston format layers that turn a raw webpieces log call into a\n * Cloud-Logging-ready structured record. Ported verbatim (behaviourally) from\n * the tested-in-GCP logger at\n * onetablet/monorepo-nx1 libraries/core-context/src/logger/format.ts, with the\n * one webpieces adaptation: context is read from the webpieces HeaderRegistry +\n * a ContextReader (rather than a hard-coded PLATFORM_HEADERS enum), so the exact\n * set of logged fields is whatever the app registered.\n *\n * Correlation rides the webpieces magic context (AsyncLocalStorage on the\n * server, via the ContextReader passed in) — NOT OpenTelemetry / trace-agent, so\n * nothing here imports a tracing agent.\n */\nimport { format } from 'winston';\nimport type { Format, TransformableInfo } from 'logform';\nimport { stringify as safeStringify } from 'safe-stable-stringify';\nimport { HeaderRegistry } from '@webpieces/core-util';\nimport type { ContextKey } from '@webpieces/core-util';\nimport { RequestContext } from '@webpieces/core-context';\n\n// JSON-shaped value (the widest thing a log field / replacer value can hold),\n// used instead of `any`/`unknown` which the code rules disallow.\ntype JsonValue = string | number | boolean | bigint | object | null | undefined;\n\n// winston level → GCP Cloud Logging severity. The Cloud Run / GKE logging agent\n// recognises top-level `severity` in stdout JSON; without this map it falls back\n// to \"DEFAULT\" which is unfilterable. webpieces `trace` maps onto winston `silly`\n// (see WinstonLogger), so both land at DEBUG severity.\nexport const LEVEL_TO_SEVERITY: Record<string, string> = {\n    silly: 'DEBUG',\n    verbose: 'DEBUG',\n    debug: 'DEBUG',\n    info: 'INFO',\n    warn: 'WARNING',\n    error: 'ERROR',\n};\n\n/**\n * Round-trip the record through safe-stable-stringify so circular references\n * (HTTP client/response cycles, request/response objects, framework execution\n * contexts) become \"[Circular]\" instead of crashing the log emit, and bigints\n * serialize as strings (JSON.stringify can't, and the bare safe-stringify output\n * wouldn't round-trip through JSON.parse). Symbol keys winston relies on are\n * untouched (JSON ignores them), so Object.assign only rewrites string fields.\n */\nexport function bigIntSafeFormat(): Format {\n    return format((info: TransformableInfo) => {\n        return Object.assign(\n            info,\n            JSON.parse(\n                // webpieces-disable no-any-unknown -- safe-stable-stringify's Replacer types the value as unknown\n                safeStringify(info, (_key: string, value: unknown) => {\n                    if (typeof value === 'bigint') {\n                        return value.toString();\n                    }\n                    return value;\n                })!,\n            ),\n        );\n    })();\n}\n\n/**\n * Inject every logged HeaderRegistry key present in the active RequestContext frame\n * into the record under its `name` (→ top-level jsonPayload.<name> in GCP, filterable\n * as jsonPayload.requestId, jsonPayload.tenantId, …). Values are read DIRECTLY from\n * RequestContext, secured keys masked via {@link ContextKey.maskIfSecured} — no\n * ContextReader. Caller-supplied fields on the record win on conflict. Runs on EVERY\n * winston call, including winston's own handleExceptions/handleRejections lines that\n * bypass the WinstonLogger wrapper.\n *\n * This mirrors the (duplicated, on purpose) inline logic in BunyanLogger: it must run\n * ONLY when a winston backend is installed, never for the plain ConsoleLogger. A log\n * line with no active RequestContext = a missing request-wrapping server filter; we\n * report that once (closure latch, via console.error so there is no re-entrancy back\n * into winston and no dependency on LogManager).\n */\n// webpieces-disable no-function-outside-class -- winston format(fn) factory; whole file is winston Format factories\nexport function injectContextFormat(): Format {\n    let reportedMissingContext = false;\n    return format((info: TransformableInfo) => {\n        if (RequestContext.isActive()) {\n            // ONE loop, in HeaderRegistry.buildStructuredLogFields. Values may be OBJECTS (the `api`\n            // tag), so an object-valued key nests into jsonPayload.<name> (winston JSON-serializes the\n            // whole record) rather than being dropped by the string-only buildLogFields. Caller-supplied\n            // fields win on conflict.\n            RequestContext.buildStructuredLogFields().forEach((value: string | object, name: string) => {\n                if (info[name] === undefined) {\n                    info[name] = value;\n                }\n            });\n        } else if (!reportedMissingContext) {\n            reportedMissingContext = true;\n            // This IS a logging backend; direct stderr for the framework-misconfig warning.\n            console.error(\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: ' +\n                    'correlation fields (requestId, tenant, ...) will be absent from logs. Reported once.',\n            );\n        }\n        return info;\n    })();\n}\n\n/**\n * Map the winston level onto a top-level `severity` field that the Cloud Logging\n * agent lifts onto the LogEntry.\n */\nexport function severityFormat(): Format {\n    return format((info: TransformableInfo) => {\n        info['severity'] = LEVEL_TO_SEVERITY[info.level] || info.level.toUpperCase();\n        return info;\n    })();\n}\n\n// Fields that are rendered specially (or not at all) by the local pretty format,\n// so they must not leak into the trailing \"extra\" JSON blob.\n//\n// `svcName` + `version` (the ServiceInfo defaultMeta fields) are here to be rendered NOT AT ALL:\n// they earn their keep in GCP, where you filter across many services and deploys, but locally each\n// service logs to its own place and you can check git yourself — so on every single line they are\n// pure noise. GCP still gets both (this set only affects localPrettyFormat).\nconst LOCAL_STRUCTURAL_KEYS = new Set<string>([\n    'level',\n    'message',\n    'severity',\n    'svcName',\n    'version',\n    'loggerName',\n]);\n\n/**\n * Local-only human format: `[loggerName] [requestId=… tenantId=…] level: message { …extra }`.\n * The registered context keys (already injected by injectContextFormat) render as\n * a bracketed prefix; anything else the caller attached renders as trailing JSON.\n * The set of context-key names is read lazily from the registry (first line).\n */\nexport function localPrettyFormat(): Format {\n    let contextNames: Set<string> | undefined;\n    return format.printf((info: TransformableInfo) => {\n        if (!contextNames) {\n            contextNames = new Set(HeaderRegistry.get().getLoggedKeys().map((k: ContextKey) => k.name));\n        }\n        // Only STRING context values render in the bracket prefix. An object-valued key (the `api`\n        // tag) would stringify to \"[object Object]\" here, so it is left out of the prefix and instead\n        // falls into the trailing JSON blob below (readable), while GCP still gets it nested.\n        const prefixBits: string[] = [];\n        for (const name of contextNames) {\n            const value = info[name];\n            if (value != null && typeof value === 'string') {\n                prefixBits.push(`${name}=${value}`);\n            }\n        }\n        const prefix = prefixBits.length ? `[${prefixBits.join(' ')}] ` : '';\n        const loggerName = info['loggerName'] ? `[${String(info['loggerName'])}] ` : '';\n\n        const rest: Record<string, JsonValue> = {};\n        for (const key of Object.keys(info)) {\n            if (LOCAL_STRUCTURAL_KEYS.has(key)) {\n                continue;\n            }\n            // A context key already shown in the bracket prefix (string value) is skipped; an\n            // object-valued context key (api) was NOT shown there, so let it render as trailing JSON.\n            if (contextNames.has(key) && typeof info[key] === 'string') {\n                continue;\n            }\n            rest[key] = info[key] as JsonValue;\n        }\n        const restStr = Object.keys(rest).length ? ` ${safeStringify(rest)}` : '';\n\n        return `${loggerName}${prefix}${info.level}: ${info.message}${restStr}`;\n    });\n}\n"]}

package/src/index.d.ts

@@ -5,22 +5,33 @@
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
+ * import { ServiceInfo } from '@webpieces/core-util';
  * import { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';
  *
+ * ServiceInfo.setInfo('my-service', '2.1.0');  // FIRST — the factories read it in their constructor
  * const loggerFactory = process.env.K_SERVICE
  *   ? new WinstonGcpFactory()      // Cloud Run → stdout JSON
  *   : new WinstonConsoleFactory(); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
+ * BREAKING (was `new WinstonFactoryOptions(svcGitHash)` passed to each factory): the version moved
+ * to `ServiceInfo.setInfo(name, version)` in @webpieces/core-util, because it is a fact about the
+ * SERVICE, not about winston — bunyan needs the same version and previously could not stamp one at
+ * all. It is also no longer presumed to be a git SHA: `version` is opaque, so a project deploying
+ * semver or CI build numbers is no longer misdescribed. Migration: delete the `WinstonFactoryOptions`
+ * import, call `ServiceInfo.setInfo(<name>, <the same hash>)` before building the factory, and drop
+ * the ctor argument. A forgotten call throws at startup. Note the field renamed `svcGitHash` →
+ * `version`, so GCP log filters/alerts on `jsonPayload.svcGitHash` must be updated.
+ *
  * Both backends auto-enrich every line with the logged context keys, read
  * DIRECTLY from the active RequestContext (@webpieces/core-context) on each line —
- * no ContextReader is threaded in.
+ * no ContextReader is threaded in. Every line also carries `svcName` + `version` from ServiceInfo,
+ * though neither renders in the LOCAL pretty format (you know your own service, and can check git).
  *
  * @packageDocumentation
  */
 export { WinstonGcpFactory } from './WinstonGcpFactory';
 export { WinstonConsoleFactory } from './WinstonConsoleFactory';
-export { WinstonFactoryOptions } from './WinstonFactoryOptions';
 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.WinstonFactoryOptions = 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.WinstonConsoleFactory = exports.WinstonGcpFactory = void 0;
 /**
  * @webpieces/winston
  *
@@ -8,17 +8,29 @@ exports.localPrettyFormat = exports.severityFormat = exports.injectContextFormat
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
+ * import { ServiceInfo } from '@webpieces/core-util';
  * import { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';
  *
+ * ServiceInfo.setInfo('my-service', '2.1.0');  // FIRST — the factories read it in their constructor
  * const loggerFactory = process.env.K_SERVICE
  *   ? new WinstonGcpFactory()      // Cloud Run → stdout JSON
  *   : new WinstonConsoleFactory(); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
+ * BREAKING (was `new WinstonFactoryOptions(svcGitHash)` passed to each factory): the version moved
+ * to `ServiceInfo.setInfo(name, version)` in @webpieces/core-util, because it is a fact about the
+ * SERVICE, not about winston — bunyan needs the same version and previously could not stamp one at
+ * all. It is also no longer presumed to be a git SHA: `version` is opaque, so a project deploying
+ * semver or CI build numbers is no longer misdescribed. Migration: delete the `WinstonFactoryOptions`
+ * import, call `ServiceInfo.setInfo(<name>, <the same hash>)` before building the factory, and drop
+ * the ctor argument. A forgotten call throws at startup. Note the field renamed `svcGitHash` →
+ * `version`, so GCP log filters/alerts on `jsonPayload.svcGitHash` must be updated.
+ *
  * Both backends auto-enrich every line with the logged context keys, read
  * DIRECTLY from the active RequestContext (@webpieces/core-context) on each line —
- * no ContextReader is threaded in.
+ * no ContextReader is threaded in. Every line also carries `svcName` + `version` from ServiceInfo,
+ * though neither renders in the LOCAL pretty format (you know your own service, and can check git).
  *
  * @packageDocumentation
  */
@@ -26,8 +38,6 @@ 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 WinstonFactoryOptions_1 = require("./WinstonFactoryOptions");
-Object.defineProperty(exports, "WinstonFactoryOptions", { enumerable: true, get: function () { return WinstonFactoryOptions_1.WinstonFactoryOptions; } });
 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;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAC1B,iEAAgE;AAAvD,8HAAA,qBAAqB,OAAA;AAC9B,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 { WinstonGcpFactory, WinstonConsoleFactory } from '@webpieces/winston';\n *\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 * 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.\n *\n * @packageDocumentation\n */\nexport { WinstonGcpFactory } from './WinstonGcpFactory';\nexport { WinstonConsoleFactory } from './WinstonConsoleFactory';\nexport { WinstonFactoryOptions } from './WinstonFactoryOptions';\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,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"]}

package/src/WinstonFactoryOptions.d.ts

@@ -1,24 +0,0 @@
-/**
- * WinstonFactoryOptions - tuning for the winston LoggerFactory backends.
- *
- * Data-only structure → a class, per CLAUDE.md.
- *
- * There is deliberately NO level knob: webpieces does not filter by level — that
- * is winston's job (it filters at its own default). `svcGitHash` is optional, so a
- * bare `new WinstonGcpFactory()` still works.
- */
-export declare class WinstonFactoryOptions {
-    /**
-     * The running service's git commit SHA. When set, every line carries
-     * `jsonPayload.svcGitHash=<sha>` (winston defaultMeta) so operators can
-     * filter Cloud Logging by deployment.
-     */
-    readonly svcGitHash?: string | undefined;
-    constructor(
-    /**
-     * The running service's git commit SHA. When set, every line carries
-     * `jsonPayload.svcGitHash=<sha>` (winston defaultMeta) so operators can
-     * filter Cloud Logging by deployment.
-     */
-    svcGitHash?: string | undefined);
-}

package/src/WinstonFactoryOptions.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WinstonFactoryOptions = void 0;
-/**
- * WinstonFactoryOptions - tuning for the winston LoggerFactory backends.
- *
- * Data-only structure → a class, per CLAUDE.md.
- *
- * There is deliberately NO level knob: webpieces does not filter by level — that
- * is winston's job (it filters at its own default). `svcGitHash` is optional, so a
- * bare `new WinstonGcpFactory()` still works.
- */
-class WinstonFactoryOptions {
-    svcGitHash;
-    constructor(
-    /**
-     * The running service's git commit SHA. When set, every line carries
-     * `jsonPayload.svcGitHash=<sha>` (winston defaultMeta) so operators can
-     * filter Cloud Logging by deployment.
-     */
-    svcGitHash) {
-        this.svcGitHash = svcGitHash;
-    }
-}
-exports.WinstonFactoryOptions = WinstonFactoryOptions;
-//# sourceMappingURL=WinstonFactoryOptions.js.map

package/src/WinstonFactoryOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"WinstonFactoryOptions.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonFactoryOptions.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;GAQG;AACH,MAAa,qBAAqB;IAOV;IANpB;IACI;;;;OAIG;IACa,UAAmB;QAAnB,eAAU,GAAV,UAAU,CAAS;IACpC,CAAC;CACP;AATD,sDASC","sourcesContent":["/**\n * WinstonFactoryOptions - tuning for the winston LoggerFactory backends.\n *\n * Data-only structure → a class, per CLAUDE.md.\n *\n * There is deliberately NO level knob: webpieces does not filter by level — that\n * is winston's job (it filters at its own default). `svcGitHash` is optional, so a\n * bare `new WinstonGcpFactory()` still works.\n */\nexport class WinstonFactoryOptions {\n    constructor(\n        /**\n         * The running service's git commit SHA. When set, every line carries\n         * `jsonPayload.svcGitHash=<sha>` (winston defaultMeta) so operators can\n         * filter Cloud Logging by deployment.\n         */\n        public readonly svcGitHash?: string,\n    ) {}\n}\n"]}