@adalo/metrics 0.1.172 → 0.1.174

package/lib/metrics/httpMetricsRedisCollector.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const {
+  BaseMetricsClient
+} = require('./baseMetricsClient');
+const {
+  HttpMetricsRedisStore,
+  buildFieldKey
+} = require('./httpMetricsRedisStore');
+
+/**
+ * Drain worker: reads HTTP aggregates from Redis (written by {@link HttpMetricsRedisRecorder}),
+ * applies them to `app_requests_*` counters, then pushes the registry to the VM-agent (same as {@link BaseMetricsClient}).
+ * **Minimal usage:** `{ redisClient }` only. Redis keys use segment **`web`** unless you pass **`redisProcessTypeForKeys`**.
+ * `processType` / `appName` / `dynoId` follow {@link BaseMetricsClient} defaults (e.g. `BUILD_DYNO_PROCESS_TYPE`) and do **not** select Redis hash names.
+ * Always passes `blockNodeDefaultMetrics: true` (HTTP-focused registry).
+ *
+ * @extends BaseMetricsClient
+ */
+class HttpMetricsRedisCollector extends BaseMetricsClient {
+  /**
+   * @param {Object} [config]
+   * @param {import('redis').RedisClient} config.redisClient **Required.** Injected client (same pattern as {@link RedisMetricsClient}).
+   * @param {string} [config.appName] Application name (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.dynoId] Dyno/instance ID
+   * @param {string} [config.processType] Label `process_type` on push (default from env / base)
+   * @param {boolean} [config.enabled] Enable collection and push
+   * @param {boolean} [config.logValues] Log metric JSON to console
+   * @param {string} [config.pushgatewayUrl] VM-agent import URL
+   * @param {string} [config.pushgatewaySecret] Basic auth secret (Base64)
+   * @param {number} [config.intervalSec] Push interval (seconds)
+   * @param {boolean} [config.removeOldMetrics] Clear old series on shutdown where supported
+   * @param {function} [config.startupValidation] Run before first push
+   * @param {boolean} [config.disablePushgateway] Skip POST to VM-agent
+   * @param {string} [config.redisProcessTypeForKeys] Segment in Redis keys for HTTP hashes (default **`web`**). Optional; only if writers use a non-`web` segment.
+   * @param {number} [config.ttlSec] Passed to {@link HttpMetricsRedisStore} (should match writers)
+   */
+  constructor(config = {}) {
+    const {
+      redisClient
+    } = config;
+    if (redisClient == null) {
+      throw new Error('HttpMetricsRedisCollector: redisClient is required');
+    }
+    super({
+      ...config,
+      blockNodeDefaultMetrics: true
+    });
+    const keyProcessType = config.redisProcessTypeForKeys || 'web';
+    this.defaultLabelsWithoutDynoId = {
+      app: this.appName,
+      process_type: keyProcessType
+    };
+    this._store = new HttpMetricsRedisStore({
+      redisClient,
+      appName: this.appName,
+      processType: keyProcessType,
+      ttlSec: config.ttlSec
+    });
+
+    /** @type {Set<string>} Redis field keys already primed with inc(0) + push in this process */
+    this._httpCounterPrimedKeys = new Set();
+    this.createCounter({
+      name: 'app_requests_total',
+      help: 'Total number of HTTP requests',
+      labelNames: this.withDefaultLabelsWithoutDynoId(['method', 'route', 'status_code']),
+      useLabelsWithoutDynoId: true
+    });
+    this.createCounter({
+      name: 'app_requests_total_duration',
+      help: 'Total duration of HTTP requests in milliseconds',
+      labelNames: this.withDefaultLabelsWithoutDynoId(['method', 'route', 'status_code']),
+      useLabelsWithoutDynoId: true
+    });
+  }
+
+  /**
+   * Drains Redis into counters, then runs gauge updates and VM-agent push ({@link BaseMetricsClient#_pushMetrics}).
+   * @returns {Promise<void>}
+   */
+  pushMetrics = async () => {
+    if (this._store && this.countersFunctions?.app_requests_total && this.countersFunctions?.app_requests_total_duration) {
+      const {
+        ok,
+        rows
+      } = await this._store.drainRows();
+      if (ok && rows.length > 0) {
+        const applyCount = (labels, value) => this.countersFunctions.app_requests_total(labels, value);
+        const applyDur = (labels, value) => this.countersFunctions.app_requests_total_duration(labels, value);
+        let primedAny = false;
+        for (const row of rows) {
+          const key = buildFieldKey(row.labels.method, row.labels.route, row.labels.status_code);
+          if (!this._httpCounterPrimedKeys.has(key)) {
+            this._httpCounterPrimedKeys.add(key);
+            applyCount(row.labels, 0);
+            applyDur(row.labels, 0);
+            primedAny = true;
+          }
+        }
+        if (primedAny) {
+          await this.gatewayPush();
+        }
+        for (const row of rows) {
+          applyCount(row.labels, row.count);
+          if (row.dur > 0) {
+            applyDur(row.labels, row.dur);
+          }
+        }
+      }
+    }
+    return this._pushMetrics();
+  };
+}
+module.exports = {
+  HttpMetricsRedisCollector
+};
+//# sourceMappingURL=httpMetricsRedisCollector.js.map

