@worker-manager/metrics 1.0.0

package/dist/LatencyStore.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LatencyStore = exports.QUEUE_AGE_METRIC = void 0;
+const histogram_1 = require("./histogram");
+const keys_1 = require("./keys");
+exports.QUEUE_AGE_METRIC = 'queueage';
+const SECONDS_PER_DAY = 86400;
+const MS_PER_HOUR = 3600000;
+function ttl(days) {
+    return String(Math.max(1, Math.floor(days * SECONDS_PER_DAY)));
+}
+/**
+ * Merges one tick's bucket vector into the queue's hour hash, its day totals, and the
+ * global rollup of both, in a single round trip.
+ *
+ * Packing all 18 counts into one hash field rather than one field per bucket is what keeps
+ * this affordable: Redis hash entry overhead dwarfs a two-byte count, so the packed form
+ * costs roughly an eighth of the field-per-bucket form. The trade is that HINCRBY no longer
+ * applies, hence the read-modify-write here.
+ *
+ * Unlike the counter path there is no delta trick, because the caller supplies increments
+ * rather than absolute values. Two recorders writing the same tick would double-count, which
+ * is what LatencySampler's lease prevents.
+ *
+ * KEYS[1] queue hour hash    ARGV[1] hour field      ARGV[4] hour-tier ttl
+ * KEYS[2] queue totals hash  ARGV[2] day field        ARGV[5] day-tier ttl
+ * KEYS[3] global hour hash   ARGV[3] packed vector    ARGV[6] oldest day to keep
+ * KEYS[4] global totals hash                          ARGV[7] bucket count
+ */
+const MERGE_VECTOR = `
+local function merge(key, field, incoming, width)
+  local current = redis.call('HGET', key, field)
+  local out = {}
+  local i = 1
+  if current then
+    for value in string.gmatch(current, '([^,]+)') do
+      out[i] = tonumber(value) or 0
+      i = i + 1
+    end
+  end
+  while i <= width do
+    out[i] = 0
+    i = i + 1
+  end
+  local j = 1
+  for value in string.gmatch(incoming, '([^,]+)') do
+    out[j] = (out[j] or 0) + (tonumber(value) or 0)
+    j = j + 1
+  end
+  redis.call('HSET', key, field, table.concat(out, ','))
+end
+
+local function trim(key, cutoff)
+  local fields = redis.call('HKEYS', key)
+  local stale = {}
+  for i = 1, #fields do
+    if fields[i] < cutoff then
+      stale[#stale + 1] = fields[i]
+      if #stale == 256 then
+        redis.call('HDEL', key, unpack(stale))
+        stale = {}
+      end
+    end
+  end
+  if #stale > 0 then
+    redis.call('HDEL', key, unpack(stale))
+  end
+end
+
+local width = tonumber(ARGV[7])
+local newDay = redis.call('HEXISTS', KEYS[2], ARGV[2]) == 0
+
+merge(KEYS[1], ARGV[1], ARGV[3], width)
+merge(KEYS[2], ARGV[2], ARGV[3], width)
+merge(KEYS[3], ARGV[1], ARGV[3], width)
+merge(KEYS[4], ARGV[2], ARGV[3], width)
+
+redis.call('EXPIRE', KEYS[1], ARGV[4])
+redis.call('EXPIRE', KEYS[2], ARGV[5])
+redis.call('EXPIRE', KEYS[3], ARGV[4])
+redis.call('EXPIRE', KEYS[4], ARGV[5])
+
+if newDay then
+  trim(KEYS[2], ARGV[6])
+  trim(KEYS[4], ARGV[6])
+end
+return 1
+`;
+/**
+ * Queue age is a gauge, so an hour holds the worst backlog seen in it and a day holds the
+ * worst of its hours. Summing would be meaningless -- which is also why the global rollup
+ * here is a MAX across queues rather than the four-key SUM MERGE_VECTOR does: "the oldest
+ * job waiting anywhere on this board" is the meaningful cross-queue number, adding queues'
+ * ages together would not be.
+ *
+ * Because it's "set if greater", a bucket's value never goes down within its own hour or
+ * day once a high value lands -- that's the correct meaning of "the worst backlog seen in
+ * this hour/day", both for a single queue and for the global rollup. A later, healthier
+ * queue doesn't erase an earlier spike from the same bucket; it only wins the buckets it
+ * writes to itself.
+ *
+ * The totals hashes need the same day cutoff MERGE_VECTOR applies: their TTL is refreshed on
+ * every tick, so without a trim they would accumulate one field per day for as long as the
+ * queue exists rather than for the retention window.
+ *
+ * KEYS[1] queue hour hash    ARGV[1] hour field      ARGV[4] hour-tier ttl
+ * KEYS[2] queue totals hash  ARGV[2] day field        ARGV[5] day-tier ttl
+ * KEYS[3] global hour hash   ARGV[3] value            ARGV[6] oldest day to keep
+ * KEYS[4] global totals hash
+ */
+const MAX_GAUGE = `
+local function setMax(key, field, value)
+  local current = tonumber(redis.call('HGET', key, field) or '-1')
+  if value > current then
+    redis.call('HSET', key, field, value)
+  end
+end
+
+local function trim(key, cutoff)
+  local fields = redis.call('HKEYS', key)
+  local stale = {}
+  for i = 1, #fields do
+    if fields[i] < cutoff then
+      stale[#stale + 1] = fields[i]
+      if #stale == 256 then
+        redis.call('HDEL', key, unpack(stale))
+        stale = {}
+      end
+    end
+  end
+  if #stale > 0 then
+    redis.call('HDEL', key, unpack(stale))
+  end
+end
+
+local value = tonumber(ARGV[3])
+local newDay = redis.call('HEXISTS', KEYS[2], ARGV[2]) == 0
+
+setMax(KEYS[1], ARGV[1], value)
+setMax(KEYS[2], ARGV[2], value)
+setMax(KEYS[3], ARGV[1], value)
+setMax(KEYS[4], ARGV[2], value)
+
+redis.call('EXPIRE', KEYS[1], ARGV[4])
+redis.call('EXPIRE', KEYS[2], ARGV[5])
+redis.call('EXPIRE', KEYS[3], ARGV[4])
+redis.call('EXPIRE', KEYS[4], ARGV[5])
+
+if newDay then
+  trim(KEYS[2], ARGV[6])
+  trim(KEYS[4], ARGV[6])
+end
+return 1
+`;
+class LatencyStore {
+    constructor(opts) {
+        this.redis = opts.redis;
+        this.keys = opts.keys;
+        this.retention = opts.retention;
+    }
+    async addSamples(queue, metric, hour, vector) {
+        const day = (0, keys_1.minuteToDay)(hour * 60);
+        await this.redis.eval(MERGE_VECTOR, 4, this.keys.hour(queue, metric, day), this.keys.totals(queue, metric), this.keys.hour(keys_1.GLOBAL_QUEUE, metric, day), this.keys.totals(keys_1.GLOBAL_QUEUE, metric), String(hour), day, (0, histogram_1.packVector)(vector), ttl(this.retention.hours), ttl(this.retention.days), (0, keys_1.shiftDay)(day, -this.retention.days), String(histogram_1.BUCKET_COUNT));
+    }
+    async recordQueueAge(queue, hour, ms) {
+        const day = (0, keys_1.minuteToDay)(hour * 60);
+        await this.redis.eval(MAX_GAUGE, 4, this.keys.hour(queue, exports.QUEUE_AGE_METRIC, day), this.keys.totals(queue, exports.QUEUE_AGE_METRIC), this.keys.hour(keys_1.GLOBAL_QUEUE, exports.QUEUE_AGE_METRIC, day), this.keys.totals(keys_1.GLOBAL_QUEUE, exports.QUEUE_AGE_METRIC), String(hour), day, String(Math.max(0, Math.round(ms))), ttl(this.retention.hours), ttl(this.retention.days), (0, keys_1.shiftDay)(day, -this.retention.days));
+    }
+    async readRange(queue, metric, granularity, days) {
+        const out = {};
+        if (granularity === 'day') {
+            const raw = await this.redis.hgetall(this.keys.totals(queue, metric));
+            for (const day of days) {
+                if (raw[day] !== undefined) {
+                    out[day] = (0, histogram_1.unpackVector)(raw[day]);
+                }
+            }
+            return out;
+        }
+        // Up to one key per retention day, so these go out together rather than as a serial
+        // chain of round trips, matching how the counter path reads its day hashes.
+        const perDay = await Promise.all(days.map((day) => this.redis.hgetall(this.keys.hour(queue, metric, day))));
+        for (const raw of perDay) {
+            for (const field of Object.keys(raw)) {
+                out[field] = out[field]
+                    ? (0, histogram_1.mergeVectors)(out[field], (0, histogram_1.unpackVector)(raw[field]))
+                    : (0, histogram_1.unpackVector)(raw[field]);
+            }
+        }
+        return out;
+    }
+    async readQueueAge(queue, granularity, days) {
+        var _a;
+        const out = {};
+        if (granularity === 'day') {
+            const raw = await this.redis.hgetall(this.keys.totals(queue, exports.QUEUE_AGE_METRIC));
+            for (const day of days) {
+                if (raw[day] !== undefined) {
+                    out[day] = Number(raw[day]) || 0;
+                }
+            }
+            return out;
+        }
+        const perDay = await Promise.all(days.map((day) => this.redis.hgetall(this.keys.hour(queue, exports.QUEUE_AGE_METRIC, day))));
+        for (const raw of perDay) {
+            for (const field of Object.keys(raw)) {
+                out[field] = Math.max((_a = out[field]) !== null && _a !== void 0 ? _a : 0, Number(raw[field]) || 0);
+            }
+        }
+        return out;
+    }
+    /** Epoch ms for an absolute hour index, for building response timestamps. */
+    static hourToMs(hour) {
+        return hour * MS_PER_HOUR;
+    }
+}
+exports.LatencyStore = LatencyStore;
+//# sourceMappingURL=LatencyStore.js.map

