@btravstack/observability 0.30.1 → 0.31.0

package/README.md

@@ -131,9 +131,14 @@ import { pinoSink } from "@btravstack/observability/pino";
 observability({ sink: pinoSink(pino()) });
 ```
 
+The child logger uses a `trace` floor and leaves the supplied logger unchanged.
 The level filter stays this package's — `LOG_LEVEL`, validated once — so there
 is one filter in the process rather than two that can disagree.
 
+Both JSON and Pino sinks retain safe error diagnostics and omit arbitrary
+error payloads. Pino's error serializer is installed on a child logger at
+`trace`, leaving the supplied logger's configuration intact.
+
 ## Traces and metrics
 
 The other half of the package's name, behind an optional-peer subpath the way

package/dist/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_json_sink = require("./json-sink-CQB0-tTI.cjs");
 let _btravstack_config = require("@btravstack/config");
 let _btravstack_core = require("@btravstack/core");
 let _btravstack_di = require("@btravstack/di");
@@ -22,88 +23,6 @@ const logLevel = (options = {}) => {
 	};
 };
 //#endregion
-//#region src/json-sink.ts
-const DIAGNOSTIC_FIELDS = [
-	"_tag",
-	"sqlState",
-	"constraint",
-	"table",
-	"database",
-	"role",
-	"bypass",
-	"port"
-];
-/**
-* An `Error`'s `message` and `stack` are **non-enumerable**, so
-* `JSON.stringify` renders a thrown one as `{}` — the line that exists to carry
-* a failure would carry nothing. Walks `cause` chains so a wrapped failure keeps
-* its origin.
-*/
-const renderCause = (cause, depth = 0, parents = /* @__PURE__ */ new Set()) => {
-	if (!(cause instanceof Error)) return depth > 0 && cause !== null && (typeof cause === "object" || typeof cause === "function" || typeof cause === "bigint") ? "[non-error]" : cause;
-	if (parents.has(cause)) return "[circular]";
-	const ancestors = new Set(parents).add(cause);
-	const errors = cause instanceof AggregateError ? Object.getOwnPropertyDescriptor(cause, "errors")?.value : void 0;
-	return {
-		name: cause.name,
-		message: cause.message,
-		stack: cause.stack,
-		...Object.fromEntries(DIAGNOSTIC_FIELDS.flatMap((key) => {
-			const value = Object.getOwnPropertyDescriptor(cause, key)?.value;
-			return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? [[key, value]] : [];
-		})),
-		...cause.cause === void 0 || depth >= 4 ? {} : { cause: renderCause(cause.cause, depth + 1, ancestors) },
-		...Array.isArray(errors) && depth < 4 ? {
-			errors: Array.from({ length: Math.min(errors.length, 16) }, (_, index) => {
-				const member = Object.getOwnPropertyDescriptor(errors, String(index))?.value;
-				return renderCause(member, depth + 1, ancestors);
-			}),
-			...errors.length > 16 ? { omittedErrors: errors.length - 16 } : {}
-		} : {}
-	};
-};
-/**
-* One JSON object per line on `stream`.
-*
-* The caller's attributes are spread FIRST and the line's own fields after them,
-* and that order is the precedence: an `attributes: { level: "info" }` cannot
-* rewrite an `error` line's severity, nor its `traceId`.
-*
-* The unit's ids are spread at the top level rather than nested under `unit`,
-* because `traceId` is the field an operator searches.
-*/
-const jsonSink = (stream = process.stdout) => (line) => {
-	const { level, message, attributes, cause, time, unit } = line;
-	const rendered = {
-		...attributes,
-		time: new Date(time).toISOString(),
-		level,
-		message,
-		...unit === void 0 ? {} : unit,
-		...cause === void 0 ? {} : { cause: renderCause(cause) }
-	};
-	stream.write(`${safeStringify(rendered)}\n`);
-};
-const serialises = (key, value) => {
-	try {
-		JSON.stringify({ [key]: value });
-		return true;
-	} catch {
-		return false;
-	}
-};
-const safeStringify = (rendered) => {
-	try {
-		return JSON.stringify(rendered);
-	} catch {
-		const kept = Object.entries(rendered).filter(([key, value]) => serialises(key, value));
-		return JSON.stringify({
-			...Object.fromEntries(kept),
-			unserialisable: Object.keys(rendered).filter((key) => !serialises(key, rendered[key]))
-		});
-	}
-};
-//#endregion
 //#region src/logger.ts
 const severity = (level) => _btravstack_core.LEVELS.indexOf(level);
 /**
@@ -182,7 +101,7 @@ const observability = (options = {}) => (0, _btravstack_di.Module)("Observabilit
 		_btravstack_config.Config.provider(LoggerConfig)(_btravstack_config.Config.object({ level: _btravstack_config.Config.pinned(options.level, logLevel()) })),
 		(0, _btravstack_di.Provider)(_btravstack_core.Logger)({
 			inject: { config: LoggerConfig },
-			sync: ({ config }) => createLogger(options.sink ?? jsonSink(), config.level)
+			sync: ({ config }) => createLogger(options.sink ?? require_json_sink.jsonSink(), config.level)
 		}),
 		_btravstack_di.Provider.member(_btravstack_core.Observers)({
 			inject: { logger: _btravstack_core.Logger },
@@ -263,7 +182,7 @@ const kernelEvents = (logger) => (event) => {
 //#endregion
 exports.LoggerConfig = LoggerConfig;
 exports.createLogger = createLogger;
-exports.jsonSink = jsonSink;
+exports.jsonSink = require_json_sink.jsonSink;
 exports.kernelEvents = kernelEvents;
 exports.logLevel = logLevel;
 exports.observability = observability;

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { t as jsonSink } from "./json-sink-7PQoEfMj.mjs";
 import { Config, ConfigFieldInvalid, Env } from "@btravstack/config";
 import { LEVELS, Logger, Observers, currentUnit } from "@btravstack/core";
 import { Module, Port, Provider } from "@btravstack/di";
@@ -21,88 +22,6 @@ const logLevel = (options = {}) => {
 	};
 };
 //#endregion
-//#region src/json-sink.ts
-const DIAGNOSTIC_FIELDS = [
-	"_tag",
-	"sqlState",
-	"constraint",
-	"table",
-	"database",
-	"role",
-	"bypass",
-	"port"
-];
-/**
-* An `Error`'s `message` and `stack` are **non-enumerable**, so
-* `JSON.stringify` renders a thrown one as `{}` — the line that exists to carry
-* a failure would carry nothing. Walks `cause` chains so a wrapped failure keeps
-* its origin.
-*/
-const renderCause = (cause, depth = 0, parents = /* @__PURE__ */ new Set()) => {
-	if (!(cause instanceof Error)) return depth > 0 && cause !== null && (typeof cause === "object" || typeof cause === "function" || typeof cause === "bigint") ? "[non-error]" : cause;
-	if (parents.has(cause)) return "[circular]";
-	const ancestors = new Set(parents).add(cause);
-	const errors = cause instanceof AggregateError ? Object.getOwnPropertyDescriptor(cause, "errors")?.value : void 0;
-	return {
-		name: cause.name,
-		message: cause.message,
-		stack: cause.stack,
-		...Object.fromEntries(DIAGNOSTIC_FIELDS.flatMap((key) => {
-			const value = Object.getOwnPropertyDescriptor(cause, key)?.value;
-			return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? [[key, value]] : [];
-		})),
-		...cause.cause === void 0 || depth >= 4 ? {} : { cause: renderCause(cause.cause, depth + 1, ancestors) },
-		...Array.isArray(errors) && depth < 4 ? {
-			errors: Array.from({ length: Math.min(errors.length, 16) }, (_, index) => {
-				const member = Object.getOwnPropertyDescriptor(errors, String(index))?.value;
-				return renderCause(member, depth + 1, ancestors);
-			}),
-			...errors.length > 16 ? { omittedErrors: errors.length - 16 } : {}
-		} : {}
-	};
-};
-/**
-* One JSON object per line on `stream`.
-*
-* The caller's attributes are spread FIRST and the line's own fields after them,
-* and that order is the precedence: an `attributes: { level: "info" }` cannot
-* rewrite an `error` line's severity, nor its `traceId`.
-*
-* The unit's ids are spread at the top level rather than nested under `unit`,
-* because `traceId` is the field an operator searches.
-*/
-const jsonSink = (stream = process.stdout) => (line) => {
-	const { level, message, attributes, cause, time, unit } = line;
-	const rendered = {
-		...attributes,
-		time: new Date(time).toISOString(),
-		level,
-		message,
-		...unit === void 0 ? {} : unit,
-		...cause === void 0 ? {} : { cause: renderCause(cause) }
-	};
-	stream.write(`${safeStringify(rendered)}\n`);
-};
-const serialises = (key, value) => {
-	try {
-		JSON.stringify({ [key]: value });
-		return true;
-	} catch {
-		return false;
-	}
-};
-const safeStringify = (rendered) => {
-	try {
-		return JSON.stringify(rendered);
-	} catch {
-		const kept = Object.entries(rendered).filter(([key, value]) => serialises(key, value));
-		return JSON.stringify({
-			...Object.fromEntries(kept),
-			unserialisable: Object.keys(rendered).filter((key) => !serialises(key, rendered[key]))
-		});
-	}
-};
-//#endregion
 //#region src/logger.ts
 const severity = (level) => LEVELS.indexOf(level);
 /**

package/dist/json-sink-7PQoEfMj.mjs

@@ -0,0 +1,83 @@
+//#region src/json-sink.ts
+const DIAGNOSTIC_FIELDS = [
+	"_tag",
+	"sqlState",
+	"constraint",
+	"table",
+	"database",
+	"role",
+	"bypass",
+	"port"
+];
+/**
+* An `Error`'s `message` and `stack` are **non-enumerable**, so
+* `JSON.stringify` renders a thrown one as `{}` — the line that exists to carry
+* a failure would carry nothing. Walks `cause` chains so a wrapped failure keeps
+* its origin.
+*/
+const renderCause = (cause, depth = 0, parents = /* @__PURE__ */ new Set()) => {
+	if (!(cause instanceof Error)) return depth > 0 && cause !== null && (typeof cause === "object" || typeof cause === "function" || typeof cause === "bigint") ? "[non-error]" : cause;
+	if (parents.has(cause)) return "[circular]";
+	const ancestors = new Set(parents).add(cause);
+	const errors = cause instanceof AggregateError ? Object.getOwnPropertyDescriptor(cause, "errors")?.value : void 0;
+	return {
+		name: cause.name,
+		message: cause.message,
+		stack: cause.stack,
+		...Object.fromEntries(DIAGNOSTIC_FIELDS.flatMap((key) => {
+			const value = Object.getOwnPropertyDescriptor(cause, key)?.value;
+			return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? [[key, value]] : [];
+		})),
+		...cause.cause === void 0 || depth >= 4 ? {} : { cause: renderCause(cause.cause, depth + 1, ancestors) },
+		...Array.isArray(errors) && depth < 4 ? {
+			errors: Array.from({ length: Math.min(errors.length, 16) }, (_, index) => {
+				const member = Object.getOwnPropertyDescriptor(errors, String(index))?.value;
+				return renderCause(member, depth + 1, ancestors);
+			}),
+			...errors.length > 16 ? { omittedErrors: errors.length - 16 } : {}
+		} : {}
+	};
+};
+/**
+* One JSON object per line on `stream`.
+*
+* The caller's attributes are spread FIRST and the line's own fields after them,
+* and that order is the precedence: an `attributes: { level: "info" }` cannot
+* rewrite an `error` line's severity, nor its `traceId`.
+*
+* The unit's ids are spread at the top level rather than nested under `unit`,
+* because `traceId` is the field an operator searches.
+*/
+const jsonSink = (stream = process.stdout) => (line) => {
+	const { level, message, attributes, cause, time, unit } = line;
+	const rendered = {
+		...attributes,
+		time: new Date(time).toISOString(),
+		level,
+		message,
+		...unit === void 0 ? {} : unit,
+		...cause === void 0 ? {} : { cause: renderCause(cause) }
+	};
+	stream.write(`${safeStringify(rendered)}\n`);
+};
+const serialises = (key, value) => {
+	try {
+		JSON.stringify({ [key]: value });
+		return true;
+	} catch {
+		return false;
+	}
+};
+const safeStringify = (rendered) => {
+	try {
+		return JSON.stringify(rendered);
+	} catch {
+		const kept = Object.entries(rendered).filter(([key, value]) => serialises(key, value));
+		return JSON.stringify({
+			...Object.fromEntries(kept),
+			unserialisable: Object.keys(rendered).filter((key) => !serialises(key, rendered[key]))
+		});
+	}
+};
+//#endregion
+export { renderCause as n, jsonSink as t };

package/dist/json-sink-CQB0-tTI.cjs

@@ -0,0 +1,94 @@
+//#region src/json-sink.ts
+const DIAGNOSTIC_FIELDS = [
+	"_tag",
+	"sqlState",
+	"constraint",
+	"table",
+	"database",
+	"role",
+	"bypass",
+	"port"
+];
+/**
+* An `Error`'s `message` and `stack` are **non-enumerable**, so
+* `JSON.stringify` renders a thrown one as `{}` — the line that exists to carry
+* a failure would carry nothing. Walks `cause` chains so a wrapped failure keeps
+* its origin.
+*/
+const renderCause = (cause, depth = 0, parents = /* @__PURE__ */ new Set()) => {
+	if (!(cause instanceof Error)) return depth > 0 && cause !== null && (typeof cause === "object" || typeof cause === "function" || typeof cause === "bigint") ? "[non-error]" : cause;
+	if (parents.has(cause)) return "[circular]";
+	const ancestors = new Set(parents).add(cause);
+	const errors = cause instanceof AggregateError ? Object.getOwnPropertyDescriptor(cause, "errors")?.value : void 0;
+	return {
+		name: cause.name,
+		message: cause.message,
+		stack: cause.stack,
+		...Object.fromEntries(DIAGNOSTIC_FIELDS.flatMap((key) => {
+			const value = Object.getOwnPropertyDescriptor(cause, key)?.value;
+			return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? [[key, value]] : [];
+		})),
+		...cause.cause === void 0 || depth >= 4 ? {} : { cause: renderCause(cause.cause, depth + 1, ancestors) },
+		...Array.isArray(errors) && depth < 4 ? {
+			errors: Array.from({ length: Math.min(errors.length, 16) }, (_, index) => {
+				const member = Object.getOwnPropertyDescriptor(errors, String(index))?.value;
+				return renderCause(member, depth + 1, ancestors);
+			}),
+			...errors.length > 16 ? { omittedErrors: errors.length - 16 } : {}
+		} : {}
+	};
+};
+/**
+* One JSON object per line on `stream`.
+*
+* The caller's attributes are spread FIRST and the line's own fields after them,
+* and that order is the precedence: an `attributes: { level: "info" }` cannot
+* rewrite an `error` line's severity, nor its `traceId`.
+*
+* The unit's ids are spread at the top level rather than nested under `unit`,
+* because `traceId` is the field an operator searches.
+*/
+const jsonSink = (stream = process.stdout) => (line) => {
+	const { level, message, attributes, cause, time, unit } = line;
+	const rendered = {
+		...attributes,
+		time: new Date(time).toISOString(),
+		level,
+		message,
+		...unit === void 0 ? {} : unit,
+		...cause === void 0 ? {} : { cause: renderCause(cause) }
+	};
+	stream.write(`${safeStringify(rendered)}\n`);
+};
+const serialises = (key, value) => {
+	try {
+		JSON.stringify({ [key]: value });
+		return true;
+	} catch {
+		return false;
+	}
+};
+const safeStringify = (rendered) => {
+	try {
+		return JSON.stringify(rendered);
+	} catch {
+		const kept = Object.entries(rendered).filter(([key, value]) => serialises(key, value));
+		return JSON.stringify({
+			...Object.fromEntries(kept),
+			unserialisable: Object.keys(rendered).filter((key) => !serialises(key, rendered[key]))
+		});
+	}
+};
+//#endregion
+Object.defineProperty(exports, "jsonSink", {
+	enumerable: true,
+	get: function() {
+		return jsonSink;
+	}
+});
+Object.defineProperty(exports, "renderCause", {
+	enumerable: true,
+	get: function() {
+		return renderCause;
+	}
+});

package/dist/pino.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_json_sink = require("./json-sink-CQB0-tTI.cjs");
 //#region src/pino.ts
 /**
 * A {@link Sink} over a pino logger — the subpath a deployment reaches for
@@ -16,19 +17,29 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 * ```
 *
 * The level filter stays **ours**: `createLogger` has already decided the
