@webpieces/bunyan 0.4.393 → 0.4.395

package/README.md

@@ -17,28 +17,35 @@ Two factories, both auto-enriching every line with the logged context keys regis
 
 ```ts
 import { LogManager, HeaderRegistry } from '@webpieces/core-util';
+import { ServiceInfo } from '@webpieces/core-util';
 import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
-import { RequestContextReader } from '@webpieces/core-context';
 
-const reader = new RequestContextReader();
+// FIRST: name this service. Both factories read it in their CONSTRUCTOR, so this must come
+// before you build one — a forgotten call throws at startup rather than shipping unnamed logs.
+ServiceInfo.setName('my-service');
+
 const loggerFactory = process.env.K_SERVICE
-    ? new BunyanGcpFactory(reader)
-    : new BunyanConsoleFactory(reader);
+    ? new BunyanGcpFactory()
+    : new BunyanConsoleFactory();
 
 // Typically you pass loggerFactory to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...)),
 // which calls HeaderRegistry.configure(...) then LogManager.setFactory(loggerFactory) for you.
 ```
 
-The `ContextReader` is a **constructor argument** (the node `RequestContextReader` lives in
-`@webpieces/core-context`) so this package depends only on `@webpieces/core-util` — not on
-any node context package.
+Both factories read the magic context **directly** from `RequestContext` on each line, so
+nothing is threaded in: there is no `ContextReader` constructor argument.
 
 `BunyanGcpFactory` sends to the Cloud Logging API and needs GCP Application Default
 Credentials on the instance (automatic on Cloud Run), exactly as the source service runs.
 
 ## Options
 
-`new BunyanGcpFactory(reader, new BunyanFactoryOptions(level, serviceName))`:
+There are none — both factories take no arguments.
 
-- `level` — minimum webpieces level to emit (default `'info'`).
-- `serviceName` — the bunyan logger `name` (default `'webpieces'`), surfaced in the payload.
+- **Service name** — from `ServiceInfo.setName(...)` (see above), NOT a factory option. It
+  becomes bunyan's mandatory root-logger `name` and surfaces as `name` in the payload. It
+  lives in `@webpieces/core-util` because it is a fact about the SERVICE, not about bunyan:
+  the winston backend reads the same value, and so does `requestIdSource` (which records
+  which service minted a request-id).
+- **Level** — there is deliberately no knob. webpieces does not filter by level; bunyan
+  filters at its own default.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpieces/bunyan",
-  "version": "0.4.393",
+  "version": "0.4.395",
   "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.393",
-    "@webpieces/core-context": "0.4.393",
+    "@webpieces/core-util": "0.4.395",
+    "@webpieces/core-context": "0.4.395",
     "bunyan": "1.8.15",
     "@google-cloud/logging-bunyan": "5.1.0",
     "@types/bunyan": "1.8.11"

package/src/BunyanConsoleFactory.d.ts

@@ -1,11 +1,13 @@
 import { BunyanFactoryBase } from './BunyanFactoryBase';
-import { BunyanFactoryOptions } from './BunyanFactoryOptions';
 /**
  * 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.
+ *
+ * The service name comes from {@link ServiceInfo}, which startup must have named
+ * BEFORE constructing this.
  */
 export declare class BunyanConsoleFactory extends BunyanFactoryBase {
-    constructor(opts: BunyanFactoryOptions);
+    constructor();
 }

package/src/BunyanConsoleFactory.js

@@ -8,10 +8,13 @@ const streams_1 = require("./streams");
  * 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.