package/dist/LatencyStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LatencyStore.js","sourceRoot":"","sources":["../src/LatencyStore.ts"],"names":[],"mappings":";;;AACA,2CAAmF;AAEnF,iCAA+E;AAIlE,QAAA,gBAAgB,GAAG,UAAU,CAAC;AAE3C,MAAM,eAAe,GAAG,KAAK,CAAC;AAC9B,MAAM,WAAW,GAAG,OAAO,CAAC;AAE5B,SAAS,GAAG,CAAC,IAAY;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CjB,CAAC;AAEF,MAAa,YAAY;IAKvB,YAAY,IAAuE;QACjF,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,UAAU,CACd,KAAa,EACb,MAAqB,EACrB,IAAY,EACZ,MAAgB;QAEhB,MAAM,GAAG,GAAG,IAAA,kBAAW,EAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QACnC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CACnB,YAAY,EACZ,CAAC,EACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAClC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAC/B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAY,EAAE,MAAM,EAAE,GAAG,CAAC,EACzC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAY,EAAE,MAAM,CAAC,EACtC,MAAM,CAAC,IAAI,CAAC,EACZ,GAAG,EACH,IAAA,sBAAU,EAAC,MAAM,CAAC,EAClB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EACzB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACxB,IAAA,eAAQ,EAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACnC,MAAM,CAAC,wBAAY,CAAC,CACrB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,KAAa,EAAE,IAAY,EAAE,EAAU;QAC1D,MAAM,GAAG,GAAG,IAAA,kBAAW,EAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QACnC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CACnB,SAAS,EACT,CAAC,EACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,wBAAgB,EAAE,GAAG,CAAC,EAC5C,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,wBAAgB,CAAC,EACzC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAY,EAAE,wBAAgB,EAAE,GAAG,CAAC,EACnD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAY,EAAE,wBAAgB,CAAC,EAChD,MAAM,CAAC,IAAI,CAAC,EACZ,GAAG,EACH,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EACnC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EACzB,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EACxB,IAAA,eAAQ,EAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CACpC,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,SAAS,CACb,KAAa,EACb,MAAqB,EACrB,WAA2B,EAC3B,IAAc;QAEd,MAAM,GAAG,GAA6B,EAAE,CAAC;QACzC,IAAI,WAAW,KAAK,KAAK,EAAE,CAAC;YAC1B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;YACtE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;oBAC3B,GAAG,CAAC,GAAG,CAAC,GAAG,IAAA,wBAAY,EAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;QACD,oFAAoF;QACpF,4EAA4E;QAC5E,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAC1E,CAAC;QACF,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrC,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC;oBACrB,CAAC,CAAC,IAAA,wBAAY,EAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAA,wBAAY,EAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;oBACpD,CAAC,CAAC,IAAA,wBAAY,EAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,KAAK,CAAC,YAAY,CAChB,KAAa,EACb,WAA2B,EAC3B,IAAc;;QAEd,MAAM,GAAG,GAA2B,EAAE,CAAC;QACvC,IAAI,WAAW,KAAK,KAAK,EAAE,CAAC;YAC1B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,wBAAgB,CAAC,CAAC,CAAC;YAChF,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;oBAC3B,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,wBAAgB,EAAE,GAAG,CAAC,CAAC,CAAC,CACpF,CAAC;QACF,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAA,GAAG,CAAC,KAAK,CAAC,mCAAI,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,6EAA6E;IAC7E,MAAM,CAAC,QAAQ,CAAC,IAAY;QAC1B,OAAO,IAAI,GAAG,WAAW,CAAC;IAC5B,CAAC;CACF;AAlHD,oCAkHC"}

