Use a similar strategy to LabelMap for stats coalescing for cluster.js

This has to wrestle with the problem of lack of fore-knowledge of the
canonical set of labels. We achieve this by assuming 6 labels to
begin with, first filling in the empties as we discover new ones, and
tnen expanding the columns by ⌈25%⌉ if they don't, and re-keying the
entire table (by concatenating extra ||'s onto the end)..

Before and after:

✓ cluster ➭ aggregate() is 6.088% faster.
✓ cluster ➭ aggregate() is 149.4% faster.

Author: jdmarshall

CHANGELOG.md

@@ -24,7 +24,7 @@ project adheres to [Semantic Versioning](http://semver.org/).
 - perf: Remove truthy conditionals in hot code paths
 - Show the invalid name in the validation errors
 - perf: Improve performance of registry defaultLabels during metric processing
-- perf: New, more space-efficient storage engine, 20-45% faster stats recording
+- perf: New, more space-efficient storage engine, 20-45% faster stats recording, 148% faster aggregation
 
 ### Added
 

benchmarks/util.js

@@ -14,6 +14,9 @@ function setupUtilSuite(suite) {
 				foo: 'longish',
 				user_agent: 'Chrome',
 				gateway: 'lb04',
+				method: 'get',
+				status_code: 200,
+				phase: 'load',
 			});
 		},
 		{ setup: findUtil },
@@ -27,9 +30,13 @@ function setupUtilSuite(suite) {
 			}
 
 			labelMap.validate({
-				foo: 'longish:tag:goes:here',
+				foo: 'longish',
 				user_agent: 'Chrome',
-				status_code: 503,
+				gateway: 'lb04',
+				method: 'get',
+				status_code: 200,
+				phase: 'load',
+				label1: 4,
 			});
 		},
 		{ setup },
@@ -45,11 +52,41 @@ function setupUtilSuite(suite) {
 			labelMap.keyFrom({
 				foo: 'longish',
 				user_agent: 'Chrome',
-				status_code: 503,
+				gateway: 'lb04',
+				method: 'get',
+				status_code: 301,
+				phase: 'load',
+				label1: 4,
 			});
 		},
 		{ setup },
 	);
+
+	suite.add(
+		'LabelGrouper.keyFrom()',
+		(client, labelGrouper) => {
+			if (labelGrouper === undefined) {
+				return;
+			}
+
+			labelGrouper.keyFrom({
+				foo: 'longish',
+				user_agent: 'Chrome',
+				gateway: 'lb04',
+				method: 'get',
+				status_code: 503,
+				phase: 'load',
+				label1: 4,
+			});
+		},
+		{
+			setup: client => {
+				const Util = findUtil(client);
+
+				return Util && new Util.LabelGrouper();
+			},
+		},
+	);
 }
 
 function setup(client) {
@@ -62,6 +99,8 @@ function setup(client) {
 			'gateway',
 			'method',
 			'status_code',
+			'phase',
+			'label1',
 		]);
 	}
 }