+ *
+ * The service name comes from {@link ServiceInfo}, which startup must have named
+ * BEFORE constructing this.
  */
 class BunyanConsoleFactory extends BunyanFactoryBase_1.BunyanFactoryBase {
-    constructor(opts) {
-        super(opts.serviceName, [(0, streams_1.createConsoleStream)()]);
+    constructor() {
+        super([(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":";;;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"]}
+{"version":3,"file":"BunyanConsoleFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanConsoleFactory.ts"],"names":[],"mappings":";;;AAAA,2DAAwD;AACxD,uCAAgD;AAEhD;;;;;;;;GAQG;AACH,MAAa,oBAAqB,SAAQ,qCAAiB;IACvD;QACI,KAAK,CAAC,CAAC,IAAA,6BAAmB,GAAE,CAAC,CAAC,CAAC;IACnC,CAAC;CACJ;AAJD,oDAIC","sourcesContent":["import { BunyanFactoryBase } from './BunyanFactoryBase';\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 * The service name comes from {@link ServiceInfo}, which startup must have named\n * BEFORE constructing this.\n */\nexport class BunyanConsoleFactory extends BunyanFactoryBase {\n    constructor() {\n        super([createConsoleStream()]);\n    }\n}\n"]}

package/src/BunyanFactoryBase.d.ts

@@ -7,10 +7,20 @@ import type { Logger as WpLogger, LoggerFactory } from '@webpieces/core-util';
  * 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.setName(...)` throws OUR actionable error while
+ * the process boots, rather than bunyan's opaque TypeError.
+ *
+ * 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
+ * set logger name`).
  */
 export declare abstract class BunyanFactoryBase implements LoggerFactory {
     private readonly base;
     private readonly loggers;
-    protected constructor(name: string, streams: Logger.Stream[]);
+    protected constructor(streams: Logger.Stream[]);
     getLogger(name: string): WpLogger;
 }

package/src/BunyanFactoryBase.js

@@ -3,6 +3,7 @@ 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");
 /**
  * BunyanFactoryBase - shared plumbing for the bunyan {@link LoggerFactory}
@@ -11,12 +12,22 @@ const BunyanLogger_1 = require("./BunyanLogger");
  * 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.setName(...)` throws OUR actionable error while
+ * the process boots, rather than bunyan's opaque TypeError.
+ *
+ * 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
+ * set logger name`).
  */
 class BunyanFactoryBase {
     base;
     loggers = new Map();
-    constructor(name, streams) {
-        this.base = bunyan_1.default.createLogger({ name, streams });
+    constructor(streams) {
+        this.base = bunyan_1.default.createLogger({ name: core_util_1.ServiceInfo.getName(), streams });
     }
     getLogger(name) {
         let logger = this.loggers.get(name);

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;;;;;;;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"]}
+{"version":3,"file":"BunyanFactoryBase.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanFactoryBase.ts"],"names":[],"mappings":";;;;AAAA,4DAA4B;AAE5B,oDAAmD;AACnD,iDAA8C;AAE9C;;;;;;;;;;;;;;;;;GAiBG;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,EAAE,IAAI,EAAE,uBAAW,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC9E,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 { 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.setName(...)` throws OUR actionable error while\n * the process boots, rather than bunyan's opaque TypeError.\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({ name: ServiceInfo.getName(), 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/BunyanGcpFactory.d.ts

@@ -1,5 +1,4 @@
 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,
@@ -7,7 +6,10 @@ import { BunyanFactoryOptions } from './BunyanFactoryOptions';
  * 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.
+ *
+ * The service name comes from {@link ServiceInfo}, which startup must have named
+ * BEFORE constructing this.
  */
 export declare class BunyanGcpFactory extends BunyanFactoryBase {
-    constructor(opts: BunyanFactoryOptions);
+    constructor();
 }

package/src/BunyanGcpFactory.js

@@ -10,10 +10,13 @@ const streams_1 = require("./streams");
  * 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.
+ *
+ * The service name comes from {@link ServiceInfo}, which startup must have named
+ * BEFORE constructing this.
  */
 class BunyanGcpFactory extends BunyanFactoryBase_1.BunyanFactoryBase {
-    constructor(opts) {
-        super(opts.serviceName, [(0, streams_1.createGoogleCloudStream)()]);
+    constructor() {
+        super([(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":";;;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"]}
+{"version":3,"file":"BunyanGcpFactory.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/BunyanGcpFactory.ts"],"names":[],"mappings":";;;AAAA,2DAAwD;AACxD,uCAAoD;AAEpD;;;;;;;;;;GAUG;AACH,MAAa,gBAAiB,SAAQ,qCAAiB;IACnD;QACI,KAAK,CAAC,CAAC,IAAA,iCAAuB,GAAE,CAAC,CAAC,CAAC;IACvC,CAAC;CACJ;AAJD,4CAIC","sourcesContent":["import { BunyanFactoryBase } from './BunyanFactoryBase';\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 *\n * The service name comes from {@link ServiceInfo}, which startup must have named\n * BEFORE constructing this.\n */\nexport class BunyanGcpFactory extends BunyanFactoryBase {\n    constructor() {\n        super([createGoogleCloudStream()]);\n    }\n}\n"]}

package/src/index.d.ts

@@ -5,15 +5,22 @@
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
- * import { BunyanGcpFactory, BunyanConsoleFactory, BunyanFactoryOptions } from '@webpieces/bunyan';
+ * import { ServiceInfo } from '@webpieces/core-util';
+ * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
  *
- * const opts = new BunyanFactoryOptions('my-service'); // serviceName is required
+ * ServiceInfo.setName('my-service');  // FIRST — the factories read it in their constructor
  * const loggerFactory = process.env.K_SERVICE
- *   ? new BunyanGcpFactory(opts)      // Cloud Logging via @google-cloud/logging-bunyan
- *   : new BunyanConsoleFactory(opts); // local → pretty console
+ *   ? new BunyanGcpFactory()      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
+ * BREAKING (was `new BunyanFactoryOptions('my-service')` passed to each factory): the service name
+ * moved to `ServiceInfo.setName(...)` in @webpieces/core-util, because it is a fact about the
+ * SERVICE, not about bunyan — winston needs the same name, and so does `requestIdSource`. Migration:
+ * delete the `BunyanFactoryOptions` import, call `ServiceInfo.setName(<the same string>)` before
+ * building the factory, and drop the ctor argument. A forgotten call throws at startup.
+ *
  * 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
@@ -23,7 +30,6 @@
  */
 export { BunyanGcpFactory } from './BunyanGcpFactory';
 export { BunyanConsoleFactory } from './BunyanConsoleFactory';
-export { BunyanFactoryOptions } from './BunyanFactoryOptions';
 export { BunyanLogger } from './BunyanLogger';
 export { createGoogleCloudStream, createConsoleStream } from './streams';
 export { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';

package/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleStream = exports.createGoogleCloudStream = exports.BunyanLogger = exports.BunyanFactoryOptions = exports.BunyanConsoleFactory = exports.BunyanGcpFactory = void 0;
+exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleStream = exports.createGoogleCloudStream = exports.BunyanLogger = exports.BunyanConsoleFactory = exports.BunyanGcpFactory = void 0;
 /**
  * @webpieces/bunyan
  *
@@ -8,15 +8,22 @@ exports.logLevelToBunyanLevel = exports.LEVEL_TO_BUNYAN = exports.createConsoleS
  * startup via `LogManager.setFactory(...)`:
  *
  * ```ts
- * import { BunyanGcpFactory, BunyanConsoleFactory, BunyanFactoryOptions } from '@webpieces/bunyan';
+ * import { ServiceInfo } from '@webpieces/core-util';
+ * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';
  *
- * const opts = new BunyanFactoryOptions('my-service'); // serviceName is required
+ * ServiceInfo.setName('my-service');  // FIRST — the factories read it in their constructor
  * const loggerFactory = process.env.K_SERVICE
- *   ? new BunyanGcpFactory(opts)      // Cloud Logging via @google-cloud/logging-bunyan
- *   : new BunyanConsoleFactory(opts); // local → pretty console
+ *   ? new BunyanGcpFactory()      // Cloud Logging via @google-cloud/logging-bunyan
+ *   : new BunyanConsoleFactory(); // local → pretty console
  * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))
  * ```
  *
+ * BREAKING (was `new BunyanFactoryOptions('my-service')` passed to each factory): the service name
+ * moved to `ServiceInfo.setName(...)` in @webpieces/core-util, because it is a fact about the
+ * SERVICE, not about bunyan — winston needs the same name, and so does `requestIdSource`. Migration:
+ * delete the `BunyanFactoryOptions` import, call `ServiceInfo.setName(<the same string>)` before
+ * building the factory, and drop the ctor argument. A forgotten call throws at startup.
+ *
  * 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
@@ -28,8 +35,6 @@ var BunyanGcpFactory_1 = require("./BunyanGcpFactory");
 Object.defineProperty(exports, "BunyanGcpFactory", { enumerable: true, get: function () { return BunyanGcpFactory_1.BunyanGcpFactory; } });
 var BunyanConsoleFactory_1 = require("./BunyanConsoleFactory");
 Object.defineProperty(exports, "BunyanConsoleFactory", { enumerable: true, get: function () { return BunyanConsoleFactory_1.BunyanConsoleFactory; } });
-var BunyanFactoryOptions_1 = require("./BunyanFactoryOptions");
-Object.defineProperty(exports, "BunyanFactoryOptions", { enumerable: true, get: function () { return BunyanFactoryOptions_1.BunyanFactoryOptions; } });
 var BunyanLogger_1 = require("./BunyanLogger");
 Object.defineProperty(exports, "BunyanLogger", { enumerable: true, get: function () { return BunyanLogger_1.BunyanLogger; } });
 var streams_1 = require("./streams");

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, 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"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/logging/bunyan/src/index.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,+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 { ServiceInfo } from '@webpieces/core-util';\n * import { BunyanGcpFactory, BunyanConsoleFactory } from '@webpieces/bunyan';\n *\n * ServiceInfo.setName('my-service');  // FIRST — the factories read it in their constructor\n * const loggerFactory = process.env.K_SERVICE\n *   ? new BunyanGcpFactory()      // Cloud Logging via @google-cloud/logging-bunyan\n *   : new BunyanConsoleFactory(); // local → pretty console\n * // hand to setupRuntime(new RuntimeSetupOptions(loggerFactory, ...))\n * ```\n *\n * BREAKING (was `new BunyanFactoryOptions('my-service')` passed to each factory): the service name\n * moved to `ServiceInfo.setName(...)` in @webpieces/core-util, because it is a fact about the\n * SERVICE, not about bunyan — winston needs the same name, and so does `requestIdSource`. Migration:\n * delete the `BunyanFactoryOptions` import, call `ServiceInfo.setName(<the same string>)` before\n * building the factory, and drop the ctor argument. A forgotten call throws at startup.\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 { BunyanLogger } from './BunyanLogger';\nexport { createGoogleCloudStream, createConsoleStream } from './streams';\nexport { LEVEL_TO_BUNYAN, logLevelToBunyanLevel } from './levels';\n"]}

package/src/BunyanFactoryOptions.d.ts

@@ -1,21 +0,0 @@
-/**
- * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
- *
- * 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 {
-    /**
-     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). REQUIRED — every service names itself.
-     */
-    readonly serviceName: string;
-    constructor(
-    /**
-     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). REQUIRED — every service names itself.
-     */
-    serviceName: string);
-}

package/src/BunyanFactoryOptions.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BunyanFactoryOptions = void 0;
-/**
- * BunyanFactoryOptions - tuning for the bunyan LoggerFactory backends.
- *
- * 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 {
-    serviceName;
-    constructor(
-    /**
-     * The bunyan logger `name` (surfaces as `name` in Cloud Logging's JSON
-     * payload). REQUIRED — every service names itself.
-     */
-    serviceName) {
-        this.serviceName = serviceName;
-    }
-}
-exports.BunyanFactoryOptions = BunyanFactoryOptions;
-//# sourceMappingURL=BunyanFactoryOptions.js.map

package/src/BunyanFactoryOptions.js.map

@@ -1 +0,0 @@
-{"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"]}