@adalo/metrics 0.1.175 → 0.1.176

package/lib/metrics/metricsProcessTypeUtils.d.ts

@@ -8,35 +8,43 @@
 export function resolveMetricsProcessType(metricsConfig: {
     processType?: string;
 }, defaultProcessType: string): string;
+/**
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
+ * @returns {boolean}
+ */
+export function shouldEnforceProcessType(metricsConfig: {
+    processType?: string;
+    enabled?: boolean;
+}): boolean;
 /**
  * Exit with no logs if the resolved process type is not exactly `expectedProcessType`.
+ * No-op when `METRICS_ENABLED` is not `true` (avoids exit/restart loops when metrics are off).
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {string} expectedProcessType - Single allowed value (use a module constant, e.g. {@link METRICS_PROCESS_TYPE_DATABASE})
  * @returns {void}
  */
 export function exitUnlessProcessTypeIs(metricsConfig: {
     processType?: string;
+    enabled?: boolean;
 }, expectedProcessType: string): void;
 /**
  * Exit with no logs if the resolved process type is not in `allowedProcessTypes`.
+ * No-op when `METRICS_ENABLED` is not `true`.
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {readonly string[]} allowedProcessTypes
  * @param {string} defaultWhenUnspecified - Used only to resolve when config/env omit `processType` (e.g. {@link METRICS_PROCESS_TYPE_QUEUE} for {@link RedisMetricsClient})
  * @returns {void}
  */
 export function exitUnlessProcessTypeIn(metricsConfig: {
     processType?: string;
+    enabled?: boolean;
 }, allowedProcessTypes: readonly string[], defaultWhenUnspecified: string): void;
 /**
- * Helpers for resolving `processType` and silently exiting when a specialized metrics client
- * is constructed on the wrong dyno / process (no log output).
- *
- * **Canonical names** align with typical Procfile processes (e.g. backend: `web`, `worker`,
- * `queue-metrics`, `database-metrics`, `http-metrics`). The compile **worker** dyno serves queues/builds
- * — it does not run HTTP request metrics. HTTP Redis **key segment** for API traffic is fixed **`web`**
- * (`HttpMetricsRedisCollector` / `HttpMetricsRedisRecorder`), not `BUILD_DYNO_PROCESS_TYPE`.
+ * Helpers for resolving `processType` and optional silent exit when a specialized metrics client
+ * is constructed on the wrong dyno (no log output). If `METRICS_ENABLED` is not `true`, the check
+ * is skipped so the process is not stopped.
  *
  * @module metrics/metricsProcessTypeUtils
  */

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