package/lib/metrics/httpMetricsRedisCollector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpMetricsRedisCollector.js","names":["BaseMetricsClient","require","HttpMetricsRedisStore","buildFieldKey","HttpMetricsRedisCollector","constructor","config","redisClient","Error","blockNodeDefaultMetrics","keyProcessType","redisProcessTypeForKeys","defaultLabelsWithoutDynoId","app","appName","process_type","_store","processType","ttlSec","_httpCounterPrimedKeys","Set","createCounter","name","help","labelNames","withDefaultLabelsWithoutDynoId","useLabelsWithoutDynoId","pushMetrics","countersFunctions","app_requests_total","app_requests_total_duration","ok","rows","drainRows","length","applyCount","labels","value","applyDur","primedAny","row","key","method","route","status_code","has","add","gatewayPush","count","dur","_pushMetrics","module","exports"],"sources":["../../src/metrics/httpMetricsRedisCollector.js"],"sourcesContent":["const { BaseMetricsClient } = require('./baseMetricsClient')\nconst {\n  HttpMetricsRedisStore,\n  buildFieldKey,\n} = require('./httpMetricsRedisStore')\n\n/**\n * Drain worker: reads HTTP aggregates from Redis (written by {@link HttpMetricsRedisRecorder}),\n * applies them to `app_requests_*` counters, then pushes the registry to the VM-agent (same as {@link BaseMetricsClient}).\n * **Minimal usage:** `{ redisClient }` only. Redis keys use segment **`web`** unless you pass **`redisProcessTypeForKeys`**.\n * `processType` / `appName` / `dynoId` follow {@link BaseMetricsClient} defaults (e.g. `BUILD_DYNO_PROCESS_TYPE`) and do **not** select Redis hash names.\n * Always passes `blockNodeDefaultMetrics: true` (HTTP-focused registry).\n *\n * @extends BaseMetricsClient\n */\nclass HttpMetricsRedisCollector extends BaseMetricsClient {\n  /**\n   * @param {Object} [config]\n   * @param {import('redis').RedisClient} config.redisClient **Required.** Injected client (same pattern as {@link RedisMetricsClient}).\n   * @param {string} [config.appName] Application name (defaults per {@link BaseMetricsClient})\n   * @param {string} [config.dynoId] Dyno/instance ID\n   * @param {string} [config.processType] Label `process_type` on push (default from env / base)\n   * @param {boolean} [config.enabled] Enable collection and push\n   * @param {boolean} [config.logValues] Log metric JSON to console\n   * @param {string} [config.pushgatewayUrl] VM-agent import URL\n   * @param {string} [config.pushgatewaySecret] Basic auth secret (Base64)\n   * @param {number} [config.intervalSec] Push interval (seconds)\n   * @param {boolean} [config.removeOldMetrics] Clear old series on shutdown where supported\n   * @param {function} [config.startupValidation] Run before first push\n   * @param {boolean} [config.disablePushgateway] Skip POST to VM-agent\n   * @param {string} [config.redisProcessTypeForKeys] Segment in Redis keys for HTTP hashes (default **`web`**). Optional; only if writers use a non-`web` segment.\n   * @param {number} [config.ttlSec] Passed to {@link HttpMetricsRedisStore} (should match writers)\n   */\n  constructor(config = {}) {\n    const { redisClient } = config\n    if (redisClient == null) {\n      throw new Error('HttpMetricsRedisCollector: redisClient is required')\n    }\n\n    super({\n      ...config,\n      blockNodeDefaultMetrics: true,\n    })\n\n    const keyProcessType = config.redisProcessTypeForKeys || 'web'\n\n    this.defaultLabelsWithoutDynoId = {\n      app: this.appName,\n      process_type: keyProcessType,\n    }\n\n    this._store = new HttpMetricsRedisStore({\n      redisClient,\n      appName: this.appName,\n      processType: keyProcessType,\n      ttlSec: config.ttlSec,\n    })\n\n    /** @type {Set<string>} Redis field keys already primed with inc(0) + push in this process */\n    this._httpCounterPrimedKeys = new Set()\n\n    this.createCounter({\n      name: 'app_requests_total',\n      help: 'Total number of HTTP requests',\n      labelNames: this.withDefaultLabelsWithoutDynoId([\n        'method',\n        'route',\n        'status_code',\n      ]),\n      useLabelsWithoutDynoId: true,\n    })\n\n    this.createCounter({\n      name: 'app_requests_total_duration',\n      help: 'Total duration of HTTP requests in milliseconds',\n      labelNames: this.withDefaultLabelsWithoutDynoId([\n        'method',\n        'route',\n        'status_code',\n      ]),\n      useLabelsWithoutDynoId: true,\n    })\n  }\n\n  /**\n   * Drains Redis into counters, then runs gauge updates and VM-agent push ({@link BaseMetricsClient#_pushMetrics}).\n   * @returns {Promise<void>}\n   */\n  pushMetrics = async () => {\n    if (\n      this._store &&\n      this.countersFunctions?.app_requests_total &&\n      this.countersFunctions?.app_requests_total_duration\n    ) {\n      const { ok, rows } = await this._store.drainRows()\n      if (ok && rows.length > 0) {\n        const applyCount = (labels, value) =>\n          this.countersFunctions.app_requests_total(labels, value)\n        const applyDur = (labels, value) =>\n          this.countersFunctions.app_requests_total_duration(labels, value)\n\n        let primedAny = false\n        for (const row of rows) {\n          const key = buildFieldKey(\n            row.labels.method,\n            row.labels.route,\n            row.labels.status_code\n          )\n          if (!this._httpCounterPrimedKeys.has(key)) {\n            this._httpCounterPrimedKeys.add(key)\n            applyCount(row.labels, 0)\n            applyDur(row.labels, 0)\n            primedAny = true\n          }\n        }\n        if (primedAny) {\n          await this.gatewayPush()\n        }\n        for (const row of rows) {\n          applyCount(row.labels, row.count)\n          if (row.dur > 0) {\n            applyDur(row.labels, row.dur)\n          }\n        }\n      }\n    }\n    return this._pushMetrics()\n  }\n}\n\nmodule.exports = { HttpMetricsRedisCollector }\n"],"mappings":"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","ignoreList":[]}