-* line is worth writing by the time a sink sees it, so pino is configured at
-* `trace` here — one filter in the process, and it is the one `LOG_LEVEL`
-* validated at startup. `fatal` and `trace` map to pino's own; the ambient
-* unit's ids ride as fields, not as a message prefix, so they stay indexable.
+* line is worth writing by the time a sink sees it, so the child logger has a
+* `trace` floor — one filter in the process, and it is the one `LOG_LEVEL`
+* validated at startup. The supplied logger is left unchanged. `fatal` and
+* `trace` map to pino's own; the ambient unit's ids ride as fields, not as a
+* message prefix, so they stay indexable.
 */
-const pinoSink = (logger) => (line) => {
-	const { level, message, attributes, cause, unit } = line;
-	const fields = {
-		...attributes,
-		...unit === void 0 ? {} : unit,
-		...cause === void 0 ? {} : { err: cause }
+const pinoSink = (logger) => {
+	const safeLogger = logger.child({}, {
+		level: "trace",
+		serializers: { err: (cause) => cause instanceof Error ? {
+			type: cause.name,
+			...require_json_sink.renderCause(cause)
+		} : require_json_sink.renderCause(cause) }
+	});
+	return (line) => {
+		const { level, message, attributes, cause, unit } = line;
+		const fields = {
+			...attributes,
+			...unit === void 0 ? {} : unit,
+			...cause === void 0 ? {} : { err: cause }
+		};
+		safeLogger[level](fields, message);
 	};
-	logger[level](fields, message);
 };
 //#endregion
 exports.pinoSink = pinoSink;

package/dist/pino.d.cts

@@ -17,10 +17,11 @@ import { Logger } from "pino";
  * ```
  *
  * The level filter stays **ours**: `createLogger` has already decided the
- * line is worth writing by the time a sink sees it, so pino is configured at
- * `trace` here — one filter in the process, and it is the one `LOG_LEVEL`
- * validated at startup. `fatal` and `trace` map to pino's own; the ambient
- * unit's ids ride as fields, not as a message prefix, so they stay indexable.
+ * line is worth writing by the time a sink sees it, so the child logger has a
+ * `trace` floor — one filter in the process, and it is the one `LOG_LEVEL`
+ * validated at startup. The supplied logger is left unchanged. `fatal` and
+ * `trace` map to pino's own; the ambient unit's ids ride as fields, not as a
+ * message prefix, so they stay indexable.
  */
 export declare const pinoSink: (logger: Logger) => Sink;
 //#endregion

package/dist/pino.d.mts

@@ -17,10 +17,11 @@ import { Logger } from "pino";
  * ```
  *
  * The level filter stays **ours**: `createLogger` has already decided the
- * line is worth writing by the time a sink sees it, so pino is configured at
- * `trace` here — one filter in the process, and it is the one `LOG_LEVEL`
- * validated at startup. `fatal` and `trace` map to pino's own; the ambient
- * unit's ids ride as fields, not as a message prefix, so they stay indexable.
+ * line is worth writing by the time a sink sees it, so the child logger has a
+ * `trace` floor — one filter in the process, and it is the one `LOG_LEVEL`
+ * validated at startup. The supplied logger is left unchanged. `fatal` and
+ * `trace` map to pino's own; the ambient unit's ids ride as fields, not as a
+ * message prefix, so they stay indexable.
  */
 export declare const pinoSink: (logger: Logger) => Sink;
 //#endregion

package/dist/pino.mjs

@@ -1,3 +1,4 @@
+import { n as renderCause } from "./json-sink-7PQoEfMj.mjs";
 //#region src/pino.ts
 /**
 * A {@link Sink} over a pino logger — the subpath a deployment reaches for
@@ -15,19 +16,29 @@
 * ```
 *
 * The level filter stays **ours**: `createLogger` has already decided the
-* line is worth writing by the time a sink sees it, so pino is configured at
-* `trace` here — one filter in the process, and it is the one `LOG_LEVEL`
-* validated at startup. `fatal` and `trace` map to pino's own; the ambient
-* unit's ids ride as fields, not as a message prefix, so they stay indexable.
+* line is worth writing by the time a sink sees it, so the child logger has a
+* `trace` floor — one filter in the process, and it is the one `LOG_LEVEL`
+* validated at startup. The supplied logger is left unchanged. `fatal` and
+* `trace` map to pino's own; the ambient unit's ids ride as fields, not as a
+* message prefix, so they stay indexable.
 */
-const pinoSink = (logger) => (line) => {
-	const { level, message, attributes, cause, unit } = line;
-	const fields = {
-		...attributes,
-		...unit === void 0 ? {} : unit,
-		...cause === void 0 ? {} : { err: cause }
+const pinoSink = (logger) => {
+	const safeLogger = logger.child({}, {
+		level: "trace",
+		serializers: { err: (cause) => cause instanceof Error ? {
+			type: cause.name,
+			...renderCause(cause)
+		} : renderCause(cause) }
+	});
+	return (line) => {
+		const { level, message, attributes, cause, unit } = line;
+		const fields = {
+			...attributes,
+			...unit === void 0 ? {} : unit,
+			...cause === void 0 ? {} : { err: cause }
+		};
+		safeLogger[level](fields, message);
 	};
-	logger[level](fields, message);
 };
 //#endregion
 export { pinoSink };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/observability",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "description": "Observability for @btravstack/core: a strict Logger port correlated with the kernel's units, a dependency-free JSON sink, and the lifecycle events as log lines",
   "keywords": [
     "dependency-injection",
@@ -65,10 +65,10 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@btravstack/config": "0.30.1",
-    "@btravstack/core": "0.30.1",
-    "@btravstack/di": "0.30.1",
-    "@btravstack/testing": "0.30.1",
+    "@btravstack/config": "0.31.0",
+    "@btravstack/core": "0.31.0",
+    "@btravstack/di": "0.31.0",
+    "@btravstack/testing": "0.31.0",
     "@btravstack/tsconfig": "0.4.0",
     "@opentelemetry/api": "1.9.1",
     "@opentelemetry/sdk-node": "0.222.0",
@@ -83,9 +83,9 @@
     "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@btravstack/config": "^0.30.1",
-    "@btravstack/core": "^0.30.1",
-    "@btravstack/di": "^0.30.1",
+    "@btravstack/config": "^0.31.0",
+    "@btravstack/core": "^0.31.0",
+    "@btravstack/di": "^0.31.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "pino": "^10",