@@ -1 +1 @@
-{"version":3,"file":"metricsProcessTypeUtils.d.ts","sourceRoot":"","sources":["../../src/metrics/metricsProcessTypeUtils.js"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,yDAJW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,sBACxB,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;GAMG;AACH,uDAJW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,uBACxB,MAAM,GACJ,IAAI,CAOhB;AAED;;;;;;;GAOG;AACH,uDALW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,uBACxB,SAAS,MAAM,EAAE,0BACjB,MAAM,GACJ,IAAI,CAchB;AArFD;;;;;;;;;;GAUG;AAEH,6DAA6D;AAC7D,+DAAwD;AAExD,gEAAgE;AAChE,yDAAkD;AAElD,yEAAyE;AACzE,yDAAkD;AAElD,kGAAkG;AAClG,6CAAsC;AAEtC,gGAAgG;AAChG,mDAA4C;AAE5C;;;GAGG;AACH,yDAFU,SAAS,MAAM,EAAE,CAKzB"}
+{"version":3,"file":"metricsProcessTypeUtils.d.ts","sourceRoot":"","sources":["../../src/metrics/metricsProcessTypeUtils.js"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,yDAJW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,sBACxB,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH,wDAHW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GACzC,OAAO,CAMnB;AAED;;;;;;;GAOG;AACH,uDAJW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,uBAC3C,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;GAQG;AACH,uDALW;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,uBAC3C,SAAS,MAAM,EAAE,0BACjB,MAAM,GACJ,IAAI,CAehB;AA/FD;;;;;;GAMG;AAEH,6DAA6D;AAC7D,+DAAwD;AAExD,gEAAgE;AAChE,yDAAkD;AAElD,yEAAyE;AACzE,yDAAkD;AAElD,kGAAkG;AAClG,6CAAsC;AAEtC,gGAAgG;AAChG,mDAA4C;AAE5C;;;GAGG;AACH,yDAFU,SAAS,MAAM,EAAE,CAKzB"}

package/lib/metrics/metricsProcessTypeUtils.js

@@ -1,13 +1,9 @@
 "use strict";
 
 /**
- * Helpers for resolving `processType` and silently exiting when a specialized metrics client
- * is constructed on the wrong dyno / process (no log output).
- *
- * **Canonical names** align with typical Procfile processes (e.g. backend: `web`, `worker`,
- * `queue-metrics`, `database-metrics`, `http-metrics`). The compile **worker** dyno serves queues/builds
- * — it does not run HTTP request metrics. HTTP Redis **key segment** for API traffic is fixed **`web`**
- * (`HttpMetricsRedisCollector` / `HttpMetricsRedisRecorder`), not `BUILD_DYNO_PROCESS_TYPE`.
+ * Helpers for resolving `processType` and optional silent exit when a specialized metrics client
+ * is constructed on the wrong dyno (no log output). If `METRICS_ENABLED` is not `true`, the check
+ * is skipped so the process is not stopped.
  *
  * @module metrics/metricsProcessTypeUtils
  */
@@ -44,14 +40,24 @@ function resolveMetricsProcessType(metricsConfig, defaultProcessType) {
   return metricsConfig.processType || process.env.BUILD_DYNO_PROCESS_TYPE || defaultProcessType;
 }
 
+/**
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
+ * @returns {boolean}
+ */
+function shouldEnforceProcessType(metricsConfig) {
+  return (metricsConfig.enabled ?? process.env.METRICS_ENABLED === 'true') === true;
+}
+
 /**
  * Exit with no logs if the resolved process type is not exactly `expectedProcessType`.
+ * No-op when `METRICS_ENABLED` is not `true` (avoids exit/restart loops when metrics are off).
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {string} expectedProcessType - Single allowed value (use a module constant, e.g. {@link METRICS_PROCESS_TYPE_DATABASE})
  * @returns {void}
  */
 function exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {
+  if (!shouldEnforceProcessType(metricsConfig)) return;
   const resolved = resolveMetricsProcessType(metricsConfig, expectedProcessType);
   if (resolved !== expectedProcessType) {
     process.exit(0);
@@ -60,13 +66,15 @@ function exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {
 
 /**
  * Exit with no logs if the resolved process type is not in `allowedProcessTypes`.
+ * No-op when `METRICS_ENABLED` is not `true`.
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {readonly string[]} allowedProcessTypes
  * @param {string} defaultWhenUnspecified - Used only to resolve when config/env omit `processType` (e.g. {@link METRICS_PROCESS_TYPE_QUEUE} for {@link RedisMetricsClient})
  * @returns {void}
  */
 function exitUnlessProcessTypeIn(metricsConfig, allowedProcessTypes, defaultWhenUnspecified) {
+  if (!shouldEnforceProcessType(metricsConfig)) return;
   const resolved = resolveMetricsProcessType(metricsConfig, defaultWhenUnspecified);
   if (!allowedProcessTypes.includes(resolved)) {
     process.exit(0);
@@ -74,6 +82,7 @@ function exitUnlessProcessTypeIn(metricsConfig, allowedProcessTypes, defaultWhen
 }
 module.exports = {
   resolveMetricsProcessType,
+  shouldEnforceProcessType,
   exitUnlessProcessTypeIs,
   exitUnlessProcessTypeIn,
   METRICS_PROCESS_TYPE_DATABASE,

package/lib/metrics/metricsProcessTypeUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"metricsProcessTypeUtils.js","names":["METRICS_PROCESS_TYPE_DATABASE","METRICS_PROCESS_TYPE_QUEUE","METRICS_PROCESS_TYPE_REDIS","METRICS_PROCESS_TYPE_WEB","METRICS_PROCESS_TYPE_WORKER","REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES","Object","freeze","resolveMetricsProcessType","metricsConfig","defaultProcessType","processType","process","env","BUILD_DYNO_PROCESS_TYPE","exitUnlessProcessTypeIs","expectedProcessType","resolved","exit","exitUnlessProcessTypeIn","allowedProcessTypes","defaultWhenUnspecified","includes","module","exports"],"sources":["../../src/metrics/metricsProcessTypeUtils.js"],"sourcesContent":["/**\n * Helpers for resolving `processType` and silently exiting when a specialized metrics client\n * is constructed on the wrong dyno / process (no log output).\n *\n * **Canonical names** align with typical Procfile processes (e.g. backend: `web`, `worker`,\n * `queue-metrics`, `database-metrics`, `http-metrics`). The compile **worker** dyno serves queues/builds\n * — it does not run HTTP request metrics. HTTP Redis **key segment** for API traffic is fixed **`web`**\n * (`HttpMetricsRedisCollector` / `HttpMetricsRedisRecorder`), not `BUILD_DYNO_PROCESS_TYPE`.\n *\n * @module metrics/metricsProcessTypeUtils\n */\n\n/** DB-only metrics dyno (`database-metrics` in Procfile). */\nconst METRICS_PROCESS_TYPE_DATABASE = 'database-metrics'\n\n/** Queue + Redis metrics dyno (`queue-metrics` in Procfile). */\nconst METRICS_PROCESS_TYPE_QUEUE = 'queue-metrics'\n\n/** Redis-only metrics dyno (no Bee Queue; optional separate process). */\nconst METRICS_PROCESS_TYPE_REDIS = 'redis-metrics'\n\n/** Web servers — HTTP traffic, HTTP Redis **writers** typically use this in Redis key segment. */\nconst METRICS_PROCESS_TYPE_WEB = 'web'\n\n/** Build/compile workers and similar (e.g. backend `worker:`) — no HTTP server metrics here. */\nconst METRICS_PROCESS_TYPE_WORKER = 'worker'\n\n/**\n * Parent {@link RedisMetricsClient} allows either redis-only or queue stack (`QueueRedisMetricsClient`).\n * @type {readonly string[]}\n */\nconst REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES = Object.freeze([\n  METRICS_PROCESS_TYPE_REDIS,\n  METRICS_PROCESS_TYPE_QUEUE,\n])\n\n/**\n * Resolve logical process type the same way specialized metrics clients do.\n *\n * @param {{ processType?: string }} metricsConfig - Remainder of constructor options (e.g. after destructuring `redisClient`, `databaseUrl`, …)\n * @param {string} defaultProcessType - Fallback when `metricsConfig.processType` and `BUILD_DYNO_PROCESS_TYPE` are unset\n * @returns {string}\n */\nfunction resolveMetricsProcessType(metricsConfig, defaultProcessType) {\n  return (\n    metricsConfig.processType ||\n    process.env.BUILD_DYNO_PROCESS_TYPE ||\n    defaultProcessType\n  )\n}\n\n/**\n * Exit with no logs if the resolved process type is not exactly `expectedProcessType`.\n *\n * @param {{ processType?: string }} metricsConfig\n * @param {string} expectedProcessType - Single allowed value (use a module constant, e.g. {@link METRICS_PROCESS_TYPE_DATABASE})\n * @returns {void}\n */\nfunction exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {\n  const resolved = resolveMetricsProcessType(metricsConfig, expectedProcessType)\n  if (resolved !== expectedProcessType) {\n    process.exit(0)\n  }\n}\n\n/**\n * Exit with no logs if the resolved process type is not in `allowedProcessTypes`.\n *\n * @param {{ processType?: string }} metricsConfig\n * @param {readonly string[]} allowedProcessTypes\n * @param {string} defaultWhenUnspecified - Used only to resolve when config/env omit `processType` (e.g. {@link METRICS_PROCESS_TYPE_QUEUE} for {@link RedisMetricsClient})\n * @returns {void}\n */\nfunction exitUnlessProcessTypeIn(\n  metricsConfig,\n  allowedProcessTypes,\n  defaultWhenUnspecified\n) {\n  const resolved = resolveMetricsProcessType(\n    metricsConfig,\n    defaultWhenUnspecified\n  )\n  if (!allowedProcessTypes.includes(resolved)) {\n    process.exit(0)\n  }\n}\n\nmodule.exports = {\n  resolveMetricsProcessType,\n  exitUnlessProcessTypeIs,\n  exitUnlessProcessTypeIn,\n  METRICS_PROCESS_TYPE_DATABASE,\n  METRICS_PROCESS_TYPE_QUEUE,\n  METRICS_PROCESS_TYPE_REDIS,\n  METRICS_PROCESS_TYPE_WEB,\n  METRICS_PROCESS_TYPE_WORKER,\n  REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES,\n}\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAMA,6BAA6B,GAAG,kBAAkB;;AAExD;AACA,MAAMC,0BAA0B,GAAG,eAAe;;AAElD;AACA,MAAMC,0BAA0B,GAAG,eAAe;;AAElD;AACA,MAAMC,wBAAwB,GAAG,KAAK;;AAEtC;AACA,MAAMC,2BAA2B,GAAG,QAAQ;;AAE5C;AACA;AACA;AACA;AACA,MAAMC,0CAA0C,GAAGC,MAAM,CAACC,MAAM,CAAC,CAC/DL,0BAA0B,EAC1BD,0BAA0B,CAC3B,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASO,yBAAyBA,CAACC,aAAa,EAAEC,kBAAkB,EAAE;EACpE,OACED,aAAa,CAACE,WAAW,IACzBC,OAAO,CAACC,GAAG,CAACC,uBAAuB,IACnCJ,kBAAkB;AAEtB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASK,uBAAuBA,CAACN,aAAa,EAAEO,mBAAmB,EAAE;EACnE,MAAMC,QAAQ,GAAGT,yBAAyB,CAACC,aAAa,EAAEO,mBAAmB,CAAC;EAC9E,IAAIC,QAAQ,KAAKD,mBAAmB,EAAE;IACpCJ,OAAO,CAACM,IAAI,CAAC,CAAC,CAAC;EACjB;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,uBAAuBA,CAC9BV,aAAa,EACbW,mBAAmB,EACnBC,sBAAsB,EACtB;EACA,MAAMJ,QAAQ,GAAGT,yBAAyB,CACxCC,aAAa,EACbY,sBACF,CAAC;EACD,IAAI,CAACD,mBAAmB,CAACE,QAAQ,CAACL,QAAQ,CAAC,EAAE;IAC3CL,OAAO,CAACM,IAAI,CAAC,CAAC,CAAC;EACjB;AACF;AAEAK,MAAM,CAACC,OAAO,GAAG;EACfhB,yBAAyB;EACzBO,uBAAuB;EACvBI,uBAAuB;EACvBnB,6BAA6B;EAC7BC,0BAA0B;EAC1BC,0BAA0B;EAC1BC,wBAAwB;EACxBC,2BAA2B;EAC3BC;AACF,CAAC","ignoreList":[]}
+{"version":3,"file":"metricsProcessTypeUtils.js","names":["METRICS_PROCESS_TYPE_DATABASE","METRICS_PROCESS_TYPE_QUEUE","METRICS_PROCESS_TYPE_REDIS","METRICS_PROCESS_TYPE_WEB","METRICS_PROCESS_TYPE_WORKER","REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES","Object","freeze","resolveMetricsProcessType","metricsConfig","defaultProcessType","processType","process","env","BUILD_DYNO_PROCESS_TYPE","shouldEnforceProcessType","enabled","METRICS_ENABLED","exitUnlessProcessTypeIs","expectedProcessType","resolved","exit","exitUnlessProcessTypeIn","allowedProcessTypes","defaultWhenUnspecified","includes","module","exports"],"sources":["../../src/metrics/metricsProcessTypeUtils.js"],"sourcesContent":["/**\n * Helpers for resolving `processType` and optional silent exit when a specialized metrics client\n * is constructed on the wrong dyno (no log output). If `METRICS_ENABLED` is not `true`, the check\n * is skipped so the process is not stopped.\n *\n * @module metrics/metricsProcessTypeUtils\n */\n\n/** DB-only metrics dyno (`database-metrics` in Procfile). */\nconst METRICS_PROCESS_TYPE_DATABASE = 'database-metrics'\n\n/** Queue + Redis metrics dyno (`queue-metrics` in Procfile). */\nconst METRICS_PROCESS_TYPE_QUEUE = 'queue-metrics'\n\n/** Redis-only metrics dyno (no Bee Queue; optional separate process). */\nconst METRICS_PROCESS_TYPE_REDIS = 'redis-metrics'\n\n/** Web servers — HTTP traffic, HTTP Redis **writers** typically use this in Redis key segment. */\nconst METRICS_PROCESS_TYPE_WEB = 'web'\n\n/** Build/compile workers and similar (e.g. backend `worker:`) — no HTTP server metrics here. */\nconst METRICS_PROCESS_TYPE_WORKER = 'worker'\n\n/**\n * Parent {@link RedisMetricsClient} allows either redis-only or queue stack (`QueueRedisMetricsClient`).\n * @type {readonly string[]}\n */\nconst REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES = Object.freeze([\n  METRICS_PROCESS_TYPE_REDIS,\n  METRICS_PROCESS_TYPE_QUEUE,\n])\n\n/**\n * Resolve logical process type the same way specialized metrics clients do.\n *\n * @param {{ processType?: string }} metricsConfig - Remainder of constructor options (e.g. after destructuring `redisClient`, `databaseUrl`, …)\n * @param {string} defaultProcessType - Fallback when `metricsConfig.processType` and `BUILD_DYNO_PROCESS_TYPE` are unset\n * @returns {string}\n */\nfunction resolveMetricsProcessType(metricsConfig, defaultProcessType) {\n  return (\n    metricsConfig.processType ||\n    process.env.BUILD_DYNO_PROCESS_TYPE ||\n    defaultProcessType\n  )\n}\n\n/**\n * @param {{ processType?: string, enabled?: boolean }} metricsConfig\n * @returns {boolean}\n */\nfunction shouldEnforceProcessType(metricsConfig) {\n  return (\n    (metricsConfig.enabled ?? process.env.METRICS_ENABLED === 'true') === true\n  )\n}\n\n/**\n * Exit with no logs if the resolved process type is not exactly `expectedProcessType`.\n * No-op when `METRICS_ENABLED` is not `true` (avoids exit/restart loops when metrics are off).\n *\n * @param {{ processType?: string, enabled?: boolean }} metricsConfig\n * @param {string} expectedProcessType - Single allowed value (use a module constant, e.g. {@link METRICS_PROCESS_TYPE_DATABASE})\n * @returns {void}\n */\nfunction exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {\n  if (!shouldEnforceProcessType(metricsConfig)) return\n  const resolved = resolveMetricsProcessType(metricsConfig, expectedProcessType)\n  if (resolved !== expectedProcessType) {\n    process.exit(0)\n  }\n}\n\n/**\n * Exit with no logs if the resolved process type is not in `allowedProcessTypes`.\n * No-op when `METRICS_ENABLED` is not `true`.\n *\n * @param {{ processType?: string, enabled?: boolean }} metricsConfig\n * @param {readonly string[]} allowedProcessTypes\n * @param {string} defaultWhenUnspecified - Used only to resolve when config/env omit `processType` (e.g. {@link METRICS_PROCESS_TYPE_QUEUE} for {@link RedisMetricsClient})\n * @returns {void}\n */\nfunction exitUnlessProcessTypeIn(\n  metricsConfig,\n  allowedProcessTypes,\n  defaultWhenUnspecified\n) {\n  if (!shouldEnforceProcessType(metricsConfig)) return\n  const resolved = resolveMetricsProcessType(\n    metricsConfig,\n    defaultWhenUnspecified\n  )\n  if (!allowedProcessTypes.includes(resolved)) {\n    process.exit(0)\n  }\n}\n\nmodule.exports = {\n  resolveMetricsProcessType,\n  shouldEnforceProcessType,\n  exitUnlessProcessTypeIs,\n  exitUnlessProcessTypeIn,\n  METRICS_PROCESS_TYPE_DATABASE,\n  METRICS_PROCESS_TYPE_QUEUE,\n  METRICS_PROCESS_TYPE_REDIS,\n  METRICS_PROCESS_TYPE_WEB,\n  METRICS_PROCESS_TYPE_WORKER,\n  REDIS_METRICS_CLIENT_ALLOWED_PROCESS_TYPES,\n}\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAMA,6BAA6B,GAAG,kBAAkB;;AAExD;AACA,MAAMC,0BAA0B,GAAG,eAAe;;AAElD;AACA,MAAMC,0BAA0B,GAAG,eAAe;;AAElD;AACA,MAAMC,wBAAwB,GAAG,KAAK;;AAEtC;AACA,MAAMC,2BAA2B,GAAG,QAAQ;;AAE5C;AACA;AACA;AACA;AACA,MAAMC,0CAA0C,GAAGC,MAAM,CAACC,MAAM,CAAC,CAC/DL,0BAA0B,EAC1BD,0BAA0B,CAC3B,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASO,yBAAyBA,CAACC,aAAa,EAAEC,kBAAkB,EAAE;EACpE,OACED,aAAa,CAACE,WAAW,IACzBC,OAAO,CAACC,GAAG,CAACC,uBAAuB,IACnCJ,kBAAkB;AAEtB;;AAEA;AACA;AACA;AACA;AACA,SAASK,wBAAwBA,CAACN,aAAa,EAAE;EAC/C,OACE,CAACA,aAAa,CAACO,OAAO,IAAIJ,OAAO,CAACC,GAAG,CAACI,eAAe,KAAK,MAAM,MAAM,IAAI;AAE9E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,uBAAuBA,CAACT,aAAa,EAAEU,mBAAmB,EAAE;EACnE,IAAI,CAACJ,wBAAwB,CAACN,aAAa,CAAC,EAAE;EAC9C,MAAMW,QAAQ,GAAGZ,yBAAyB,CAACC,aAAa,EAAEU,mBAAmB,CAAC;EAC9E,IAAIC,QAAQ,KAAKD,mBAAmB,EAAE;IACpCP,OAAO,CAACS,IAAI,CAAC,CAAC,CAAC;EACjB;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,uBAAuBA,CAC9Bb,aAAa,EACbc,mBAAmB,EACnBC,sBAAsB,EACtB;EACA,IAAI,CAACT,wBAAwB,CAACN,aAAa,CAAC,EAAE;EAC9C,MAAMW,QAAQ,GAAGZ,yBAAyB,CACxCC,aAAa,EACbe,sBACF,CAAC;EACD,IAAI,CAACD,mBAAmB,CAACE,QAAQ,CAACL,QAAQ,CAAC,EAAE;IAC3CR,OAAO,CAACS,IAAI,CAAC,CAAC,CAAC;EACjB;AACF;AAEAK,MAAM,CAACC,OAAO,GAAG;EACfnB,yBAAyB;EACzBO,wBAAwB;EACxBG,uBAAuB;EACvBI,uBAAuB;EACvBtB,6BAA6B;EAC7BC,0BAA0B;EAC1BC,0BAA0B;EAC1BC,wBAAwB;EACxBC,2BAA2B;EAC3BC;AACF,CAAC","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adalo/metrics",
-  "version": "0.1.175",
+  "version": "0.1.176",
   "description": "Reusable metrics utilities for Node.js and Laravel apps",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -23,12 +23,13 @@
   "author": "@AdaloHQ",
   "license": "ISC",
   "dependencies": {
+    "@types/pg": "^8.15.6",
     "bee-queue": "^1.2.2",
     "dotenv": "^8.2.0",
     "mysql2": "^3.11.0",
     "pg": "^8.16.3",
     "prom-client": "^15.1.3",
-    "@types/pg": "^8.15.6"
+    "uuid": "9.0.1"
   },
   "devDependencies": {
     "@babel/cli": "7.24.7",

package/src/metrics/baseMetricsClient.js

@@ -63,7 +63,7 @@ class BaseMetricsClient {
       process_type: this.processType,
     }
 
-    /** Default labels without dyno_id (for HTTP metrics so dyno_id is not included). */
+    /** Labels excluding `dyno_id` (for series keyed only by app + process_type). */
     this.defaultLabelsWithoutDynoId = {
       app: this.appName,
       process_type: this.processType,

package/src/metrics/httpMetricsRedisCollector.js

@@ -1,3 +1,4 @@
+const { v4: uuidv4 } = require('uuid')
 const { BaseMetricsClient } = require('./baseMetricsClient')
 const {
   HttpMetricsRedisStore,
@@ -5,31 +6,33 @@ const {
 } = 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
+ * Ms between `http_instance_id` rotation + in-memory counter reset in {@link HttpMetricsRedisCollector}.
+ * From `process.env.METRICS_HTTP_INSTANCE_ROTATE_MS` if positive integer, else 7 days. Resolved at module load.
  */
+const HTTP_PUSH_INSTANCE_ROTATE_MS =
+  parseInt(process.env.METRICS_HTTP_INSTANCE_ROTATE_MS || '', 10) ||
+  7 * 24 * 60 * 60 * 1000
+const HTTP_PUSH_ROTATION_CHECK_THROTTLE_MS = 60 * 1000
+
 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)
+   * @param {import('redis').RedisClient} config.redisClient
+   * @param {string} [config.appName] Name of the application (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.dynoId] Dyno/instance ID (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.processType] Process type for labels (defaults per {@link BaseMetricsClient})
+   * @param {boolean} [config.enabled] Enable metrics collection (defaults per {@link BaseMetricsClient})
+   * @param {boolean} [config.logValues] Log metrics values to console (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.pushgatewayUrl] VM-agent import URL (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.pushgatewaySecret] Basic auth secret, Base64 (defaults per {@link BaseMetricsClient})
+   * @param {number} [config.intervalSec] Push interval in seconds (defaults per {@link BaseMetricsClient})
+   * @param {boolean} [config.removeOldMetrics] Enable clearing old metrics (defaults per {@link BaseMetricsClient})
+   * @param {function} [config.startupValidation] Run before first push (defaults per {@link BaseMetricsClient})
+   * @param {boolean} [config.disablePushgateway] Skip POST to VM-agent (defaults per {@link BaseMetricsClient})
+   * @param {string} [config.redisProcessTypeForKeys] Segment in Redis keys for HTTP hashes (default `web`).
+   * @param {number} [config.ttlSec] Redis hash TTL in seconds; should match writers’ {@link HttpMetricsRedisStore}.
+   *
+   * `http_instance_id` rotation interval: {@link HTTP_PUSH_INSTANCE_ROTATE_MS} (set at process start from env, see constant JSDoc).
    */
   constructor(config = {}) {
     const { redisClient } = config
@@ -44,11 +47,6 @@ class HttpMetricsRedisCollector extends BaseMetricsClient {
 
     const keyProcessType = config.redisProcessTypeForKeys || 'web'
 
-    this.defaultLabelsWithoutDynoId = {
-      app: this.appName,
-      process_type: keyProcessType,
-    }
-
     this._store = new HttpMetricsRedisStore({
       redisClient,
       appName: this.appName,
@@ -56,27 +54,69 @@ class HttpMetricsRedisCollector extends BaseMetricsClient {
       ttlSec: config.ttlSec,
     })
 
-    /** @type {Set<string>} Redis field keys already primed with inc(0) + push in this process */
+    const now = Date.now()
+    this._httpPushInstanceId = uuidv4()
+    this._httpPushInstanceStartedAt = now
+    this._httpRotationLastCheck = 0
+
+    /** @type {Set<string>} */
     this._httpCounterPrimedKeys = new Set()
 
+    const httpLabelNames = this.withDefaultLabelsWithoutDynoId([
+      'method',
+      'route',
+      'status_code',
+      'http_instance_id',
+    ])
+
     this.createCounter({
       name: 'app_requests_total',
       help: 'Total number of HTTP requests',
-      labelNames: this.withDefaultLabels(['method', 'route', 'status_code']),
+      labelNames: httpLabelNames,
+      useLabelsWithoutDynoId: true,
     })
 
     this.createCounter({
       name: 'app_requests_total_duration',
       help: 'Total duration of HTTP requests in milliseconds',
-      labelNames: this.withDefaultLabels(['method', 'route', 'status_code']),
+      labelNames: httpLabelNames,
+      useLabelsWithoutDynoId: true,
     })
   }
 
+  _labelsForHttpPush(rowLabels) {
+    return {
+      ...rowLabels,
+      http_instance_id: this._httpPushInstanceId,
+    }
+  }
+
+  /** @param {number} now */
+  _rotateHttpPushInstance(now) {
+    this._httpPushInstanceId = uuidv4()
+    this._httpPushInstanceStartedAt = now
+    this.clearAllCounters()
+    this._httpCounterPrimedKeys.clear()
+  }
+
+  /** @param {number} now */
+  _maybeRotateHttpPushInstance(now = Date.now()) {
+    if (now - this._httpRotationLastCheck < HTTP_PUSH_ROTATION_CHECK_THROTTLE_MS) {
+      return
+    }
+    this._httpRotationLastCheck = now
+
+    if (now - this._httpPushInstanceStartedAt >= HTTP_PUSH_INSTANCE_ROTATE_MS) {
+      this._rotateHttpPushInstance(now)
+    }
+  }
+
   /**
-   * Drains Redis into counters, then runs gauge updates and VM-agent push ({@link BaseMetricsClient#_pushMetrics}).
    * @returns {Promise<void>}
    */
   pushMetrics = async () => {
+    this._maybeRotateHttpPushInstance()
+
     if (
       this._store &&
       this.countersFunctions?.app_requests_total &&
@@ -96,10 +136,11 @@ class HttpMetricsRedisCollector extends BaseMetricsClient {
             row.labels.route,
             row.labels.status_code
           )
+          const L = this._labelsForHttpPush(row.labels)
           if (!this._httpCounterPrimedKeys.has(key)) {
             this._httpCounterPrimedKeys.add(key)
-            applyCount(row.labels, 0)
-            applyDur(row.labels, 0)
+            applyCount(L, 0)
+            applyDur(L, 0)
             primedAny = true
           }
         }
@@ -107,9 +148,10 @@ class HttpMetricsRedisCollector extends BaseMetricsClient {
           await this.gatewayPush()
         }
         for (const row of rows) {
-          applyCount(row.labels, row.count)
+          const L = this._labelsForHttpPush(row.labels)
+          applyCount(L, row.count)
           if (row.dur > 0) {
-            applyDur(row.labels, row.dur)
+            applyDur(L, row.dur)
           }
         }
       }
@@ -118,4 +160,7 @@ class HttpMetricsRedisCollector extends BaseMetricsClient {
   }
 }
 
-module.exports = { HttpMetricsRedisCollector }
+module.exports = {
+  HttpMetricsRedisCollector,
+  HTTP_PUSH_INSTANCE_ROTATE_MS,
+}

package/src/metrics/httpMetricsRedisRecorder.js

@@ -1,23 +1,29 @@
 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).
+   * @param {Object} [opts]
+   * @param {import('redis').RedisClient} [opts.redisClient] Required if `METRICS_HTTP_ENABLED` env is `true`.
+   * @param {string} [opts.appName]
+   * @param {string} [opts.processType]
+   * @param {number} [opts.ttlSec]
    */
   constructor({ redisClient, appName, processType = 'web', ttlSec } = {}) {
+    this._enabled = process.env.METRICS_HTTP_ENABLED === 'true'
+
+    if (!this._enabled) {
+      this.processType = processType
+      this.appName = appName || process.env.BUILD_APP_NAME || 'unknown-app'
+      this._store = null
+      return
+    }
+
     if (redisClient == null) {
-      throw new Error('HttpMetricsRedisRecorder: redisClient is required')
+      throw new Error(
+        'HttpMetricsRedisRecorder: redisClient is required when METRICS_HTTP_ENABLED=true'
+      )
     }
+
     const resolvedAppName =
       appName || process.env.BUILD_APP_NAME || 'unknown-app'
     this.processType = processType
@@ -38,18 +44,20 @@ class HttpMetricsRedisRecorder {
    * @param {number} params.duration
    */
   trackHttpRequest({ method, route, status_code, duration }) {
+    if (!this._enabled || !this._store) return
     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 (!this._enabled) {
+      next()
+      return
+    }
     if (req.method === 'OPTIONS') {
       next()
       return

package/src/metrics/metricsClient.js

@@ -3,13 +3,7 @@ const os = require('os')
 const { BaseMetricsClient } = require('./baseMetricsClient')
 
 /**
- * MetricsClient handles Prometheus metrics collection and push.
- * Supports gauges, default process metrics, optional HTTP counters, and custom metrics.
- *
- * **HTTP metrics:** In-process counters only (`app_requests_*`), gated by `httpMetricsEnabled` /
- * `METRICS_HTTP_ENABLED`. For Redis-backed HTTP aggregation (multi-web / cluster), use
- * {@link HttpMetricsRedisRecorder} and {@link HttpMetricsRedisCollector} — not this class.
- *
+ * Process gauges (CPU, memory, event loop lag, uptime, etc.) on top of {@link BaseMetricsClient}.
  * @extends BaseMetricsClient
  */
 class MetricsClient extends BaseMetricsClient {
@@ -19,7 +13,6 @@ class MetricsClient extends BaseMetricsClient {
    * @param {string} [config.dynoId] Dyno/instance ID
    * @param {string} [config.processType] Process type (web, worker, etc.)
    * @param {boolean} [config.enabled] Enable metrics collection
-   * @param {boolean} [config.httpMetricsEnabled] Enable HTTP request metrics (`app_requests_total`, `app_requests_total_duration`); defaults from `METRICS_HTTP_ENABLED === 'true'`
    * @param {boolean} [config.logValues] Log metrics values to console
    * @param {string} [config.pushgatewayUrl] Push URL (VM-agent import endpoint, e.g. .../api/v1/import/prometheus). /metrics is for GET (scrape), not POST (push).
    * @param {string} [config.pushgatewaySecret] Basic auth secret (Base64 of `user:password`)
@@ -32,11 +25,6 @@ class MetricsClient extends BaseMetricsClient {
   constructor(config = {}) {
     super(config)
 
-    this.httpMetricsEnabled =
-      config.httpMetricsEnabled !== undefined
-        ? config.httpMetricsEnabled
-        : process.env.METRICS_HTTP_ENABLED === 'true'
-
     this._lastUsageMicros = 0
     this._lastCheckTime = Date.now()
 
@@ -83,30 +71,6 @@ class MetricsClient extends BaseMetricsClient {
       help: 'How long the process has been running',
       updateFn: process.uptime,
     })
-
-    if (this.httpMetricsEnabled) {
-      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,
-      })
-    }
   }
 
   /**
@@ -206,62 +170,6 @@ class MetricsClient extends BaseMetricsClient {
       setImmediate(() => resolve(Date.now() - start))
     })
   }
-
-  /**
-   * Increment HTTP request counters (in-process). No-op if `httpMetricsEnabled` is false.
-   *
-   * @param {Object} params
-   * @param {string} params.method HTTP method
-   * @param {string} params.route Route or path pattern
-   * @param {number} params.status_code HTTP status code
-   * @param {number} params.duration Duration in milliseconds
-   */
-  trackHttpRequest({ method, route, status_code, duration }) {
-    if (!this.httpMetricsEnabled) return
-
-    this.countersFunctions?.app_requests_total({
-      method,
-      route,
-      status_code,
-    })
-    this.countersFunctions?.app_requests_total_duration(
-      {
-        method,
-        route,
-        status_code,
-      },
-      duration
-    )
-  }
-
-  /**
-   * Express middleware: records `app_requests_*` on response finish.
-   * Skips when disabled, HTTP metrics off, or `OPTIONS`.
-   *
-   * @param {import('http').IncomingMessage} req
-   * @param {import('http').ServerResponse} res
-   * @param {function} next
-   */
-  trackHttpRequestMiddleware = (req, res, next) => {
-    if (!this.enabled || !this.httpMetricsEnabled || 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 = { MetricsClient }

package/src/metrics/metricsProcessTypeUtils.js

@@ -1,11 +1,7 @@
 /**
- * Helpers for resolving `processType` and silently exiting when a specialized metrics client
- * is constructed on the wrong dyno / process (no log output).
- *
- * **Canonical names** align with typical Procfile processes (e.g. backend: `web`, `worker`,
- * `queue-metrics`, `database-metrics`, `http-metrics`). The compile **worker** dyno serves queues/builds
- * — it does not run HTTP request metrics. HTTP Redis **key segment** for API traffic is fixed **`web`**
- * (`HttpMetricsRedisCollector` / `HttpMetricsRedisRecorder`), not `BUILD_DYNO_PROCESS_TYPE`.
+ * Helpers for resolving `processType` and optional silent exit when a specialized metrics client
+ * is constructed on the wrong dyno (no log output). If `METRICS_ENABLED` is not `true`, the check
+ * is skipped so the process is not stopped.
  *
  * @module metrics/metricsProcessTypeUtils
  */
@@ -49,14 +45,26 @@ function resolveMetricsProcessType(metricsConfig, defaultProcessType) {
   )
 }
 
+/**
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
+ * @returns {boolean}
+ */
+function shouldEnforceProcessType(metricsConfig) {
+  return (
+    (metricsConfig.enabled ?? process.env.METRICS_ENABLED === 'true') === true
+  )
+}
+
 /**
  * Exit with no logs if the resolved process type is not exactly `expectedProcessType`.
+ * No-op when `METRICS_ENABLED` is not `true` (avoids exit/restart loops when metrics are off).
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {string} expectedProcessType - Single allowed value (use a module constant, e.g. {@link METRICS_PROCESS_TYPE_DATABASE})
  * @returns {void}
  */
 function exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {
+  if (!shouldEnforceProcessType(metricsConfig)) return
   const resolved = resolveMetricsProcessType(metricsConfig, expectedProcessType)
   if (resolved !== expectedProcessType) {
     process.exit(0)
@@ -65,8 +73,9 @@ function exitUnlessProcessTypeIs(metricsConfig, expectedProcessType) {
 
 /**
  * Exit with no logs if the resolved process type is not in `allowedProcessTypes`.
+ * No-op when `METRICS_ENABLED` is not `true`.
  *
- * @param {{ processType?: string }} metricsConfig
+ * @param {{ processType?: string, enabled?: boolean }} metricsConfig
  * @param {readonly string[]} allowedProcessTypes
  * @param {string} defaultWhenUnspecified - Used only to resolve when config/env omit `processType` (e.g. {@link METRICS_PROCESS_TYPE_QUEUE} for {@link RedisMetricsClient})
  * @returns {void}
@@ -76,6 +85,7 @@ function exitUnlessProcessTypeIn(
   allowedProcessTypes,
   defaultWhenUnspecified
 ) {
+  if (!shouldEnforceProcessType(metricsConfig)) return
   const resolved = resolveMetricsProcessType(
     metricsConfig,
     defaultWhenUnspecified
@@ -87,6 +97,7 @@ function exitUnlessProcessTypeIn(
 
 module.exports = {
   resolveMetricsProcessType,
+  shouldEnforceProcessType,
   exitUnlessProcessTypeIs,
   exitUnlessProcessTypeIn,
   METRICS_PROCESS_TYPE_DATABASE,

package/docs/http-metrics-redis.md

@@ -1,19 +0,0 @@
-# HTTP metrics via Redis (`HttpMetricsRedisRecorder` / `HttpMetricsRedisCollector`)
-
-This file is a **quick entry point** for the Redis-backed HTTP aggregation path. **Full architecture, env vars, and diagrams** are in the repository guide:
-
-**[docs/METRICS.md](../../docs/METRICS.md)**
-
-## Cheat sheet
-
-| Concern | Detail |
-|--------|--------|
-| **Writers** | `HttpMetricsRedisRecorder` — Express middleware records `method`, `route`, `status_code`, duration into Redis hashes. |
-| **Reader** | `HttpMetricsRedisCollector` — separate process calls `pushMetrics()`, which **drains** Redis (atomic Lua) and increments `app_requests_*`, then pushes to VM-agent. |
-| **Redis key shape** | `metrics:http:v2:<encode(appName)>:<encode(processType)>:count` and `:dur` — two hashes per writer group. |
-| **Hash field** | Three logical parts: method, route, HTTP status (joined with an internal `FIELD_SEP`). |
-| **Prometheus labels** | `method`, `route`, `status_code` (plus default `app` / `process_type` without `dyno_id` on these counters). |
-| **Backend** | Web: `backend/monitoring.ts` + `METRICS_HTTP_ENABLED`. Drain: `backend/http-metrics-collector.ts`, Procfile `http-metrics:`. |
-| **Prime 0 on new routes** | The first time a `(method, route, status_code)` appears **in this process**, the collector `inc(..., 0)` for count+duration on **that label set only**, **POST**, then applies drained counts for **all** rows. Existing series are **not** touched in the prime loop — e.g. in-memory `b` was **18**, drain has new `a:1` and `b:20`: prime push exports **`a=0`, `b=18`**; after apply, final push has **`a=1`, `b=38`**. If **all** label sets were already seen, there is **no** extra prime `POST`. |
-
-For in-process HTTP metrics **without** Redis, see **`MetricsClient`** + `METRICS_HTTP_ENABLED` in **[docs/METRICS.md](../../docs/METRICS.md#http-metrics-two-valid-designs)**.