package/lib/metrics/httpMetricsRedisRecorder.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Records HTTP request aggregates only to Redis (no in-process Prometheus counters on this path).
+ * Pair with {@link HttpMetricsRedisCollector} on a drain process to flush into counters and push to the VM-agent.
+ *
+ * @see HttpMetricsRedisStore
+ */
+export class HttpMetricsRedisRecorder {
+    /**
+     * @param {Object} opts
+     * @param {import('redis').RedisClient} opts.redisClient **Required.** Injected client (same pattern as {@link RedisMetricsClient}).
+     * @param {string} [opts.appName] Optional override; default same as {@link BaseMetricsClient}: `BUILD_APP_NAME` or `unknown-app`.
+     * @param {string} [opts.processType] Redis key segment (default **`web`**, same as {@link HttpMetricsRedisCollector}).
+     * @param {number} [opts.ttlSec] Redis hash key TTL in seconds (sliding; default 120).
+     */
+    constructor({ redisClient, appName, processType, ttlSec }?: {
+        redisClient: import('redis').RedisClient;
+        appName?: string | undefined;
+        processType?: string | undefined;
+        ttlSec?: number | undefined;
+    });
+    processType: string;
+    appName: string;
+    _store: HttpMetricsRedisStore;
+    /**
+     * @param {Object} params
+     * @param {string} params.method
+     * @param {string} params.route
+     * @param {number} params.status_code
+     * @param {number} params.duration
+     */
+    trackHttpRequest({ method, route, status_code, duration }: {
+        method: string;
+        route: string;
+        status_code: number;
+        duration: number;
+    }): void;
+    /**
+     * Express middleware: appends a `finish` listener and writes one aggregate row per request to Redis.
+     * Does not check `METRICS_ENABLED`; the app should only mount this when HTTP Redis metrics should run.
+     *
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     * @param {function} next
+     */
+    trackHttpRequestMiddleware: (req: import('http').IncomingMessage, res: import('http').ServerResponse, next: Function) => void;
+}
+import { HttpMetricsRedisStore } from "./httpMetricsRedisStore";
+//# sourceMappingURL=httpMetricsRedisRecorder.d.ts.map

package/lib/metrics/httpMetricsRedisRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpMetricsRedisRecorder.d.ts","sourceRoot":"","sources":["../../src/metrics/httpMetricsRedisRecorder.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IACE;;;;;;OAMG;IACH;QAL6C,WAAW,EAA7C,OAAO,OAAO,EAAE,WAAW;QACb,OAAO;QACP,WAAW;QACX,MAAM;OAgB9B;IARC,oBAA8B;IAC9B,gBAA8B;IAC9B,8BAKE;IAGJ;;;;;;OAMG;IACH;QAL0B,MAAM,EAArB,MAAM;QACS,KAAK,EAApB,MAAM;QACS,WAAW,EAA1B,MAAM;QACS,QAAQ,EAAvB,MAAM;aAIhB;IAED;;;;;;;OAOG;IACH,kCAJW,OAAO,MAAM,EAAE,eAAe,OAC9B,OAAO,MAAM,EAAE,cAAc,0BAsBvC;CACF"}

package/lib/metrics/httpMetricsRedisRecorder.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const {
+  HttpMetricsRedisStore
+} = require('./httpMetricsRedisStore');
+
+/**
+ * Records HTTP request aggregates only to Redis (no in-process Prometheus counters on this path).
+ * Pair with {@link HttpMetricsRedisCollector} on a drain process to flush into counters and push to the VM-agent.
+ *
+ * @see HttpMetricsRedisStore
+ */
+class HttpMetricsRedisRecorder {
+  /**
+   * @param {Object} opts
+   * @param {import('redis').RedisClient} opts.redisClient **Required.** Injected client (same pattern as {@link RedisMetricsClient}).
+   * @param {string} [opts.appName] Optional override; default same as {@link BaseMetricsClient}: `BUILD_APP_NAME` or `unknown-app`.
+   * @param {string} [opts.processType] Redis key segment (default **`web`**, same as {@link HttpMetricsRedisCollector}).
+   * @param {number} [opts.ttlSec] Redis hash key TTL in seconds (sliding; default 120).
+   */
+  constructor({
+    redisClient,
+    appName,
+    processType = 'web',
+    ttlSec
+  } = {}) {
+    if (redisClient == null) {
+      throw new Error('HttpMetricsRedisRecorder: redisClient is required');
+    }
+    const resolvedAppName = appName || process.env.BUILD_APP_NAME || 'unknown-app';
+    this.processType = processType;
+    this.appName = resolvedAppName;
+    this._store = new HttpMetricsRedisStore({
+      redisClient,
+      appName: resolvedAppName,
+      processType,
+      ttlSec
+    });
+  }
+
+  /**
+   * @param {Object} params
+   * @param {string} params.method
+   * @param {string} params.route
+   * @param {number} params.status_code
+   * @param {number} params.duration
+   */
+  trackHttpRequest({
+    method,
+    route,
+    status_code,
+    duration
+  }) {
+    this._store.record(method, route, status_code, duration);
+  }
+
+  /**
+   * Express middleware: appends a `finish` listener and writes one aggregate row per request to Redis.
+   * Does not check `METRICS_ENABLED`; the app should only mount this when HTTP Redis metrics should run.
+   *
+   * @param {import('http').IncomingMessage} req
+   * @param {import('http').ServerResponse} res
+   * @param {function} next
+   */
+  trackHttpRequestMiddleware = (req, res, next) => {
+    if (req.method === 'OPTIONS') {
+      next();
+      return;
+    }
+    const start = Date.now();
+    res.on('finish', () => {
+      const route = req.route?.path || req.path || 'unknown';
+      this.trackHttpRequest({
+        method: req.method,
+        route,
+        status_code: res.statusCode,
+        duration: Date.now() - start
+      });
+    });
+    next();
+  };
+}
+module.exports = {
+  HttpMetricsRedisRecorder
+};
+//# sourceMappingURL=httpMetricsRedisRecorder.js.map

