@webpieces/winston 0.4.446 → 0.4.447

package/package.json

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

package/src/WinstonFactoryBase.d.ts

@@ -8,14 +8,12 @@ import type { Logger, LoggerFactory } from '@webpieces/core-util';
  * 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 has no mandatory logger name, so this
- * backend used to emit none — a winston service was distinguishable only by GCP's own resource
- * labels). It is read here at construction and rides as `defaultMeta`; it is simply absent if the
- * service was not identified before this factory was built.
- *
- * `version` is NOT read here: it is stamped per-record by `RequestContext.buildStructuredLogFields`
- * (the one map `injectContextFormat` already loops), so it appears the moment `setInfo` runs — even
- * if that is after this factory was constructed — and logging works before it.
+ * Neither `svcName` nor `version` is read here: BOTH are stamped per-record by
+ * `RequestContext.buildStructuredLogFields` (the one map `injectContextFormat` already loops), so they
+ * appear the moment `setInfo` runs — even if that is after this factory was constructed — and logging
+ * works before it. This keeps winston and bunyan symmetrical: both read the same two ServiceInfo facts
+ * from the same map, on every line. (svcName used to ride as construction-time `defaultMeta`, which
+ * silently missed a `setInfo` that ran after the factory was built.)
  */
 export declare abstract class WinstonFactoryBase implements LoggerFactory {
     private readonly base;

package/src/WinstonFactoryBase.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonFactoryBase = void 0;
 const winston_1 = require("winston");
-const core_util_1 = require("@webpieces/core-util");
 const WinstonLogger_1 = require("./WinstonLogger");
 /**
  * WinstonFactoryBase - shared plumbing for the winston {@link LoggerFactory}
@@ -11,14 +10,12 @@ 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 has no mandatory logger name, so this
- * backend used to emit none — a winston service was distinguishable only by GCP's own resource
- * labels). It is read here at construction and rides as `defaultMeta`; it is simply absent if the
- * service was not identified before this factory was built.
- *
- * `version` is NOT read here: it is stamped per-record by `RequestContext.buildStructuredLogFields`
- * (the one map `injectContextFormat` already loops), so it appears the moment `setInfo` runs — even
- * if that is after this factory was constructed — and logging works before it.
+ * Neither `svcName` nor `version` is read here: BOTH are stamped per-record by
+ * `RequestContext.buildStructuredLogFields` (the one map `injectContextFormat` already loops), so they
+ * appear the moment `setInfo` runs — even if that is after this factory was constructed — and logging
+ * works before it. This keeps winston and bunyan symmetrical: both read the same two ServiceInfo facts
+ * from the same map, on every line. (svcName used to ride as construction-time `defaultMeta`, which
+ * silently missed a `setInfo` that ran after the factory was built.)
  */
 class WinstonFactoryBase {
     base;
@@ -30,19 +27,12 @@ class WinstonFactoryBase {
      *   about the SINK, which is where it actually lives — a dev terminal has no such limit.
      */
     constructor(finalFormat, transport) {
-        // svcName is a base field on every record when known. Non-throwing read: if the service was
-        // not identified before this factory was built, svcName is simply omitted rather than blocking
-        // the deploy — setupRuntime identifies the service via ServiceInfo.setInfo (name+version are
-        // required inputs) before it serves traffic.
-        const svcName = core_util_1.ServiceInfo.getName();
-        const defaultMeta = {};
-        if (svcName) {
-            defaultMeta['svcName'] = svcName;
-        }
-        // No level set — we do NOT filter; that is winston's job (defaults to 'info').
+        // No defaultMeta: svcName + version are BOTH stamped per-record by injectContextFormat (reading
+        // RequestContext.buildStructuredLogFields), so they pick up a late setInfo and stay symmetrical
+        // with the bunyan backend. No level set — we do NOT filter; that is winston's job (defaults to
+        // 'info').
         this.base = (0, winston_1.createLogger)({
             format: finalFormat,
-            defaultMeta: defaultMeta,
             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;AAKnD,oDAAmD;AACnD,mDAAgD;AAEhD;;;;;;;;;;;;;;;GAeG;AACH,MAAsB,kBAAkB;IACnB,IAAI,CAAc;IAClB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD;;;;;OAKG;IACH,YAAsB,WAAmB,EAAE,SAAqB;QAC5D,4FAA4F;QAC5F,+FAA+F;QAC/F,6FAA6F;QAC7F,6CAA6C;QAC7C,MAAM,OAAO,GAAG,uBAAW,CAAC,OAAO,EAAE,CAAC;QACtC,MAAM,WAAW,GAA2B,EAAE,CAAC;QAC/C,IAAI,OAAO,EAAE,CAAC;YACV,WAAW,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC;QACrC,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,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;AAvCD,gDAuCC","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` from {@link ServiceInfo} (winston has no mandatory logger name, so this\n * backend used to emit none — a winston service was distinguishable only by GCP's own resource\n * labels). It is read here at construction and rides as `defaultMeta`; it is simply absent if the\n * service was not identified before this factory was built.\n *\n * `version` is NOT read here: it is stamped per-record by `RequestContext.buildStructuredLogFields`\n * (the one map `injectContextFormat` already loops), so it appears the moment `setInfo` runs — even\n * if that is after this factory was constructed — and logging works before it.\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        // svcName is a base field on every record when known. Non-throwing read: if the service was\n        // not identified before this factory was built, svcName is simply omitted rather than blocking\n        // the deploy — setupRuntime identifies the service via ServiceInfo.setInfo (name+version are\n        // required inputs) before it serves traffic.\n        const svcName = ServiceInfo.getName();\n        const defaultMeta: Record<string, string> = {};\n        if (svcName) {\n            defaultMeta['svcName'] = svcName;\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"]}
+{"version":3,"file":"WinstonFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/winston/src/WinstonFactoryBase.ts"],"names":[],"mappings":";;;AAAA,qCAAmD;AAKnD,mDAAgD;AAEhD;;;;;;;;;;;;;GAaG;AACH,MAAsB,kBAAkB;IACnB,IAAI,CAAc;IAClB,OAAO,GAAG,IAAI,GAAG,EAAkB,CAAC;IAErD;;;;;OAKG;IACH,YAAsB,WAAmB,EAAE,SAAqB;QAC5D,gGAAgG;QAChG,gGAAgG;QAChG,+FAA+F;QAC/F,WAAW;QACX,IAAI,CAAC,IAAI,GAAG,IAAA,sBAAY,EAAC;YACrB,MAAM,EAAE,WAAW;YACnB,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;AA/BD,gDA+BC","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 { 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 * Neither `svcName` nor `version` is read here: BOTH are stamped per-record by\n * `RequestContext.buildStructuredLogFields` (the one map `injectContextFormat` already loops), so they\n * appear the moment `setInfo` runs — even if that is after this factory was constructed — and logging\n * works before it. This keeps winston and bunyan symmetrical: both read the same two ServiceInfo facts\n * from the same map, on every line. (svcName used to ride as construction-time `defaultMeta`, which\n * silently missed a `setInfo` that ran after the factory was built.)\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        // No defaultMeta: svcName + version are BOTH stamped per-record by injectContextFormat (reading\n        // RequestContext.buildStructuredLogFields), so they pick up a late setInfo and stay symmetrical\n        // with the bunyan backend. No level set — we do NOT filter; that is winston's job (defaults to\n        // 'info').\n        this.base = createLogger({\n            format: finalFormat,\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"]}