@webpieces/bunyan 0.4.399 → 0.4.401

package/package.json

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

package/src/BunyanFactoryBase.d.ts

@@ -5,21 +5,8 @@ import type { Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';
  * 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`). 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).
- *
- * The root logger's `name` is bunyan's ONE mandatory option (its constructor throws
- * `options.name (string) is required`), and it comes from {@link ServiceInfo} — so an
- * app names itself ONCE, in one place, for logging AND for requestIdSource. Reading it
- * here means a forgotten `ServiceInfo.setInfo(...)` throws OUR actionable error while
- * the process boots, rather than bunyan's opaque TypeError.
- *
- * `version` rides alongside as a bunyan BASE FIELD (bunyan passes unknown top-level options straight
- * onto every record — it strips only stream/streams/level/serializers/src, and its own format
- * version is `v`, so there is no collision). This backend previously could not stamp a version at
- * all: it lived on winston's factory options, which made "do my logs say which build emitted them?"
- * depend on the logging library rather than on the service. Both backends now read the ONE
- * {@link ServiceInfo}.
+ * RequestContext (including the build `version`), so nothing is threaded through here. Subclasses
+ * differ only in the stream they pass up (GCP vs local console).
  *
  * Per-logger names ride as `loggerName` on each child rather than `name`, because
  * bunyan REFUSES to let a child override `name` (`invalid options.name: child cannot

package/src/BunyanFactoryBase.js

@@ -3,28 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BunyanFactoryBase = void 0;
 const tslib_1 = require("tslib");
 const bunyan_1 = tslib_1.__importDefault(require("bunyan"));
-const core_util_1 = require("@webpieces/core-util");
 const BunyanLogger_1 = require("./BunyanLogger");
+/**
+ * bunyan's ONE mandatory option is a non-empty root-logger `name` (its constructor throws
+ * `options.name (string) is required`). It is NOT the service name: the service identity is a
+ * process-global {@link ServiceInfo} fact that may not be set yet when this factory is constructed
+ * (logging must work before `setInfo`), and a bunyan root `name` is baked at `createLogger` and can
+ * never change afterwards (children throw `child cannot set logger name`). So we feed bunyan a fixed
+ * placeholder here and stamp the real build `version` per-record via {@link RequestContext.buildStructuredLogFields}
+ * (the ONE map both backends read), where it appears the moment `setInfo` runs. Locally the field is
+ * suppressed anyway (see BUNYAN_STD_FIELDS in ./streams).
+ */
+const BUNYAN_ROOT_NAME = 'app';
 /**
  * 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`). 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).
- *
- * The root logger's `name` is bunyan's ONE mandatory option (its constructor throws
- * `options.name (string) is required`), and it comes from {@link ServiceInfo} — so an
- * app names itself ONCE, in one place, for logging AND for requestIdSource. Reading it
- * here means a forgotten `ServiceInfo.setInfo(...)` throws OUR actionable error while
- * the process boots, rather than bunyan's opaque TypeError.
- *
- * `version` rides alongside as a bunyan BASE FIELD (bunyan passes unknown top-level options straight
- * onto every record — it strips only stream/streams/level/serializers/src, and its own format
- * version is `v`, so there is no collision). This backend previously could not stamp a version at
- * all: it lived on winston's factory options, which made "do my logs say which build emitted them?"
- * depend on the logging library rather than on the service. Both backends now read the ONE
- * {@link ServiceInfo}.
+ * RequestContext (including the build `version`), so nothing is threaded through here. Subclasses
+ * differ only in the stream they pass up (GCP vs local console).
  *
  * Per-logger names ride as `loggerName` on each child rather than `name`, because
  * bunyan REFUSES to let a child override `name` (`invalid options.name: child cannot
@@ -35,8 +32,7 @@ class BunyanFactoryBase {
     loggers = new Map();
     constructor(streams) {
         this.base = bunyan_1.default.createLogger({
-            name: core_util_1.ServiceInfo.getName(),
-            version: core_util_1.ServiceInfo.getVersion(),
+            name: BUNYAN_ROOT_NAME,
             streams,
         });
     }

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,oDAAmD;AACnD,iDAA8C;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAsB,iBAAiB;IAClB,IAAI,CAAS;IACb,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEvD,YAAsB,OAAwB;QAC1C,IAAI,CAAC,IAAI,GAAG,gBAAM,CAAC,YAAY,CAAC;YAC5B,IAAI,EAAE,uBAAW,CAAC,OAAO,EAAE;YAC3B,OAAO,EAAE,uBAAW,CAAC,UAAU,EAAE;YACjC,OAAO;SACV,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,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;AApBD,8CAoBC","sourcesContent":["import Logger from 'bunyan';\nimport type { Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';\nimport { ServiceInfo } 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 *\n * The root logger's `name` is bunyan's ONE mandatory option (its constructor throws\n * `options.name (string) is required`), and it comes from {@link ServiceInfo} — so an\n * app names itself ONCE, in one place, for logging AND for requestIdSource. Reading it\n * here means a forgotten `ServiceInfo.setInfo(...)` throws OUR actionable error while\n * the process boots, rather than bunyan's opaque TypeError.\n *\n * `version` rides alongside as a bunyan BASE FIELD (bunyan passes unknown top-level options straight\n * onto every record — it strips only stream/streams/level/serializers/src, and its own format\n * version is `v`, so there is no collision). This backend previously could not stamp a version at\n * all: it lived on winston's factory options, which made \"do my logs say which build emitted them?\"\n * depend on the logging library rather than on the service. Both backends now read the ONE\n * {@link ServiceInfo}.\n *\n * Per-logger names ride as `loggerName` on each child rather than `name`, because\n * bunyan REFUSES to let a child override `name` (`invalid options.name: child cannot\n * set logger name`).\n */\nexport abstract class BunyanFactoryBase implements LoggerFactory {\n    private readonly base: Logger;\n    private readonly loggers = new Map<string, WpLogger>();\n\n    protected constructor(streams: Logger.Stream[]) {\n        this.base = Logger.createLogger({\n            name: ServiceInfo.getName(),\n            version: ServiceInfo.getVersion(),\n            streams,\n        });\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"]}
+{"version":3,"file":"BunyanFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryBase.ts"],"names":[],"mappings":";;;;AAAA,4DAA4B;AAE5B,iDAA8C;AAE9C;;;;;;;;;GASG;AACH,MAAM,gBAAgB,GAAG,KAAK,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,MAAsB,iBAAiB;IAClB,IAAI,CAAS;IACb,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEvD,YAAsB,OAAwB;QAC1C,IAAI,CAAC,IAAI,GAAG,gBAAM,CAAC,YAAY,CAAC;YAC5B,IAAI,EAAE,gBAAgB;YACtB,OAAO;SACV,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,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;AAnBD,8CAmBC","sourcesContent":["import Logger from 'bunyan';\nimport type { Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';\nimport { BunyanLogger } from './BunyanLogger';\n\n/**\n * bunyan's ONE mandatory option is a non-empty root-logger `name` (its constructor throws\n * `options.name (string) is required`). It is NOT the service name: the service identity is a\n * process-global {@link ServiceInfo} fact that may not be set yet when this factory is constructed\n * (logging must work before `setInfo`), and a bunyan root `name` is baked at `createLogger` and can\n * never change afterwards (children throw `child cannot set logger name`). So we feed bunyan a fixed\n * placeholder here and stamp the real build `version` per-record via {@link RequestContext.buildStructuredLogFields}\n * (the ONE map both backends read), where it appears the moment `setInfo` runs. Locally the field is\n * suppressed anyway (see BUNYAN_STD_FIELDS in ./streams).\n */\nconst BUNYAN_ROOT_NAME = 'app';\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 (including the build `version`), so nothing is threaded through here. Subclasses\n * differ only in the stream they pass up (GCP vs local console).\n *\n * Per-logger names ride as `loggerName` on each child rather than `name`, because\n * bunyan REFUSES to let a child override `name` (`invalid options.name: child cannot\n * set logger name`).\n */\nexport abstract class BunyanFactoryBase implements LoggerFactory {\n    private readonly base: Logger;\n    private readonly loggers = new Map<string, WpLogger>();\n\n    protected constructor(streams: Logger.Stream[]) {\n        this.base = Logger.createLogger({\n            name: BUNYAN_ROOT_NAME,\n            streams,\n        });\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/BunyanLogger.d.ts

@@ -14,7 +14,6 @@ import type { Logger as WpLogger } from '@webpieces/core-util';
  */
 export declare class BunyanLogger implements WpLogger {
     private readonly bunyan;
-    private reportedMissingContext;
     constructor(bunyan: Logger);
     trace(message: string, err?: Error): void;
     debug(message: string, err?: Error): void;
@@ -22,5 +21,4 @@ export declare class BunyanLogger implements WpLogger {
     warn(message: string, err?: Error): void;
     error(message: string, err?: Error): void;
     private buildFields;
-    private reportMissingContextOnce;
 }

package/src/BunyanLogger.js

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