@camstack/system 1.2.17 → 1.2.19

package/dist/builtins/loki-logging/index.js

@@ -50,6 +50,12 @@ function formatLokiLine(entry) {
 * Group a batch into one stream per distinct label set, and sort each stream's
 * values by timestamp.
 *
+* The `node` label is resolved PER ENTRY from `tags.agentId` (the emitting
+* agent, falling back to `labels.node` when absent), so a batch that mixes
+* hub-local lines with forwarded agent lines fans out into one stream per
+* origin node — the whole point of shipping the cluster's logs through the hub
+* without flattening every line onto `node="hub"`.
+*
 * The sort is not cosmetic. Loki historically rejected a stream whose entries
 * were not in ascending time order, and even with out-of-order ingestion enabled
 * it is bounded by a window. Entries reach a destination from several concurrent
@@ -58,21 +64,26 @@ function formatLokiLine(entry) {
 */
 function buildPushBody(entries, labels) {
 	if (entries.length === 0) return null;
-	const base = {
-		job: labels.job,
-		node: labels.node
-	};
+	const base = { job: labels.job };
 	for (const [key, value] of Object.entries(labels.extra ?? {})) base[key] = value;
-	const byLevel = /* @__PURE__ */ new Map();
+	const byStream = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
-		const values = byLevel.get(entry.level) ?? [];
-		values.push([toUnixNano(entry.timestamp), formatLokiLine(entry)]);
-		byLevel.set(entry.level, values);
+		const agentId = entry.tags?.agentId;
+		const node = typeof agentId === "string" && agentId.length > 0 ? agentId : labels.node;
+		const key = `${node}\u0000${entry.level}`;
+		const bucket = byStream.get(key) ?? {
+			node,
+			level: entry.level,
+			values: []
+		};
+		bucket.values.push([toUnixNano(entry.timestamp), formatLokiLine(entry)]);
+		byStream.set(key, bucket);
 	}
 	const streams = [];
-	for (const [level, values] of byLevel) streams.push({
+	for (const { node, level, values } of byStream.values()) streams.push({
 		stream: {
 			...base,
+			node,
 			level
 		},
 		values: values.toSorted((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
@@ -118,10 +129,32 @@ var LokiDestination = class {
 	}
 	async initialize(config) {
 		this.config = config ?? null;
-		if (!this.isActive()) return;
+		this.startTimerIfActive();
+	}
+	/**
+	* Re-apply configuration to an already-initialized destination after a
+	* settings change, without dropping the queued tail. Stops the current flush
+	* timer, swaps the config in, and starts a fresh timer only when the new
+	* config is active. This is what makes the addon's "enable without a restart"
+	* contract real: `initialize()` starts a timer, so calling it twice would leak
+	* the first one — `reconfigure()` clears it first.
+	*/
+	async reconfigure(config) {
+		this.stopTimer();
+		this.config = config;
+		this.startTimerIfActive();
+	}
+	stopTimer() {
+		if (this.timer !== void 0) {
+			this.clearIntervalFn(this.timer);
+			this.timer = void 0;
+		}
+	}
+	startTimerIfActive() {
+		if (!this.isActive() || this.config === null) return;
 		this.timer = this.setIntervalFn(() => {
 			this.flush();
-		}, Math.max(250, config?.batchIntervalMs ?? 5e3));
+		}, Math.max(250, this.config.batchIntervalMs));
 		const timer = this.timer;
 		if (typeof timer === "object" && timer !== null && "unref" in timer) timer.unref();
 	}
@@ -254,10 +287,7 @@ var LokiDestination = class {
 		return [];
 	}
 	async shutdown() {
-		if (this.timer !== void 0) {
-			this.clearIntervalFn(this.timer);
-			this.timer = void 0;
-		}
+		this.stopTimer();
 		await this.flush();
 		this.config = null;
 	}
@@ -296,6 +326,17 @@ var LokiLoggingAddon = class extends require_dist.BaseAddon {
 		this.destination = null;
 	}
 	/**
+	* React to a settings change (enable/disable, URL, level, batching) without a
+	* restart — the contract this addon advertises. `BaseAddon` has already
+	* reloaded `this.config` by the time this runs; re-apply it to the live
+	* destination so toggling `enabled` on actually starts pushing (and off stops
+	* it). Without this the destination keeps its boot-time config forever.
+	*/
+	async onConfigChanged() {
+		await this.destination?.reconfigure(this.destinationConfig());
+		this.ctx.logger.info(this.config.enabled && this.config.url.length > 0 ? `Loki logging reconfigured → ${this.config.url}` : "Loki logging now inactive (disabled or no URL)");
+	}
+	/**
 	* `node` is a Loki LABEL, so it must be the node's real identity and must not
 	* be operator-editable — a typo would fork the stream and split a node's history
 	* in two. `kernel.localNodeId` is the Moleculer node id (`'hub'` on the hub, the

package/dist/builtins/loki-logging/index.mjs

@@ -45,6 +45,12 @@ function formatLokiLine(entry) {
 * Group a batch into one stream per distinct label set, and sort each stream's
 * values by timestamp.
 *
+* The `node` label is resolved PER ENTRY from `tags.agentId` (the emitting
+* agent, falling back to `labels.node` when absent), so a batch that mixes
+* hub-local lines with forwarded agent lines fans out into one stream per
+* origin node — the whole point of shipping the cluster's logs through the hub
+* without flattening every line onto `node="hub"`.
+*
 * The sort is not cosmetic. Loki historically rejected a stream whose entries
 * were not in ascending time order, and even with out-of-order ingestion enabled
 * it is bounded by a window. Entries reach a destination from several concurrent
@@ -53,21 +59,26 @@ function formatLokiLine(entry) {
 */
 function buildPushBody(entries, labels) {
 	if (entries.length === 0) return null;
-	const base = {
-		job: labels.job,
-		node: labels.node
-	};
+	const base = { job: labels.job };
 	for (const [key, value] of Object.entries(labels.extra ?? {})) base[key] = value;
-	const byLevel = /* @__PURE__ */ new Map();
+	const byStream = /* @__PURE__ */ new Map();
 	for (const entry of entries) {
-		const values = byLevel.get(entry.level) ?? [];
-		values.push([toUnixNano(entry.timestamp), formatLokiLine(entry)]);
-		byLevel.set(entry.level, values);
+		const agentId = entry.tags?.agentId;
+		const node = typeof agentId === "string" && agentId.length > 0 ? agentId : labels.node;
+		const key = `${node}\u0000${entry.level}`;
+		const bucket = byStream.get(key) ?? {
+			node,
+			level: entry.level,
+			values: []
+		};
+		bucket.values.push([toUnixNano(entry.timestamp), formatLokiLine(entry)]);
+		byStream.set(key, bucket);
 	}
 	const streams = [];
-	for (const [level, values] of byLevel) streams.push({
+	for (const { node, level, values } of byStream.values()) streams.push({
 		stream: {
 			...base,
+			node,
 			level
 		},
 		values: values.toSorted((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
@@ -113,10 +124,32 @@ var LokiDestination = class {
 	}
 	async initialize(config) {
 		this.config = config ?? null;
-		if (!this.isActive()) return;
+		this.startTimerIfActive();
+	}
+	/**
+	* Re-apply configuration to an already-initialized destination after a
+	* settings change, without dropping the queued tail. Stops the current flush
+	* timer, swaps the config in, and starts a fresh timer only when the new
+	* config is active. This is what makes the addon's "enable without a restart"
+	* contract real: `initialize()` starts a timer, so calling it twice would leak
+	* the first one — `reconfigure()` clears it first.
+	*/
+	async reconfigure(config) {
+		this.stopTimer();
+		this.config = config;
+		this.startTimerIfActive();
+	}
+	stopTimer() {
+		if (this.timer !== void 0) {
+			this.clearIntervalFn(this.timer);
+			this.timer = void 0;
+		}
+	}
+	startTimerIfActive() {
+		if (!this.isActive() || this.config === null) return;
 		this.timer = this.setIntervalFn(() => {
 			this.flush();
-		}, Math.max(250, config?.batchIntervalMs ?? 5e3));
+		}, Math.max(250, this.config.batchIntervalMs));
 		const timer = this.timer;
 		if (typeof timer === "object" && timer !== null && "unref" in timer) timer.unref();
 	}
@@ -249,10 +282,7 @@ var LokiDestination = class {
 		return [];
 	}
 	async shutdown() {
-		if (this.timer !== void 0) {
-			this.clearIntervalFn(this.timer);
-			this.timer = void 0;
-		}
+		this.stopTimer();
 		await this.flush();
 		this.config = null;
 	}
@@ -291,6 +321,17 @@ var LokiLoggingAddon = class extends BaseAddon {
 		this.destination = null;
 	}
 	/**
+	* React to a settings change (enable/disable, URL, level, batching) without a
+	* restart — the contract this addon advertises. `BaseAddon` has already
+	* reloaded `this.config` by the time this runs; re-apply it to the live
+	* destination so toggling `enabled` on actually starts pushing (and off stops
+	* it). Without this the destination keeps its boot-time config forever.
+	*/
+	async onConfigChanged() {
+		await this.destination?.reconfigure(this.destinationConfig());
+		this.ctx.logger.info(this.config.enabled && this.config.url.length > 0 ? `Loki logging reconfigured → ${this.config.url}` : "Loki logging now inactive (disabled or no URL)");
+	}
+	/**
 	* `node` is a Loki LABEL, so it must be the node's real identity and must not
 	* be operator-editable — a typo would fork the stream and split a node's history
 	* in two. `kernel.localNodeId` is the Moleculer node id (`'hub'` on the hub, the

package/dist/builtins/loki-logging/loki-destination.d.ts

@@ -60,6 +60,17 @@ export declare class LokiDestination implements ILogDestination {
     private readonly clearIntervalFn;
     constructor(deps?: LokiDestinationDeps);
     initialize(config?: LokiConfig): Promise<void>;
+    /**
+     * Re-apply configuration to an already-initialized destination after a
+     * settings change, without dropping the queued tail. Stops the current flush
+     * timer, swaps the config in, and starts a fresh timer only when the new
+     * config is active. This is what makes the addon's "enable without a restart"
+     * contract real: `initialize()` starts a timer, so calling it twice would leak
+     * the first one — `reconfigure()` clears it first.
+     */
+    reconfigure(config: LokiConfig): Promise<void>;
+    private stopTimer;
+    private startTimerIfActive;
     /** Enabled AND pointed somewhere. An enabled destination with no URL is inert. */
     private isActive;
     write(entry: LogEntry): void;

package/dist/builtins/loki-logging/loki-logging.addon.d.ts

@@ -18,6 +18,14 @@ export declare class LokiLoggingAddon extends BaseAddon<LokiAddonConfig> {
     constructor();
     protected onInitialize(): Promise<ProviderRegistration[]>;
     protected onShutdown(): Promise<void>;
+    /**
+     * React to a settings change (enable/disable, URL, level, batching) without a
+     * restart — the contract this addon advertises. `BaseAddon` has already
+     * reloaded `this.config` by the time this runs; re-apply it to the live
+     * destination so toggling `enabled` on actually starts pushing (and off stops
+     * it). Without this the destination keeps its boot-time config forever.
+     */
+    protected onConfigChanged(): Promise<void>;
     /**
      * `node` is a Loki LABEL, so it must be the node's real identity and must not
      * be operator-editable — a typo would fork the stream and split a node's history

package/dist/builtins/loki-logging/loki-payload.d.ts

@@ -11,7 +11,12 @@ export interface LokiPushBody {
 export interface LokiLabelInput {
     /** Fixed `job` label. Bounded by configuration, never per-entry. */
     readonly job: string;
-    /** This node's id. Bounded by cluster size. */
+    /**
+     * Fallback node id for entries that carry no `tags.agentId` origin — the
+     * id of the node running this destination. The per-entry origin
+     * (`tags.agentId`) is preferred so forwarded agent logs are attributed to
+     * their source node rather than the hub that ships them.
+     */
     readonly node: string;
     /** Extra static labels from configuration. Values must be low-cardinality. */
     readonly extra?: Readonly<Record<string, string>>;
@@ -37,6 +42,12 @@ export declare function formatLokiLine(entry: LogEntry): string;
  * Group a batch into one stream per distinct label set, and sort each stream's
  * values by timestamp.
  *
+ * The `node` label is resolved PER ENTRY from `tags.agentId` (the emitting
+ * agent, falling back to `labels.node` when absent), so a batch that mixes
+ * hub-local lines with forwarded agent lines fans out into one stream per
+ * origin node — the whole point of shipping the cluster's logs through the hub
+ * without flattening every line onto `node="hub"`.
+ *
  * The sort is not cosmetic. Loki historically rejected a stream whose entries
  * were not in ascending time order, and even with out-of-order ingestion enabled
  * it is bounded by a window. Entries reach a destination from several concurrent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.17",
+  "version": "1.2.19",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",