@webpieces/bunyan 0.3.313 → 0.3.316

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/bunyan",
-  "version": "0.3.313",
+  "version": "0.3.316",
   "description": "Node-only bunyan LoggerFactory backends for webpieces: Console (local pretty) + GCP (@google-cloud/logging-bunyan), auto-enriched with HeaderRegistry context keys",
   "type": "commonjs",
   "main": "./src/index.js",
@@ -23,7 +23,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@webpieces/core-util": "0.3.313",
+    "@webpieces/core-util": "0.3.316",
+    "@webpieces/core-context": "0.3.316",
     "bunyan": "1.8.15",
     "@google-cloud/logging-bunyan": "5.1.0",
     "@types/bunyan": "1.8.11"

package/src/BunyanConsoleFactory.d.ts

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

package/src/BunyanConsoleFactory.js

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

package/src/BunyanConsoleFactory.js.map

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

package/src/BunyanFactoryBase.d.ts

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

package/src/BunyanFactoryBase.js

@@ -8,21 +8,20 @@ const BunyanLogger_1 = require("./BunyanLogger");
  * BunyanFactoryBase - shared plumbing for the bunyan {@link LoggerFactory}
  * backends. Builds ONE underlying bunyan logger with the caller-chosen stream,
  * then hands out a cached {@link BunyanLogger} per name (each a bunyan child
- * carrying `loggerName`, wrapping the shared ContextReader). Subclasses differ
- * only in the stream they pass up (GCP vs local console).
+ * carrying `loggerName`). Every logger reads the magic context DIRECTLY from
+ * RequestContext, so nothing is threaded through here. Subclasses differ only in
+ * the stream they pass up (GCP vs local console).
  */
 class BunyanFactoryBase {
-    reader;
     base;
     loggers = new Map();
-    constructor(reader, name, streams) {
-        this.reader = reader;
+    constructor(name, streams) {
         this.base = bunyan_1.default.createLogger({ name, streams });
     }
     getLogger(name) {
         let logger = this.loggers.get(name);
         if (!logger) {
-            logger = new BunyanLogger_1.BunyanLogger(this.base.child({ loggerName: name }), this.reader);
+            logger = new BunyanLogger_1.BunyanLogger(this.base.child({ loggerName: name }));
             this.loggers.set(name, logger);
         }
         return logger;

package/src/BunyanFactoryBase.js.map

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

package/src/BunyanFactoryOptions.d.ts

@@ -1,24 +1,21 @@
-import type { LogLevel } from '@webpieces/core-util';
 /**
  * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
  *
- * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare
- * `new BunyanGcpFactory(reader)` uses the defaults.
+ * Data-only structure → a class, per CLAUDE.md.
+ *
+ * There is deliberately NO level knob: webpieces does not filter by level — that
+ * is bunyan's job (bunyan filters at its own default). You must name the service.
  */
 export declare class BunyanFactoryOptions {
-    /** Minimum webpieces level to emit. Defaults to 'info'. */
-    readonly level: LogLevel;
     /**
      * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). Defaults to 'webpieces'.
+     * payload). REQUIRED — every service names itself.
      */
     readonly serviceName: string;
     constructor(
-    /** Minimum webpieces level to emit. Defaults to 'info'. */
-    level?: LogLevel, 
     /**
      * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). Defaults to 'webpieces'.
+     * payload). REQUIRED — every service names itself.
      */
-    serviceName?: string);
+    serviceName: string);
 }

package/src/BunyanFactoryOptions.js

@@ -4,21 +4,19 @@ exports.BunyanFactoryOptions = void 0;
 /**
  * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
  *
- * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare
- * `new BunyanGcpFactory(reader)` uses the defaults.
+ * Data-only structure → a class, per CLAUDE.md.
+ *
+ * There is deliberately NO level knob: webpieces does not filter by level — that
+ * is bunyan's job (bunyan filters at its own default). You must name the service.
  */
 class BunyanFactoryOptions {
-    level;
     serviceName;
     constructor(
-    /** Minimum webpieces level to emit. Defaults to 'info'. */
-    level = 'info', 
     /**
      * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). Defaults to 'webpieces'.
+     * payload). REQUIRED — every service names itself.
      */
-    serviceName = 'webpieces') {
-        this.level = level;
+    serviceName) {
         this.serviceName = serviceName;
     }
 }

package/src/BunyanFactoryOptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"BunyanFactoryOptions.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryOptions.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACH,MAAa,oBAAoB;IAGT;IAKA;IAPpB;IACI,2DAA2D;IAC3C,QAAkB,MAAM;IACxC;;;OAGG;IACa,cAAsB,WAAW;QALjC,UAAK,GAAL,KAAK,CAAmB;QAKxB,gBAAW,GAAX,WAAW,CAAsB;IAClD,CAAC;CACP;AAVD,oDAUC","sourcesContent":["import type { LogLevel } from '@webpieces/core-util';\n\n/**\n * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.\n *\n * Data-only structure → a class, per CLAUDE.md. All fields optional; a bare\n * `new BunyanGcpFactory(reader)` uses the defaults.\n */\nexport class BunyanFactoryOptions {\n    constructor(\n        /** Minimum webpieces level to emit. Defaults to 'info'. */\n        public readonly level: LogLevel = 'info',\n        /**\n         * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON\n         * payload). Defaults to 'webpieces'.\n         */\n        public readonly serviceName: string = 'webpieces',\n    ) {}\n}\n"]}
+{"version":3,"file":"BunyanFactoryOptions.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryOptions.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,MAAa,oBAAoB;IAMT;IALpB;IACI;;;OAGG;IACa,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;IACpC,CAAC;CACP;AARD,oDAQC","sourcesContent":["/**\n * BunyanFactoryOptions - tuning for the bunyan 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 bunyan's job (bunyan filters at its own default). You must name the service.\n */\nexport class BunyanFactoryOptions {\n    constructor(\n        /**\n         * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON\n         * payload). REQUIRED — every service names itself.\n         */\n        public readonly serviceName: string,\n    ) {}\n}\n"]}

package/src/BunyanGcpFactory.d.ts

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

package/src/BunyanGcpFactory.js

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

package/src/BunyanGcpFactory.js.map

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

package/src/BunyanLogger.d.ts

@@ -1,23 +1,26 @@
 import type Logger from 'bunyan';
-import type { ContextReader, Logger as WpLogger } from '@webpieces/core-util';
+import type { Logger as WpLogger } from '@webpieces/core-util';
 /**
  * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per
- * name, created as a bunyan child carrying `loggerName`). On every call it merges
- * the logged HeaderRegistry context keys (read through the ContextReader, secured
- * values masked) into the bunyan fields object, and normalizes an optional Error
- * into `err: { name, message, stack }` — matching the tested trytami AppLogger.
+ * name, created as a bunyan child carrying `loggerName`). On every call it reads
+ * the logged HeaderRegistry keys DIRECTLY from the active {@link RequestContext}
+ * (secured values masked) into the bunyan fields object, and normalizes an optional
+ * Error into `err: { name, message, stack }` — matching the tested trytami AppLogger.
  * The GCP stream then serializes those fields into the structured log payload.
+ *
+ * This context-reading is INLINED here (and duplicated in the winston logger) on
+ * purpose: it must run ONLY when a bunyan/winston backend is installed, never for
+ * the plain ConsoleLogger — so it does not belong on RequestContext.
  */
 export declare class BunyanLogger implements WpLogger {
     private readonly bunyan;
-    private readonly reader;
-    private readonly headerMethods;
-    private loggedKeys?;
-    constructor(bunyan: Logger, reader: ContextReader);
+    private reportedMissingContext;
+    constructor(bunyan: Logger);
     trace(message: string, err?: Error): void;
     debug(message: string, err?: Error): void;
     info(message: string, err?: Error): void;
     warn(message: string, err?: Error): void;
     error(message: string, err?: Error): void;
     private buildFields;
+    private reportMissingContextOnce;
 }

package/src/BunyanLogger.js

@@ -2,7 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BunyanLogger = void 0;
 const core_util_1 = require("@webpieces/core-util");
+const core_context_1 = require("@webpieces/core-context");
 const LoggedError_1 = require("./LoggedError");
+// A log line with no active RequestContext = a missing request-wrapping server
+// filter. We report that once (below), never on every line.
+const MISSING_CONTEXT_MESSAGE = 'Log emitted OUTSIDE RequestContext.run(...) — every request must be wrapped in ' +
+    'RequestContext.run() by a server filter. That filter appears to be missing: correlation ' +
+    'fields (requestId, tenant, ...) will be absent from logs until it is added. Reported once.';
 // Above this serialized size the error is truncated, so one giant stack can't
 // blow up a log line (ported from the tested trytami AppLogger).
 const MAX_ERR_SERIALIZED = 100_000;
@@ -21,20 +27,23 @@ function normalizeError(err) {
 }
 /**
  * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per
- * name, created as a bunyan child carrying `loggerName`). On every call it merges
- * the logged HeaderRegistry context keys (read through the ContextReader, secured
- * values masked) into the bunyan fields object, and normalizes an optional Error
- * into `err: { name, message, stack }` — matching the tested trytami AppLogger.
+ * name, created as a bunyan child carrying `loggerName`). On every call it reads
+ * the logged HeaderRegistry keys DIRECTLY from the active {@link RequestContext}
+ * (secured values masked) into the bunyan fields object, and normalizes an optional
+ * Error into `err: { name, message, stack }` — matching the tested trytami AppLogger.
  * The GCP stream then serializes those fields into the structured log payload.
+ *
+ * This context-reading is INLINED here (and duplicated in the winston logger) on
+ * purpose: it must run ONLY when a bunyan/winston backend is installed, never for
+ * the plain ConsoleLogger — so it does not belong on RequestContext.
  */
 class BunyanLogger {
     bunyan;
-    reader;
-    headerMethods = new core_util_1.HeaderMethods();
-    loggedKeys;
-    constructor(bunyan, reader) {
+    // One-shot latch (see MISSING_CONTEXT_MESSAGE) — flips true after the first
+    // out-of-context line so we report the missing filter exactly once, not per line.
+    reportedMissingContext = false;
+    constructor(bunyan) {
         this.bunyan = bunyan;
-        this.reader = reader;
     }
     trace(message, err) {
         this.bunyan.trace(this.buildFields(err), message);
@@ -51,22 +60,33 @@ class BunyanLogger {
     error(message, err) {
         this.bunyan.error(this.buildFields(err), message);
     }
-    // Registry keys are read LAZILY (first log) — a LoggerFactory is built before
-    // setupRuntime calls HeaderRegistry.configure.
     buildFields(err) {
-        if (!this.loggedKeys) {
-            this.loggedKeys = core_util_1.HeaderRegistry.get().getLoggedKeys();
-        }
         const fields = {};
-        const logMap = this.headerMethods.buildSecureMapForLogs(this.loggedKeys, this.reader);
-        logMap.forEach((value, name) => {
-            fields[name] = value;
-        });
+        if (!core_context_1.RequestContext.isActive()) {
+            this.reportMissingContextOnce();
+            return fields;
+        }
+        // getLoggedKeys() already returns only isLogged keys (precomputed at configure()).
+        for (const key of core_util_1.HeaderRegistry.get().getLoggedKeys()) {
+            const value = core_context_1.RequestContext.getHeader(key);
+            if (value) {
+                fields[key.name] = key.maskIfSecured(value);
+            }
+        }
         if (err) {
             fields['err'] = normalizeError(err);
         }
         return fields;
     }
+    // Report the missing request-wrapping filter once. Uses the RAW bunyan logger
+    // (not buildFields()), so there is no re-entrancy — just a single extra line.
+    reportMissingContextOnce() {
+        if (this.reportedMissingContext) {
+            return;
+        }
+        this.reportedMissingContext = true;
+        this.bunyan.error(MISSING_CONTEXT_MESSAGE);
+    }
 }
 exports.BunyanLogger = BunyanLogger;
 //# sourceMappingURL=BunyanLogger.js.map

package/src/BunyanLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"BunyanLogger.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanLogger.ts"],"names":[],"mappings":"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","sourcesContent":["import type Logger from 'bunyan';\nimport { HeaderMethods, HeaderRegistry } from '@webpieces/core-util';\nimport type { ContextKey, ContextReader, Logger as WpLogger } from '@webpieces/core-util';\nimport { LoggedError } from './LoggedError';\n\n// Above this serialized size the error is truncated, so one giant stack can't\n// blow up a log line (ported from the tested trytami AppLogger).\nconst MAX_ERR_SERIALIZED = 100_000;\n\nfunction truncateStack(stack: string | undefined, maxLines = 5): string {\n    if (!stack) {\n        return '';\n    }\n    return stack.split('\\n').slice(0, maxLines).join('\\n');\n}\n\nfunction normalizeError(err: Error): LoggedError {\n    const full = new LoggedError(err.name, err.message, err.stack);\n    if (JSON.stringify({ err: full }).length <= MAX_ERR_SERIALIZED) {\n        return full;\n    }\n    return new LoggedError(\n        `error too long: ${err.name}`,\n        err.message.substring(0, 100),\n        truncateStack(err.stack, 5),\n    );\n}\n\n/**\n * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per\n * name, created as a bunyan child carrying `loggerName`). On every call it merges\n * the logged HeaderRegistry context keys (read through the ContextReader, secured\n * values masked) into the bunyan fields object, and normalizes an optional Error\n * into `err: { name, message, stack }` — matching the tested trytami AppLogger.\n * The GCP stream then serializes those fields into the structured log payload.\n */\nexport class BunyanLogger implements WpLogger {\n    private readonly headerMethods = new HeaderMethods();\n    private loggedKeys?: ContextKey[];\n\n    constructor(\n        private readonly bunyan: Logger,\n        private readonly reader: ContextReader,\n    ) {}\n\n    trace(message: string, err?: Error): void {\n        this.bunyan.trace(this.buildFields(err), message);\n    }\n\n    debug(message: string, err?: Error): void {\n        this.bunyan.debug(this.buildFields(err), message);\n    }\n\n    info(message: string, err?: Error): void {\n        this.bunyan.info(this.buildFields(err), message);\n    }\n\n    warn(message: string, err?: Error): void {\n        this.bunyan.warn(this.buildFields(err), message);\n    }\n\n    error(message: string, err?: Error): void {\n        this.bunyan.error(this.buildFields(err), message);\n    }\n\n    // Registry keys are read LAZILY (first log) — a LoggerFactory is built before\n    // setupRuntime calls HeaderRegistry.configure.\n    private buildFields(err?: Error): Record<string, string | LoggedError> {\n        if (!this.loggedKeys) {\n            this.loggedKeys = HeaderRegistry.get().getLoggedKeys();\n        }\n        const fields: Record<string, string | LoggedError> = {};\n        const logMap = this.headerMethods.buildSecureMapForLogs(this.loggedKeys, this.reader);\n        logMap.forEach((value: string, name: string) => {\n            fields[name] = value;\n        });\n        if (err) {\n            fields['err'] = normalizeError(err);\n        }\n        return fields;\n    }\n}\n"]}
+{"version":3,"file":"BunyanLogger.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanLogger.ts"],"names":[],"mappings":"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","sourcesContent":["import type Logger from 'bunyan';\nimport type { Logger as WpLogger } from '@webpieces/core-util';\nimport { HeaderRegistry } from '@webpieces/core-util';\nimport { RequestContext } from '@webpieces/core-context';\nimport { LoggedError } from './LoggedError';\n\n// A log line with no active RequestContext = a missing request-wrapping server\n// filter. We report that once (below), never on every line.\nconst MISSING_CONTEXT_MESSAGE =\n    'Log emitted OUTSIDE RequestContext.run(...) — every request must be wrapped in ' +\n    'RequestContext.run() by a server filter. That filter appears to be missing: correlation ' +\n    'fields (requestId, tenant, ...) will be absent from logs until it is added. Reported once.';\n\n// Above this serialized size the error is truncated, so one giant stack can't\n// blow up a log line (ported from the tested trytami AppLogger).\nconst MAX_ERR_SERIALIZED = 100_000;\n\nfunction truncateStack(stack: string | undefined, maxLines = 5): string {\n    if (!stack) {\n        return '';\n    }\n    return stack.split('\\n').slice(0, maxLines).join('\\n');\n}\n\nfunction normalizeError(err: Error): LoggedError {\n    const full = new LoggedError(err.name, err.message, err.stack);\n    if (JSON.stringify({ err: full }).length <= MAX_ERR_SERIALIZED) {\n        return full;\n    }\n    return new LoggedError(\n        `error too long: ${err.name}`,\n        err.message.substring(0, 100),\n        truncateStack(err.stack, 5),\n    );\n}\n\n/**\n * BunyanLogger - a webpieces {@link WpLogger} backed by a bunyan logger (one per\n * name, created as a bunyan child carrying `loggerName`). On every call it reads\n * the logged HeaderRegistry keys DIRECTLY from the active {@link RequestContext}\n * (secured values masked) into the bunyan fields object, and normalizes an optional\n * Error into `err: { name, message, stack }` — matching the tested trytami AppLogger.\n * The GCP stream then serializes those fields into the structured log payload.\n *\n * This context-reading is INLINED here (and duplicated in the winston logger) on\n * purpose: it must run ONLY when a bunyan/winston backend is installed, never for\n * the plain ConsoleLogger — so it does not belong on RequestContext.\n */\nexport class BunyanLogger implements WpLogger {\n    // One-shot latch (see MISSING_CONTEXT_MESSAGE) — flips true after the first\n    // out-of-context line so we report the missing filter exactly once, not per line.\n    private reportedMissingContext = false;\n\n    constructor(private readonly bunyan: Logger) {}\n\n    trace(message: string, err?: Error): void {\n        this.bunyan.trace(this.buildFields(err), message);\n    }\n\n    debug(message: string, err?: Error): void {\n        this.bunyan.debug(this.buildFields(err), message);\n    }\n\n    info(message: string, err?: Error): void {\n        this.bunyan.info(this.buildFields(err), message);\n    }\n\n    warn(message: string, err?: Error): void {\n        this.bunyan.warn(this.buildFields(err), message);\n    }\n\n    error(message: string, err?: Error): void {\n        this.bunyan.error(this.buildFields(err), message);\n    }\n\n    private buildFields(err?: Error): Record<string, string | LoggedError> {\n        const fields: Record<string, string | LoggedError> = {};\n        if (!RequestContext.isActive()) {\n            this.reportMissingContextOnce();\n            return fields;\n        }\n\n        // getLoggedKeys() already returns only isLogged keys (precomputed at configure()).\n        for (const key of HeaderRegistry.get().getLoggedKeys()) {\n            const value = RequestContext.getHeader<string>(key);\n            if (value) {\n                fields[key.name] = key.maskIfSecured(value);\n            }\n        }\n        if (err) {\n            fields['err'] = normalizeError(err);\n        }\n        return fields;\n    }\n\n    // Report the missing request-wrapping filter once. Uses the RAW bunyan logger\n    // (not buildFields()), so there is no re-entrancy — just a single extra line.\n    private reportMissingContextOnce(): void {\n        if (this.reportedMissingContext) {\n            return;\n        }\n        this.reportedMissingContext = true;\n        this.bunyan.error(MISSING_CONTEXT_MESSAGE);\n    }\n}\n"]}

package/src/index.d.ts

@@ -5,19 +5,19 @@
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
- * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
- * import { RequestContextReader } from '@webpieces/core-context';
+ * import { BunyanGcpFactory, BunyanConsoleFactory, BunyanFactoryOptions } from '@webpieces/bunyan';
  *
- * const reader = new RequestContextReader();
+ * const opts = new BunyanFactoryOptions('my-service'); // serviceName is required
  * const loggerFactory = process.env.K_SERVICE
- *   ? new BunyanGcpFactory(reader)      // Cloud Logging via @google-cloud/logging-bunyan
- *   : new BunyanConsoleFactory(reader); // local → pretty console
+ *   ? new BunyanGcpFactory(opts)      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(opts); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
- * Both backends auto-enrich every line with the logged context keys from
- * HeaderRegistry. This package depends only on @webpieces/core-util (+ bunyan +
- * @google-cloud/logging-bunyan); the node RequestContextReader is passed in.
+ * 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. There is no level knob: bunyan filters at its
+ * own default.
  *
  * @packageDocumentation
  */

package/src/index.js

@@ -8,19 +8,19 @@ exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleS
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
- * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
- * import { RequestContextReader } from '@webpieces/core-context';
+ * import { BunyanGcpFactory, BunyanConsoleFactory, BunyanFactoryOptions } from '@webpieces/bunyan';
  *
- * const reader = new RequestContextReader();
+ * const opts = new BunyanFactoryOptions('my-service'); // serviceName is required
  * const loggerFactory = process.env.K_SERVICE
- *   ? new BunyanGcpFactory(reader)      // Cloud Logging via @google-cloud/logging-bunyan
- *   : new BunyanConsoleFactory(reader); // local → pretty console
+ *   ? new BunyanGcpFactory(opts)      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(opts); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
- * Both backends auto-enrich every line with the logged context keys from
- * HeaderRegistry. This package depends only on @webpieces/core-util (+ bunyan +
- * @google-cloud/logging-bunyan); the node RequestContextReader is passed in.
+ * 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. There is no level knob: bunyan filters at its
+ * own default.
  *
  * @packageDocumentation
  */

package/src/index.js.map

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

package/src/streams.d.ts

@@ -1,11 +1,16 @@
 import Logger from 'bunyan';
-import type { LogLevel } from '@webpieces/core-util';
 /**
  * The GCP stream: delegates ALL structured-JSON formatting (numeric level → GCP
  * severity, msg→message, trace/httpRequest fields, stripping name/hostname/pid)
  * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
  * Sends to the Cloud Logging API (needs ADC on the instance).
+ *
+ * We do NOT filter by level — that is bunyan's job. The stream is created at
+ * bunyan's default level ('info'); there is no webpieces level knob.
  */
-export declare function createGoogleCloudStream(level: LogLevel): Logger.Stream;
-/** The local dev stream: human-readable text to stdout via {@link writeConsole}. */
-export declare function createConsoleStream(level: LogLevel): Logger.Stream;
+export declare function createGoogleCloudStream(): Logger.Stream;
+/**
+ * The local dev stream: human-readable text to stdout via {@link writeConsole}.
+ * No level is set — bunyan filters at its own default ('info').
+ */
+export declare function createConsoleStream(): Logger.Stream;

package/src/streams.js

@@ -6,7 +6,6 @@ const tslib_1 = require("tslib");
 const stream_1 = require("stream");
 const bunyan_1 = tslib_1.__importDefault(require("bunyan"));
 const logging_bunyan_1 = require("@google-cloud/logging-bunyan");
-const levels_1 = require("./levels");
 // bunyan record fields that are structural / rendered specially, so they are not
 // shown as context tags in the local console line.
 const BUNYAN_STD_FIELDS = new Set([
@@ -68,13 +67,21 @@ function writeConsole(line) {
  * severity, msg→message, trace/httpRequest fields, stripping name/hostname/pid)
  * to @google-cloud/logging-bunyan, exactly as the tested trytami service does.
  * Sends to the Cloud Logging API (needs ADC on the instance).
+ *
+ * We do NOT filter by level — that is bunyan's job. The stream is created at
+ * bunyan's default level ('info'); there is no webpieces level knob.
  */
-function createGoogleCloudStream(level) {
+// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories
+function createGoogleCloudStream() {
     const loggingBunyan = new logging_bunyan_1.LoggingBunyan();
-    return loggingBunyan.stream((0, levels_1.logLevelToBunyanLevel)(level));
+    return loggingBunyan.stream('info');
 }
-/** The local dev stream: human-readable text to stdout via {@link writeConsole}. */
-function createConsoleStream(level) {
+/**
+ * The local dev stream: human-readable text to stdout via {@link writeConsole}.
+ * No level is set — bunyan filters at its own default ('info').
+ */
+// webpieces-disable no-function-outside-class -- bunyan Stream factory; whole file is bunyan stream/render factories
+function createConsoleStream() {
     const writable = new stream_1.Writable({
         write(chunk, _encoding, callback) {
             writeConsole(chunk.toString());
@@ -83,7 +90,6 @@ function createConsoleStream(level) {
     });
     return {
         name: 'console',
-        level: (0, levels_1.logLevelToBunyanLevel)(level),
         stream: writable,
     };
 }

package/src/streams.js.map

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