lib/metricAggregators.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { Grouper, hashObject } = require('./util');
+const { LabelGrouper } = require('./util');
 
 /**
  * Returns a new function that applies the `aggregatorFn` to the values.
@@ -24,10 +24,10 @@ function AggregatorFactory(aggregatorFn) {
 				const name = value.metricName ?? '';
 				let group = byNames.get(name);
 				if (group === undefined) {
-					group = new Grouper();
+					group = new LabelGrouper();
 					byNames.set(name, group);
 				}
-				group.add(hashObject(value.labels), value);
+				group.add(value);
 			});
 		});
 		// Apply aggregator function to gathered metrics.

lib/util.js

@@ -352,3 +352,177 @@ class Grouper extends Map {
 }
 
 exports.Grouper = Grouper;
+
+const GROWTH_RATE = 1.25;
+
+/**
+ * For grouping metrics by labels for reporting purposes.
+ */
+class LabelGrouper {
+	/** @type {string[]} */
+	#labelNames = new Array(6).fill('');
+
+	/** @type {Map<string, Array<any>>} */
+	#map = new Map();
+
+	/**
+	 * Current number of columns
+	 * @type {number}
+	 */
+	#count = 0;
+
+	/**
+	 * Create a grouper.
+	 */
+	constructor() {}
+
+	/**
+	 * Adds the `value` to the `key`'s array of values.
+	 * @param {StatsEntry} value Value to add to `key`'s array.
+	 * @returns {LabelGrouper} undefined.
+	 */
+	add(value) {
+		const labels = value.labels;
+		const key = this.keyFrom(labels);
+
+		const entry = this.#map.get(key);
+		if (entry !== undefined) {
+			entry.push(value);
+		} else {
+			this.#map.set(key, [value]);
+		}
+
+		return this;
+	}
+
+	/**
+	 * Look up an entry by labels.
+	 * Note: This can end up modifying the store if labels are missing.
+	 * @param {object} labels Key to retrieve.
+	 * @returns {Array<StatsEntry>} undefined.
+	 */
+	get(labels) {
+		return this.#map.get(this.keyFrom(labels));
+	}
+
+	/**
+	 * Return all of the entries in this collection.
+	 * @returns {Iterator<StatsEntry>}
+	 */
+	values() {
+		return this.#map.values().filter(entry => entry.length > 0);
+	}
+
+	/**
+	 * Loop over the entries.
+	 * @param fn {Function}
+	 */
+	forEach(fn) {
+		return this.#map.forEach(fn);
+	}
+
+	/**
+	 * Remove all values from the Grouper.
+	 * Leaves the entries, but zeroes out the value arrays.
+	 * @returns {LabelGrouper}
+	 */
+	clear() {
+		for (const entry of this.#map.values()) {
+			entry.length = 0;
+		}
+
+		return this;
+	}
+
+	/**
+	 * Create a key for the given labels.
+	 * Note: This can end up modifying the store if labels are missing.
+	 * @param labels
+	 * @returns {string}
+	 */
+	keyFrom(labels = {}) {
+		const keys = Object.keys(labels);
+
+		if (keys.length === 0) {
+			return '';
+		}
+
+		const arr = new Array(this.#labelNames.length);
+
+		let count = 0;
+		for (let i = 0; i < this.#count; i++) {
+			const name = this.#labelNames[i];
+			const value = labels[name];
+
+			if (value !== undefined) {
+				arr[i] = value;
+				count++;
+			}
+		}
+
+		if (count < keys.length) {
+			let pos = this.#count;
+			const missing = this.#expandLabels(labels);
+			for (const name of missing) {
+				arr[pos++] = labels[name];
+			}
+		}
+
+		return arr.join('|');
+	}
+
+	/**
+	 * Size of the collection.
+	 * @returns {number}
+	 */
+	get size() {
+		return this.#map.size;
+	}
+
+	/**
+	 * Search the labels for missing values and expand the lookup table to handle them.
+	 * @param labels
+	 * @returns {*[]}
+	 */
+	#expandLabels(labels) {
+		const missing = [];
+
+		for (const name of Object.keys(labels)) {
+			if (this.#labelNames.indexOf(name) === -1) {
+				missing.push(name);
+			}
+		}
+
+		const target = missing.length + this.#count;
+		const current = this.#labelNames.length;
+		let width = current;
+
+		if (target > width) {
+			while (target > width) {
+				width = Math.ceil(width * GROWTH_RATE);
+			}
+
+			this.#labelNames.length = width;
+			this.#labelNames.fill('', current, width);
+
+			const extension = '|'.repeat(width - current);
+			const newMap = new Map();
+
+			for (const [key, value] of this.#map.entries()) {
+				newMap.set(`${key}${extension}`, value);
+			}
+
+			this.#map = newMap;
+		}
+
+		for (let i = this.#count, j = 0; j < missing.length; i++, j++) {
+			this.#labelNames[i] = missing[j];
+		}
+
+		this.#count = target;
+
+		return missing;
+	}
+}
+
+module.exports.LabelGrouper = LabelGrouper;