package/lib/metrics/httpMetricsRedisRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpMetricsRedisRecorder.js","names":["HttpMetricsRedisStore","require","HttpMetricsRedisRecorder","constructor","redisClient","appName","processType","ttlSec","Error","resolvedAppName","process","env","BUILD_APP_NAME","_store","trackHttpRequest","method","route","status_code","duration","record","trackHttpRequestMiddleware","req","res","next","start","Date","now","on","path","statusCode","module","exports"],"sources":["../../src/metrics/httpMetricsRedisRecorder.js"],"sourcesContent":["const { HttpMetricsRedisStore } = require('./httpMetricsRedisStore')\n\n/**\n * Records HTTP request aggregates only to Redis (no in-process Prometheus counters on this path).\n * Pair with {@link HttpMetricsRedisCollector} on a drain process to flush into counters and push to the VM-agent.\n *\n * @see HttpMetricsRedisStore\n */\nclass HttpMetricsRedisRecorder {\n  /**\n   * @param {Object} opts\n   * @param {import('redis').RedisClient} opts.redisClient **Required.** Injected client (same pattern as {@link RedisMetricsClient}).\n   * @param {string} [opts.appName] Optional override; default same as {@link BaseMetricsClient}: `BUILD_APP_NAME` or `unknown-app`.\n   * @param {string} [opts.processType] Redis key segment (default **`web`**, same as {@link HttpMetricsRedisCollector}).\n   * @param {number} [opts.ttlSec] Redis hash key TTL in seconds (sliding; default 120).\n   */\n  constructor({ redisClient, appName, processType = 'web', ttlSec } = {}) {\n    if (redisClient == null) {\n      throw new Error('HttpMetricsRedisRecorder: redisClient is required')\n    }\n    const resolvedAppName =\n      appName || process.env.BUILD_APP_NAME || 'unknown-app'\n    this.processType = processType\n    this.appName = resolvedAppName\n    this._store = new HttpMetricsRedisStore({\n      redisClient,\n      appName: resolvedAppName,\n      processType,\n      ttlSec,\n    })\n  }\n\n  /**\n   * @param {Object} params\n   * @param {string} params.method\n   * @param {string} params.route\n   * @param {number} params.status_code\n   * @param {number} params.duration\n   */\n  trackHttpRequest({ method, route, status_code, duration }) {\n    this._store.record(method, route, status_code, duration)\n  }\n\n  /**\n   * Express middleware: appends a `finish` listener and writes one aggregate row per request to Redis.\n   * Does not check `METRICS_ENABLED`; the app should only mount this when HTTP Redis metrics should run.\n   *\n   * @param {import('http').IncomingMessage} req\n   * @param {import('http').ServerResponse} res\n   * @param {function} next\n   */\n  trackHttpRequestMiddleware = (req, res, next) => {\n    if (req.method === 'OPTIONS') {\n      next()\n      return\n    }\n\n    const start = Date.now()\n    res.on('finish', () => {\n      const route = req.route?.path || req.path || 'unknown'\n\n      this.trackHttpRequest({\n        method: req.method,\n        route,\n        status_code: res.statusCode,\n        duration: Date.now() - start,\n      })\n    })\n\n    next()\n  }\n}\n\nmodule.exports = { HttpMetricsRedisRecorder }\n"],"mappings":";;AAAA,MAAM;EAAEA;AAAsB,CAAC,GAAGC,OAAO,CAAC,yBAAyB,CAAC;;AAEpE;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,wBAAwB,CAAC;EAC7B;AACF;AACA;AACA;AACA;AACA;AACA;EACEC,WAAWA,CAAC;IAAEC,WAAW;IAAEC,OAAO;IAAEC,WAAW,GAAG,KAAK;IAAEC;EAAO,CAAC,GAAG,CAAC,CAAC,EAAE;IACtE,IAAIH,WAAW,IAAI,IAAI,EAAE;MACvB,MAAM,IAAII,KAAK,CAAC,mDAAmD,CAAC;IACtE;IACA,MAAMC,eAAe,GACnBJ,OAAO,IAAIK,OAAO,CAACC,GAAG,CAACC,cAAc,IAAI,aAAa;IACxD,IAAI,CAACN,WAAW,GAAGA,WAAW;IAC9B,IAAI,CAACD,OAAO,GAAGI,eAAe;IAC9B,IAAI,CAACI,MAAM,GAAG,IAAIb,qBAAqB,CAAC;MACtCI,WAAW;MACXC,OAAO,EAAEI,eAAe;MACxBH,WAAW;MACXC;IACF,CAAC,CAAC;EACJ;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EACEO,gBAAgBA,CAAC;IAAEC,MAAM;IAAEC,KAAK;IAAEC,WAAW;IAAEC;EAAS,CAAC,EAAE;IACzD,IAAI,CAACL,MAAM,CAACM,MAAM,CAACJ,MAAM,EAAEC,KAAK,EAAEC,WAAW,EAAEC,QAAQ,CAAC;EAC1D;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,0BAA0B,GAAGA,CAACC,GAAG,EAAEC,GAAG,EAAEC,IAAI,KAAK;IAC/C,IAAIF,GAAG,CAACN,MAAM,KAAK,SAAS,EAAE;MAC5BQ,IAAI,CAAC,CAAC;MACN;IACF;IAEA,MAAMC,KAAK,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC;IACxBJ,GAAG,CAACK,EAAE,CAAC,QAAQ,EAAE,MAAM;MACrB,MAAMX,KAAK,GAAGK,GAAG,CAACL,KAAK,EAAEY,IAAI,IAAIP,GAAG,CAACO,IAAI,IAAI,SAAS;MAEtD,IAAI,CAACd,gBAAgB,CAAC;QACpBC,MAAM,EAAEM,GAAG,CAACN,MAAM;QAClBC,KAAK;QACLC,WAAW,EAAEK,GAAG,CAACO,UAAU;QAC3BX,QAAQ,EAAEO,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGF;MACzB,CAAC,CAAC;IACJ,CAAC,CAAC;IAEFD,IAAI,CAAC,CAAC;EACR,CAAC;AACH;AAEAO,MAAM,CAACC,OAAO,GAAG;EAAE7B;AAAyB,CAAC","ignoreList":[]}