package/dist/MetricsRecorder.d.ts

@@ -0,0 +1,92 @@
+import type { BaseAdapter } from '@worker-manager/api/baseAdapter';
+import { type MetricsConnection } from './connection';
+import { type Retention } from './HistoryStore';
+/**
+ * Minute detail is the expensive tier by two orders of magnitude, so it defaults to a week
+ * rather than the full window: long enough to match the recommended `MetricsTime.ONE_WEEK`
+ * worker buffer, so the recorder can be down for a week and still catch up completely.
+ * The hourly and daily rollups are cheap enough to keep for the whole window.
+ */
+export declare const DEFAULT_RETENTION: Retention;
+export interface MetricsRecorderOptions {
+    /**
+     * A function is resolved on every tick, for a board whose queue set changes while it
+     * runs. An array is read once, at construction.
+     */
+    queues: BaseAdapter[] | (() => BaseAdapter[]);
+    connection: MetricsConnection;
+    /**
+     * Redis key namespace, defaulting to `bull-board:metrics`. Set it to separate two boards
+     * sharing one Redis, and give the reading `RedisMetricsHistoryProvider` the same value.
+     *
+     * On a Redis Cluster the namespace has to sit in one hash slot, since the rollup scripts
+     * write a queue's keys and the cross-queue keys in one EVAL. A prefix with no `{...}` hash
+     * tag is wrapped in one, so `staging:metrics` becomes `{staging:metrics}`; supply your own
+     * tag to choose the slot yourself.
+     */
+    prefix?: string;
+    /** Per-resolution retention in days. Unspecified tiers fall back to the defaults. */
+    retention?: Partial<Retention>;
+    /**
+     * Shorthand that sets the daily and hourly windows. Minute retention stays at its
+     * default unless raised explicitly, since that is the tier that drives storage size.
+     */
+    retentionDays?: number;
+    snapshotIntervalMs?: number;
+    /**
+     * Latency histograms and the queue-age gauge. On by default: the package exists to give
+     * boards without a metrics stack something useful, and an opt-in feature is one nobody
+     * finds. At default retention this costs roughly 250 to 300KB per queue under typical
+     * traffic, up to about 575KB in a pathological worst case, plus a one-off shared cost of
+     * roughly 224KB for the cross-queue rollup regardless of queue count.
+     */
+    latency?: boolean;
+    /** Above this many finished jobs in one tick, the sampler subsamples. */
+    maxLatencySamplesPerTick?: number;
+    /**
+     * Test-oriented escape hatch: overrides the sampler's default 5s safety margin (see
+     * `LatencySampler`'s `SAFETY_MARGIN_MS`), which otherwise excludes jobs that finished
+     * just before a scan. Lets a test read back a sample immediately instead of sleeping
+     * past the margin.
+     */
+    latencySafetyMarginMs?: number;
+    /**
+     * Notified whenever a latency tick fails. Latency errors are swallowed on purpose so a
+     * failing scan cannot take the counter snapshot with it, which also means a collector
+     * broken since startup looks the same as a board with no traffic. Default stays silent;
+     * wire this to your logger to tell an empty chart from a broken one.
+     */
+    onLatencyError?: (error: unknown, queueName: string) => void;
+}
+export declare function resolveRetention(opts: {
+    retention?: Partial<Retention>;
+    retentionDays?: number;
+}): Retention;
+export declare class MetricsRecorder {
+    private readonly resolveQueues;
+    private readonly store;
+    private readonly redis;
+    private readonly ownsRedis;
+    private readonly intervalMs;
+    private readonly lastMinute;
+    private timer;
+    private running;
+    private stopped;
+    readonly latencyEnabled: boolean;
+    private readonly latencySampler;
+    constructor(opts: MetricsRecorderOptions);
+    get retention(): Retention;
+    start(): void;
+    stop(): void;
+    snapshot(): Promise<void>;
+    /**
+     * Incrementally copies BullMQ's per-minute ring buffer into long-retention storage.
+     * `seenUpTo` is a per-(queue, metric) watermark of the newest minute already written.
+     * getMetrics() returns points newest-first, so we walk from the newest and stop at the
+     * first minute we've already stored: everything past it is older and stored too. Fresh
+     * minutes are upserted (safe against overlapping windows across ticks), then the
+     * watermark advances. So the first tick backfills the buffer and every later tick only
+     * writes the minutes that appeared since.
+     */
+    private snapshotOne;
+}