package/lib/metrics/httpMetricsRedisStore.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Redis HTTP aggregate store. Uses an **injected** client (same pattern as {@link RedisMetricsClient}).
+ * Expects `redis` v3-style API: `multi().hincrby().expire().exec(cb)`, `eval`.
+ *
+ * **Structure:** `countKey` / `durKey` are each **one Redis hash**. Each **field name** encodes
+ * `(method, route, status_code)`. Values: `:count` is HINCRBY 1 per request; `:dur` is summed ms.
+ */
+export class HttpMetricsRedisStore {
+    /**
+     * @param {Object} opts
+     * @param {import('redis').RedisClient} opts.redisClient
+     * @param {string} opts.appName BUILD_APP_NAME (key segment)
+     * @param {string} opts.processType logical process for key (e.g. web)
+     * @param {number} [opts.ttlSec] Expire keys after this many seconds (default 120)
+     */
+    constructor({ redisClient, appName, processType, ttlSec }: {
+        redisClient: import('redis').RedisClient;
+        appName: string;
+        processType: string;
+        ttlSec?: number | undefined;
+    });
+    _client: import("redis").RedisClient;
+    ttlSec: number;
+    countKey: string;
+    durKey: string;
+    /**
+     * @returns {import('redis').RedisClient}
+     * @private
+     */
+    private _ensureClient;
+    /**
+     * @param {string} method
+     * @param {string} route
+     * @param {number} statusCode
+     * @param {number} durationMs
+     */
+    record(method: string, route: string, statusCode: number, durationMs: number): void;
+    /**
+     * Atomically drain Redis hashes (same Lua as `flushToCounters`) and return parsed rows.
+     *
+     * @returns {Promise<{ ok: boolean, rows: { labels: Object, count: number, dur: number }[] }>}
+     */
+    drainRows(): Promise<{
+        ok: boolean;
+        rows: {
+            labels: Object;
+            count: number;
+            dur: number;
+        }[];
+    }>;
+    /**
+     * @param {(labels: Object, value: number) => void} applyCount
+     * @param {(labels: Object, value: number) => void} applyDuration
+     * @returns {Promise<boolean>}
+     */
+    flushToCounters(applyCount: (labels: Object, value: number) => void, applyDuration: (labels: Object, value: number) => void): Promise<boolean>;
+}
+/**
+ * @param {string} method
+ * @param {string} route
+ * @param {number} statusCode
+ * @returns {string}
+ */
+export function buildFieldKey(method: string, route: string, statusCode: number): string;
+/**
+ * Record separator for hash fields (avoids collisions when route contains "|").
+ * @type {string}
+ */
+export const FIELD_SEP: string;
+/**
+ * Default Redis key TTL in seconds (sliding: refreshed on each `record` write).
+ * @type {number}
+ */
+export const DEFAULT_HTTP_METRICS_REDIS_TTL_SEC: number;
+/**
+ * @param {unknown} raw redis eval result [countPairs, durPairs]
+ * @returns {{ labels: { method: string, route: string, status_code: string }, count: number, dur: number }[]}
+ */
+export function rowsFromDrainRaw(raw: unknown): {
+    labels: {
+        method: string;
+        route: string;
+        status_code: string;
+    };
+    count: number;
+    dur: number;
+}[];
+//# sourceMappingURL=httpMetricsRedisStore.d.ts.map

package/lib/metrics/httpMetricsRedisStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpMetricsRedisStore.d.ts","sourceRoot":"","sources":["../../src/metrics/httpMetricsRedisStore.js"],"names":[],"mappings":"AA6EA;;;;;;GAMG;AACH;IACE;;;;;;OAMG;IACH;QAL6C,WAAW,EAA7C,OAAO,OAAO,EAAE,WAAW;QACd,OAAO,EAApB,MAAM;QACO,WAAW,EAAxB,MAAM;QACQ,MAAM;OAgB9B;IAVC,qCAA0B;IAC1B,eAGwC;IAIxC,iBAAiD;IACjD,eAA6C;IAG/C;;;OAGG;IACH,sBAEC;IAED;;;;;OAKG;IACH,eALW,MAAM,SACN,MAAM,cACN,MAAM,cACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,aAFa,QAAQ;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,CAAC,CAgC5F;IAED;;;;OAIG;IACH,qCAJoB,MAAM,SAAS,MAAM,KAAK,IAAI,0BAC9B,MAAM,SAAS,MAAM,KAAK,IAAI,GACrC,QAAQ,OAAO,CAAC,CAe5B;CACF;AAlLD;;;;;GAKG;AACH,sCALW,MAAM,SACN,MAAM,cACN,MAAM,GACJ,MAAM,CAIlB;AA7BD;;;GAGG;AACH,wBAFU,MAAM,CAEQ;AAExB;;;GAGG;AACH,iDAFU,MAAM,CAE8B;AAgC9C;;;GAGG;AACH,sCAHW,OAAO,GACL;IAAE,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,CA+B5G"}

package/lib/metrics/httpMetricsRedisStore.js

@@ -0,0 +1,223 @@
+"use strict";
+
+/**
+ * Record separator for hash fields (avoids collisions when route contains "|").
+ * @type {string}
+ */
+const FIELD_SEP = '\x1e';
+
+/**
+ * Default Redis key TTL in seconds (sliding: refreshed on each `record` write).
+ * @type {number}
+ */
+const DEFAULT_HTTP_METRICS_REDIS_TTL_SEC = 120;
+const DRAIN_LUA = `
+local function drain(key)
+  local v = redis.call('HGETALL', key)
+  redis.call('DEL', key)
+  return v
+end
+return {drain(KEYS[1]), drain(KEYS[2])}
+`;
+
+/**
+ * @param {string} method
+ * @param {string} route
+ * @param {number} statusCode
+ * @returns {string}
+ */
+function buildFieldKey(method, route, statusCode) {
+  return [method, route, String(statusCode)].join(FIELD_SEP);
+}
+function hgetallPairsToObject(pairs) {
+  const o = {};
+  if (!pairs || !pairs.length) {
+    return o;
+  }
+  for (let i = 0; i < pairs.length; i += 2) {
+    o[pairs[i]] = pairs[i + 1];
+  }
+  return o;
+}
+
+/**
+ * @param {unknown} raw redis eval result [countPairs, durPairs]
+ * @returns {{ labels: { method: string, route: string, status_code: string }, count: number, dur: number }[]}
+ */
+function rowsFromDrainRaw(raw) {
+  const rows = [];
+  if (!raw || !Array.isArray(raw) || raw.length < 2) {
+    return rows;
+  }
+  const counts = hgetallPairsToObject(raw[0]);
+  const durs = hgetallPairsToObject(raw[1]);
+  const fieldKeys = Object.keys(counts);
+  for (const field of fieldKeys) {
+    const count = parseInt(counts[field], 10);
+    if (!count || count < 1) {
+      continue;
+    }
+    const dur = parseInt(durs[field] || '0', 10) || 0;
+    const parts = field.split(FIELD_SEP);
+    let labels = null;
+    if (parts.length === 3) {
+      const [m, route, statusStr] = parts;
+      labels = {
+        method: m,
+        route,
+        status_code: statusStr
+      };
+    } else if (parts.length === 5 || parts.length === 6) {
+      const [m, route, statusStr] = parts;
+      labels = {
+        method: m,
+        route,
+        status_code: statusStr
+      };
+    }
+    if (!labels) {
+      continue;
+    }
+    rows.push({
+      labels,
+      count,
+      dur
+    });
+  }
+  return rows;
+}
+
+/**
+ * Redis HTTP aggregate store. Uses an **injected** client (same pattern as {@link RedisMetricsClient}).
+ * Expects `redis` v3-style API: `multi().hincrby().expire().exec(cb)`, `eval`.
+ *
+ * **Structure:** `countKey` / `durKey` are each **one Redis hash**. Each **field name** encodes
+ * `(method, route, status_code)`. Values: `:count` is HINCRBY 1 per request; `:dur` is summed ms.
+ */
+class HttpMetricsRedisStore {
+  /**
+   * @param {Object} opts
+   * @param {import('redis').RedisClient} opts.redisClient
+   * @param {string} opts.appName BUILD_APP_NAME (key segment)
+   * @param {string} opts.processType logical process for key (e.g. web)
+   * @param {number} [opts.ttlSec] Expire keys after this many seconds (default 120)
+   */
+  constructor({
+    redisClient,
+    appName,
+    processType,
+    ttlSec
+  }) {
+    if (redisClient == null) {
+      throw new Error('HttpMetricsRedisStore: redisClient is required');
+    }
+    this._client = redisClient;
+    this.ttlSec = typeof ttlSec === 'number' && ttlSec > 0 ? ttlSec : DEFAULT_HTTP_METRICS_REDIS_TTL_SEC;
+    const keySeg = `${encodeURIComponent(appName)}:${encodeURIComponent(processType)}`;
+    this.countKey = `metrics:http:v2:${keySeg}:count`;
+    this.durKey = `metrics:http:v2:${keySeg}:dur`;
+  }
+
+  /**
+   * @returns {import('redis').RedisClient}
+   * @private
+   */
+  _ensureClient() {
+    return this._client;
+  }
+
+  /**
+   * @param {string} method
+   * @param {string} route
+   * @param {number} statusCode
+   * @param {number} durationMs
+   */
+  record(method, route, statusCode, durationMs) {
+    try {
+      const client = this._ensureClient();
+      const field = buildFieldKey(method, route, statusCode);
+      const dur = Math.max(0, Math.round(Number(durationMs) || 0));
+      client.multi().hincrby(this.countKey, field, 1).hincrby(this.durKey, field, dur).expire(this.countKey, this.ttlSec).expire(this.durKey, this.ttlSec).exec(err => {
+        if (err) {
+          console.error('[HttpMetricsRedisStore] record failed:', err.message);
+        }
+      });
+    } catch (e) {
+      console.error('[HttpMetricsRedisStore] record:', e.message);
+    }
+  }
+
+  /**
+   * Atomically drain Redis hashes (same Lua as `flushToCounters`) and return parsed rows.
+   *
+   * @returns {Promise<{ ok: boolean, rows: { labels: Object, count: number, dur: number }[] }>}
+   */
+  drainRows() {
+    let client;
+    try {
+      client = this._ensureClient();
+    } catch (e) {
+      console.error('[HttpMetricsRedisStore] drainRows:', e.message);
+      return Promise.resolve({
+        ok: false,
+        rows: []
+      });
+    }
+    return new Promise(resolve => {
+      client.eval(DRAIN_LUA, 2, this.countKey, this.durKey, (evalErr, raw) => {
+        if (evalErr) {
+          console.error('[HttpMetricsRedisStore] drain failed:', evalErr.message);
+          resolve({
+            ok: false,
+            rows: []
+          });
+          return;
+        }
+        try {
+          const rows = rowsFromDrainRaw(raw);
+          resolve({
+            ok: true,
+            rows
+          });
+        } catch (e) {
+          console.error('[HttpMetricsRedisStore] drainRows parse failed:', e.message);
+          resolve({
+            ok: false,
+            rows: []
+          });
+        }
+      });
+    });
+  }
+
+  /**
+   * @param {(labels: Object, value: number) => void} applyCount
+   * @param {(labels: Object, value: number) => void} applyDuration
+   * @returns {Promise<boolean>}
+   */
+  flushToCounters(applyCount, applyDuration) {
+    return this.drainRows().then(({
+      ok,
+      rows
+    }) => {
+      if (!ok) {
+        return false;
+      }
+      for (const row of rows) {
+        applyCount(row.labels, row.count);
+        if (row.dur > 0) {
+          applyDuration(row.labels, row.dur);
+        }
+      }
+      return true;
+    });
+  }
+}
+module.exports = {
+  HttpMetricsRedisStore,
+  buildFieldKey,
+  FIELD_SEP,
+  DEFAULT_HTTP_METRICS_REDIS_TTL_SEC,
+  rowsFromDrainRaw
+};
+//# sourceMappingURL=httpMetricsRedisStore.js.map