package/dist/MetricsRecorder.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsRecorder = exports.DEFAULT_RETENTION = void 0;
+exports.resolveRetention = resolveRetention;
+const connection_1 = require("./connection");
+const dataMapping_1 = require("./dataMapping");
+const HistoryStore_1 = require("./HistoryStore");
+const keys_1 = require("./keys");
+const LatencySampler_1 = require("./LatencySampler");
+const LatencyStore_1 = require("./LatencyStore");
+const METRICS = ['completed', 'failed'];
+const MS_PER_MINUTE = 60000;
+const MINUTES_PER_DAY = 1440;
+/**
+ * Minute detail is the expensive tier by two orders of magnitude, so it defaults to a week
+ * rather than the full window: long enough to match the recommended `MetricsTime.ONE_WEEK`
+ * worker buffer, so the recorder can be down for a week and still catch up completely.
+ * The hourly and daily rollups are cheap enough to keep for the whole window.
+ */
+exports.DEFAULT_RETENTION = { minutes: 7, hours: 90, days: 90 };
+function resolveRetention(opts) {
+    const base = opts.retentionDays === undefined
+        ? exports.DEFAULT_RETENTION
+        : {
+            minutes: Math.min(exports.DEFAULT_RETENTION.minutes, opts.retentionDays),
+            hours: opts.retentionDays,
+            days: opts.retentionDays,
+        };
+    return { ...base, ...opts.retention };
+}
+class MetricsRecorder {
+    constructor(opts) {
+        var _a;
+        this.lastMinute = new Map();
+        this.timer = null;
+        this.running = false;
+        this.stopped = false;
+        const { queues } = opts;
+        this.resolveQueues = typeof queues === 'function' ? queues : () => queues;
+        this.intervalMs = (_a = opts.snapshotIntervalMs) !== null && _a !== void 0 ? _a : 60000;
+        const { client, owned } = (0, connection_1.resolveClient)(opts.connection);
+        this.redis = client;
+        this.ownsRedis = owned;
+        const keys = (0, keys_1.metricsKeys)((0, keys_1.resolveNamespace)(opts.prefix, (0, connection_1.isCluster)(client)));
+        this.store = new HistoryStore_1.HistoryStore({ redis: this.redis, keys, retention: resolveRetention(opts) });
+        this.latencyEnabled = opts.latency !== false;
+        this.latencySampler = this.latencyEnabled
+            ? new LatencySampler_1.LatencySampler({
+                redis: this.redis,
+                keys,
+                store: new LatencyStore_1.LatencyStore({ redis: this.redis, keys, retention: resolveRetention(opts) }),
+                tickMs: this.intervalMs,
+                maxSamplesPerTick: opts.maxLatencySamplesPerTick,
+                safetyMarginMs: opts.latencySafetyMarginMs,
+                onError: opts.onLatencyError,
+            })
+            : null;
+    }
+    get retention() {
+        return this.store.retention;
+    }
+    start() {
+        if (this.timer) {
+            return;
+        }
+        this.timer = setInterval(() => {
+            void this.snapshot();
+        }, this.intervalMs);
+        // Do not keep the event loop alive solely for the recorder.
+        if (typeof this.timer.unref === 'function') {
+            this.timer.unref();
+        }
+        void this.snapshot();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.ownsRedis && !this.stopped) {
+            this.redis.disconnect();
+        }
+        this.stopped = true;
+    }
+    async snapshot() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        try {
+            for (const adapter of this.resolveQueues()) {
+                const name = adapter.getName();
+                for (const metric of METRICS) {
+                    await this.snapshotOne(adapter, name, metric);
+                }
+                if (this.latencySampler) {
+                    await this.latencySampler.sample(adapter);
+                }
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    /**
+     * Incrementally copies BullMQ's per-minute ring buffer into long-retention storage.
+     * `seenUpTo` is a per-(queue, metric) watermark of the newest minute already written.
+     * getMetrics() returns points newest-first, so we walk from the newest and stop at the
+     * first minute we've already stored: everything past it is older and stored too. Fresh
+     * minutes are upserted (safe against overlapping windows across ticks), then the
+     * watermark advances. So the first tick backfills the buffer and every later tick only
+     * writes the minutes that appeared since.
+     */
+    async snapshotOne(adapter, name, metric) {
+        var _a;
+        const cursorKey = `${name}:${metric}`;
+        const seenUpTo = (_a = this.lastMinute.get(cursorKey)) !== null && _a !== void 0 ? _a : -1;
+        const metrics = await adapter.getMetrics(metric).catch(() => null);
+        const points = (0, dataMapping_1.metricsToMinutePoints)(metrics);
+        if (points.length === 0) {
+            return;
+        }
+        // Correctness guard, not an optimization. Idempotency comes from the minute hash
+        // holding the previously written value, so a minute whose hash has already expired
+        // would look brand new and be added to the hourly and daily rollups a second time.
+        // That can only happen when the worker's metrics buffer reaches further back than the
+        // minute window (say a two-week buffer against a one-week window) and the recorder
+        // restarts, losing its in-memory watermark. Refusing to write past the window closes
+        // it. Nothing is lost that could have been retained anyway.
+        const oldestWritable = Math.floor(Date.now() / MS_PER_MINUTE) - this.store.retention.minutes * MINUTES_PER_DAY;
+        let newest = seenUpTo;
+        for (const point of points) {
+            if (point.minute <= seenUpTo) {
+                break; // points are newest-first; everything older is already stored
+            }
+            if (point.minute < oldestWritable) {
+                break; // ...and everything past here is older still
+            }
+            await this.store.upsertMinute(name, metric, point.minute, point.value);
+            if (point.minute > newest) {
+                newest = point.minute;
+            }
+        }
+        this.lastMinute.set(cursorKey, newest);
+    }
+}
+exports.MetricsRecorder = MetricsRecorder;
+//# sourceMappingURL=MetricsRecorder.js.map

package/dist/MetricsRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsRecorder.js","sourceRoot":"","sources":["../src/MetricsRecorder.ts"],"names":[],"mappings":"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"}

package/dist/RedisMetricsHistoryProvider.d.ts

@@ -0,0 +1,28 @@
+import type { MetricsHistoryPoint, MetricsHistoryProvider, MetricsHistoryQuery, MetricsLatencyPoint, MetricsLatencyQuery } from '@worker-manager/api/typings/app';
+import { type MetricsConnection } from './connection';
+import { type HistoryStats, type PurgeOptions, type PurgeResult } from './HistoryAdmin';
+import { type Retention } from './HistoryStore';
+export interface RedisMetricsHistoryProviderOptions {
+    connection: MetricsConnection;
+    /** Must match the recorder's. See `MetricsRecorderOptions.prefix`. */
+    prefix?: string;
+    /** Should mirror the recorder's retention. Only used to bound the query span. */
+    retention?: Partial<Retention>;
+    retentionDays?: number;
+}
+export declare class RedisMetricsHistoryProvider implements MetricsHistoryProvider {
+    private readonly store;
+    private readonly latencyStore;
+    private readonly admin;
+    private readonly redis;
+    private readonly ownsRedis;
+    private readonly retentionDays;
+    constructor(opts: RedisMetricsHistoryProviderOptions);
+    disconnect(): void;
+    /** Backs the board's storage panel. See MetricsHistoryAdmin.stats. */
+    getUsage(): Promise<HistoryStats>;
+    /** Backs the board's "clear history" action. See MetricsHistoryAdmin.purge. */
+    purge(options?: PurgeOptions): Promise<PurgeResult>;
+    getHistory(query: MetricsHistoryQuery): Promise<MetricsHistoryPoint[]>;
+    getLatency(query: MetricsLatencyQuery): Promise<MetricsLatencyPoint[]>;
+}

package/dist/RedisMetricsHistoryProvider.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisMetricsHistoryProvider = void 0;
+const connection_1 = require("./connection");
+const histogram_1 = require("./histogram");
+const HistoryAdmin_1 = require("./HistoryAdmin");
+const HistoryStore_1 = require("./HistoryStore");
+const keys_1 = require("./keys");
+const LatencyStore_1 = require("./LatencyStore");
+const MetricsRecorder_1 = require("./MetricsRecorder");
+const MS_PER_HOUR = 3600000;
+class RedisMetricsHistoryProvider {
+    constructor(opts) {
+        const { client, owned } = (0, connection_1.resolveClient)(opts.connection);
+        this.redis = client;
+        this.ownsRedis = owned;
+        const keys = (0, keys_1.metricsKeys)((0, keys_1.resolveNamespace)(opts.prefix, (0, connection_1.isCluster)(client)));
+        const retention = (0, MetricsRecorder_1.resolveRetention)(opts);
+        this.retentionDays = retention.days;
+        this.store = new HistoryStore_1.HistoryStore({ redis: this.redis, keys, retention });
+        this.latencyStore = new LatencyStore_1.LatencyStore({ redis: this.redis, keys, retention });
+        this.admin = new HistoryAdmin_1.MetricsHistoryAdmin({ connection: this.redis, prefix: opts.prefix });
+    }
+    disconnect() {
+        if (this.ownsRedis) {
+            this.redis.disconnect();
+        }
+    }
+    /** Backs the board's storage panel. See MetricsHistoryAdmin.stats. */
+    async getUsage() {
+        return this.admin.stats();
+    }
+    /** Backs the board's "clear history" action. See MetricsHistoryAdmin.purge. */
+    async purge(options = {}) {
+        return this.admin.purge(options);
+    }
+    async getHistory(query) {
+        var _a, _b;
+        const queue = (_a = query.queue) !== null && _a !== void 0 ? _a : keys_1.GLOBAL_QUEUE;
+        // Clamp the span to the retention window so an unbounded `from` (e.g. 0) can't make
+        // dayRange produce an unbounded number of day buckets -- older data doesn't exist anyway.
+        const maxSpanMs = (this.retentionDays + 1) * 86400000;
+        const from = Math.max(query.from, query.to - maxSpanMs);
+        const days = (0, keys_1.dayRange)(from, query.to);
+        if (query.metric === 'queueage') {
+            const ages = await this.latencyStore.readQueueAge(queue, query.granularity, days);
+            // Day points are stamped at the day's start, so an intraday `from` would drop the day
+            // it falls in. Floored, exactly as the counter path below does it.
+            const lowerBound = query.granularity === 'day' ? dayFloor(query.from) : query.from;
+            return Object.keys(ages)
+                .map((key) => ({
+                ts: query.granularity === 'day' ? (0, keys_1.dayToStartMs)(key) : Number(key) * MS_PER_HOUR,
+                value: ages[key],
+            }))
+                .filter((p) => p.ts >= lowerBound && p.ts <= query.to)
+                .sort((a, b) => a.ts - b.ts);
+        }
+        if (query.granularity === 'day') {
+            const rawTotals = await this.store.readDailyTotalsRaw(queue, query.metric, days);
+            // Empty history only when no day in range was ever recorded (all fields missing).
+            // A day with a stored '0' still counts as recorded -- otherwise the UI's empty
+            // state would be unreachable once any data exists.
+            if (rawTotals.every((value) => value == null)) {
+                return [];
+            }
+            const totals = {};
+            days.forEach((day, i) => {
+                totals[day] = Number(rawTotals[i]) || 0;
+            });
+            return days
+                .map((day) => { var _a; return ({ ts: (0, keys_1.dayToStartMs)(day), value: (_a = totals[day]) !== null && _a !== void 0 ? _a : 0 }); })
+                .filter((p) => p.ts >= dayFloor(query.from) && p.ts <= query.to);
+        }
+        const hourBuckets = new Map();
+        const dayHours = await Promise.all(days.map((day) => this.store.readDayHours(queue, query.metric, day)));
+        for (const hours of dayHours) {
+            for (const field of Object.keys(hours)) {
+                const ts = Number(field) * MS_PER_HOUR;
+                if (ts < query.from || ts > query.to) {
+                    continue;
+                }
+                hourBuckets.set(ts, ((_b = hourBuckets.get(ts)) !== null && _b !== void 0 ? _b : 0) + hours[field]);
+            }
+        }
+        return [...hourBuckets.entries()]
+            .map(([ts, value]) => ({ ts, value }))
+            .sort((a, b) => a.ts - b.ts);
+    }
+    async getLatency(query) {
+        var _a;
+        const queue = (_a = query.queue) !== null && _a !== void 0 ? _a : keys_1.GLOBAL_QUEUE;
+        const maxSpanMs = (this.retentionDays + 1) * 86400000;
+        const from = Math.max(query.from, query.to - maxSpanMs);
+        const days = (0, keys_1.dayRange)(from, query.to);
+        if (query.granularity === 'range') {
+            // Percentiles don't merge: averaging per-day p95s isn't the same number as the p95 of
+            // the whole range. Read the day tier's bucket vectors and merge them, then compute each
+            // requested percentile once from the summed vector.
+            const raw = await this.latencyStore.readRange(queue, query.metric, 'day', days);
+            let merged = (0, histogram_1.emptyVector)();
+            for (const day of days) {
+                const vector = raw[day];
+                if (vector) {
+                    merged = (0, histogram_1.mergeVectors)(merged, vector);
+                }
+            }
+            const count = (0, histogram_1.vectorTotal)(merged);
+            if (count === 0) {
+                return [];
+            }
+            const values = {};
+            for (const p of query.percentiles) {
+                values[String(p)] = (0, histogram_1.quantile)(merged, p);
+            }
+            return [{ ts: query.from, count: Math.round(count), values }];
+        }
+        const raw = await this.latencyStore.readRange(queue, query.metric, query.granularity, days);
+        // Same day-start alignment as getHistory: comparing a day bucket against a raw `from`
+        // would drop the oldest day and leave this chart one bucket shorter than the throughput
+        // chart drawn for the same range.
+        const lowerBound = query.granularity === 'day' ? dayFloor(query.from) : query.from;
+        const points = [];
+        for (const key of Object.keys(raw)) {
+            const ts = query.granularity === 'day' ? (0, keys_1.dayToStartMs)(key) : Number(key) * MS_PER_HOUR;
+            if (ts < lowerBound || ts > query.to) {
+                continue;
+            }
+            const vector = raw[key];
+            const count = (0, histogram_1.vectorTotal)(vector);
+            if (count === 0) {
+                continue;
+            }
+            const values = {};
+            for (const p of query.percentiles) {
+                values[String(p)] = (0, histogram_1.quantile)(vector, p);
+            }
+            points.push({ ts, count: Math.round(count), values });
+        }
+        return points.sort((a, b) => a.ts - b.ts);
+    }
+}
+exports.RedisMetricsHistoryProvider = RedisMetricsHistoryProvider;
+function dayFloor(ms) {
+    const d = new Date(ms);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+//# sourceMappingURL=RedisMetricsHistoryProvider.js.map