package/lib/metrics/httpMetricsRedisStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpMetricsRedisStore.js","names":["FIELD_SEP","DEFAULT_HTTP_METRICS_REDIS_TTL_SEC","DRAIN_LUA","buildFieldKey","method","route","statusCode","String","join","hgetallPairsToObject","pairs","o","length","i","rowsFromDrainRaw","raw","rows","Array","isArray","counts","durs","fieldKeys","Object","keys","field","count","parseInt","dur","parts","split","labels","m","statusStr","status_code","push","HttpMetricsRedisStore","constructor","redisClient","appName","processType","ttlSec","Error","_client","keySeg","encodeURIComponent","countKey","durKey","_ensureClient","record","durationMs","client","Math","max","round","Number","multi","hincrby","expire","exec","err","console","error","message","e","drainRows","Promise","resolve","ok","eval","evalErr","flushToCounters","applyCount","applyDuration","then","row","module","exports"],"sources":["../../src/metrics/httpMetricsRedisStore.js"],"sourcesContent":["/**\n * Record separator for hash fields (avoids collisions when route contains \"|\").\n * @type {string}\n */\nconst FIELD_SEP = '\\x1e'\n\n/**\n * Default Redis key TTL in seconds (sliding: refreshed on each `record` write).\n * @type {number}\n */\nconst DEFAULT_HTTP_METRICS_REDIS_TTL_SEC = 120\n\nconst DRAIN_LUA = `\nlocal function drain(key)\n  local v = redis.call('HGETALL', key)\n  redis.call('DEL', key)\n  return v\nend\nreturn {drain(KEYS[1]), drain(KEYS[2])}\n`\n\n/**\n * @param {string} method\n * @param {string} route\n * @param {number} statusCode\n * @returns {string}\n */\nfunction buildFieldKey(method, route, statusCode) {\n  return [method, route, String(statusCode)].join(FIELD_SEP)\n}\n\nfunction hgetallPairsToObject(pairs) {\n  const o = {}\n  if (!pairs || !pairs.length) {\n    return o\n  }\n  for (let i = 0; i < pairs.length; i += 2) {\n    o[pairs[i]] = pairs[i + 1]\n  }\n  return o\n}\n\n/**\n * @param {unknown} raw redis eval result [countPairs, durPairs]\n * @returns {{ labels: { method: string, route: string, status_code: string }, count: number, dur: number }[]}\n */\nfunction rowsFromDrainRaw(raw) {\n  const rows = []\n  if (!raw || !Array.isArray(raw) || raw.length < 2) {\n    return rows\n  }\n  const counts = hgetallPairsToObject(raw[0])\n  const durs = hgetallPairsToObject(raw[1])\n  const fieldKeys = Object.keys(counts)\n  for (const field of fieldKeys) {\n    const count = parseInt(counts[field], 10)\n    if (!count || count < 1) {\n      continue\n    }\n    const dur = parseInt(durs[field] || '0', 10) || 0\n    const parts = field.split(FIELD_SEP)\n    let labels = null\n    if (parts.length === 3) {\n      const [m, route, statusStr] = parts\n      labels = { method: m, route, status_code: statusStr }\n    } else if (parts.length === 5 || parts.length === 6) {\n      const [m, route, statusStr] = parts\n      labels = { method: m, route, status_code: statusStr }\n    }\n    if (!labels) {\n      continue\n    }\n    rows.push({ labels, count, dur })\n  }\n  return rows\n}\n\n/**\n * Redis HTTP aggregate store. Uses an **injected** client (same pattern as {@link RedisMetricsClient}).\n * Expects `redis` v3-style API: `multi().hincrby().expire().exec(cb)`, `eval`.\n *\n * **Structure:** `countKey` / `durKey` are each **one Redis hash**. Each **field name** encodes\n * `(method, route, status_code)`. Values: `:count` is HINCRBY 1 per request; `:dur` is summed ms.\n */\nclass HttpMetricsRedisStore {\n  /**\n   * @param {Object} opts\n   * @param {import('redis').RedisClient} opts.redisClient\n   * @param {string} opts.appName BUILD_APP_NAME (key segment)\n   * @param {string} opts.processType logical process for key (e.g. web)\n   * @param {number} [opts.ttlSec] Expire keys after this many seconds (default 120)\n   */\n  constructor({ redisClient, appName, processType, ttlSec }) {\n    if (redisClient == null) {\n      throw new Error('HttpMetricsRedisStore: redisClient is required')\n    }\n    this._client = redisClient\n    this.ttlSec =\n      typeof ttlSec === 'number' && ttlSec > 0\n        ? ttlSec\n        : DEFAULT_HTTP_METRICS_REDIS_TTL_SEC\n    const keySeg = `${encodeURIComponent(appName)}:${encodeURIComponent(\n      processType\n    )}`\n    this.countKey = `metrics:http:v2:${keySeg}:count`\n    this.durKey = `metrics:http:v2:${keySeg}:dur`\n  }\n\n  /**\n   * @returns {import('redis').RedisClient}\n   * @private\n   */\n  _ensureClient() {\n    return this._client\n  }\n\n  /**\n   * @param {string} method\n   * @param {string} route\n   * @param {number} statusCode\n   * @param {number} durationMs\n   */\n  record(method, route, statusCode, durationMs) {\n    try {\n      const client = this._ensureClient()\n      const field = buildFieldKey(method, route, statusCode)\n      const dur = Math.max(0, Math.round(Number(durationMs) || 0))\n      client\n        .multi()\n        .hincrby(this.countKey, field, 1)\n        .hincrby(this.durKey, field, dur)\n        .expire(this.countKey, this.ttlSec)\n        .expire(this.durKey, this.ttlSec)\n        .exec(err => {\n          if (err) {\n            console.error('[HttpMetricsRedisStore] record failed:', err.message)\n          }\n        })\n    } catch (e) {\n      console.error('[HttpMetricsRedisStore] record:', e.message)\n    }\n  }\n\n  /**\n   * Atomically drain Redis hashes (same Lua as `flushToCounters`) and return parsed rows.\n   *\n   * @returns {Promise<{ ok: boolean, rows: { labels: Object, count: number, dur: number }[] }>}\n   */\n  drainRows() {\n    let client\n    try {\n      client = this._ensureClient()\n    } catch (e) {\n      console.error('[HttpMetricsRedisStore] drainRows:', e.message)\n      return Promise.resolve({ ok: false, rows: [] })\n    }\n    return new Promise(resolve => {\n      client.eval(DRAIN_LUA, 2, this.countKey, this.durKey, (evalErr, raw) => {\n        if (evalErr) {\n          console.error(\n            '[HttpMetricsRedisStore] drain failed:',\n            evalErr.message\n          )\n          resolve({ ok: false, rows: [] })\n          return\n        }\n        try {\n          const rows = rowsFromDrainRaw(raw)\n          resolve({ ok: true, rows })\n        } catch (e) {\n          console.error(\n            '[HttpMetricsRedisStore] drainRows parse failed:',\n            e.message\n          )\n          resolve({ ok: false, rows: [] })\n        }\n      })\n    })\n  }\n\n  /**\n   * @param {(labels: Object, value: number) => void} applyCount\n   * @param {(labels: Object, value: number) => void} applyDuration\n   * @returns {Promise<boolean>}\n   */\n  flushToCounters(applyCount, applyDuration) {\n    return this.drainRows().then(({ ok, rows }) => {\n      if (!ok) {\n        return false\n      }\n      for (const row of rows) {\n        applyCount(row.labels, row.count)\n        if (row.dur > 0) {\n          applyDuration(row.labels, row.dur)\n        }\n      }\n      return true\n    })\n  }\n}\n\nmodule.exports = {\n  HttpMetricsRedisStore,\n  buildFieldKey,\n  FIELD_SEP,\n  DEFAULT_HTTP_METRICS_REDIS_TTL_SEC,\n  rowsFromDrainRaw,\n}\n"],"mappings":"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","ignoreList":[]}