@adalo/metrics 0.1.172 → 0.1.174

package/README.md

@@ -25,8 +25,15 @@ new MetricsClient({
   pushgatewayUrl,     // defaults: process.env.METRICS_PUSHGATEWAY_URL || ''
   pushgatewaySecret,  // defaults: process.env.METRICS_PUSHGATEWAY_SECRET || '' (Base64 of user:password)
   intervalSec,        // defaults: process.env.METRICS_INTERVAL_SEC || 15
+  httpMetricsEnabled, // defaults: METRICS_HTTP_ENABLED === 'true' (in-process HTTP counters only)
 })
 ```
+
+### HTTP metrics: `MetricsClient` vs Redis
+
+**`MetricsClient`** only registers **in-process** `app_requests_*` counters when `METRICS_HTTP_ENABLED` / `httpMetricsEnabled` is on. For **Redis-backed** HTTP aggregation (multi-web / cluster), use **`HttpMetricsRedisRecorder`** (writers) and **`HttpMetricsRedisCollector`** (drain + push) with an injected **`redisClient`** — same idea as `RedisMetricsClient`, not mixed into `MetricsClient`. See **[`docs/http-metrics-redis.md`](docs/http-metrics-redis.md)** (quick Redis reference) and the repo guide **[`../docs/METRICS.md`](../docs/METRICS.md)** (full architecture for devs and AI assistants).
+
+`DatabaseMetricsClient` / `QueueRedisMetricsClient` / `RedisMetricsClient` call **`process.exit(0)` with no logs** if `BUILD_DYNO_PROCESS_TYPE` (or `processType`) does not match `database-metrics` / `queue-metrics` / (`redis-metrics` or `queue-metrics`) respectively.
 ## Example Usage
 ```ts
 import { MetricsClient } from '@adalo/metrics-js'

package/__tests__/httpMetricsRedisCollector.test.js

@@ -0,0 +1,203 @@
+const { HttpMetricsRedisCollector } = require('../src/metrics/httpMetricsRedisCollector')
+const { buildFieldKey } = require('../src/metrics/httpMetricsRedisStore')
+
+function appRequestTotalsByRoute(metricsJson) {
+  const reqTotal = metricsJson.find(m => m.name === 'app_requests_total')
+  if (!reqTotal || !reqTotal.values) {
+    return {}
+  }
+  return Object.fromEntries(reqTotal.values.map(v => [v.labels.route, v.value]))
+}
+
+function createRedisV3Mock() {
+  const multiChain = {
+    hincrby: jest.fn().mockReturnThis(),
+    expire: jest.fn().mockReturnThis(),
+    exec: jest.fn(cb => {
+      if (cb) {
+        setImmediate(() => cb(null))
+      }
+    }),
+  }
+  return {
+    multi: jest.fn(() => multiChain),
+    eval: jest.fn(),
+    _multiChain: multiChain,
+  }
+}
+
+describe('HttpMetricsRedisCollector', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    process.env = { ...originalEnv, METRICS_DISABLE_PUSHGATEWAY: 'true' }
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  it('throws without redisClient', () => {
+    expect(() => new HttpMetricsRedisCollector({ appName: 'a' })).toThrow('redisClient is required')
+  })
+
+  it('pushMetrics drains Redis then completes without network push', async () => {
+    const redis = createRedisV3Mock()
+    const field = buildFieldKey('GET', '/health', 200)
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [field, '1'],
+        [field, '10'],
+      ])
+    })
+
+    const collector = new HttpMetricsRedisCollector({
+      redisClient: redis,
+      appName: 'test-app',
+      dynoId: 'dyno-1',
+      processType: 'http-metrics',
+      redisProcessTypeForKeys: 'web',
+      disablePushgateway: true,
+    })
+
+    const pushSpy = jest.spyOn(collector, 'gatewayPush').mockResolvedValue()
+
+    await collector.pushMetrics()
+
+    expect(redis.eval).toHaveBeenCalled()
+    expect(pushSpy).toHaveBeenCalledTimes(1)
+    const metrics = await collector._registry.getMetricsAsJSON()
+    const total = metrics.find(m => m.name === 'app_requests_total')
+    expect(total).toBeDefined()
+    const totalDur = metrics.find(m => m.name === 'app_requests_total_duration')
+    expect(totalDur).toBeDefined()
+
+    pushSpy.mockRestore()
+  })
+
+  it('primes new label sets with 0 then applies count (extra push only when labels are new)', async () => {
+    const redis = createRedisV3Mock()
+    const field = buildFieldKey('GET', '/health', 200)
+
+    const collector = new HttpMetricsRedisCollector({
+      redisClient: redis,
+      appName: 'test-app',
+      dynoId: 'dyno-1',
+      processType: 'http-metrics',
+      redisProcessTypeForKeys: 'web',
+      disablePushgateway: true,
+    })
+
+    const pushSpy = jest.spyOn(collector, 'gatewayPush').mockResolvedValue()
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [field, '2'],
+        [field, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+    expect(pushSpy).toHaveBeenCalledTimes(1)
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [field, '1'],
+        [field, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+    expect(pushSpy).toHaveBeenCalledTimes(1)
+
+    pushSpy.mockRestore()
+  })
+
+  it('prime push for new route a leaves existing route b unchanged (a=0, b=18), then a=1, b=38', async () => {
+    const redis = createRedisV3Mock()
+    const fieldB = buildFieldKey('GET', '/b', 200)
+    const fieldA = buildFieldKey('GET', '/a', 200)
+
+    const collector = new HttpMetricsRedisCollector({
+      redisClient: redis,
+      appName: 'test-app',
+      dynoId: 'dyno-1',
+      processType: 'http-metrics',
+      redisProcessTypeForKeys: 'web',
+      disablePushgateway: true,
+    })
+
+    let primePushCount = 0
+    const pushSpy = jest.spyOn(collector, 'gatewayPush').mockImplementation(async () => {
+      primePushCount++
+      if (primePushCount === 2) {
+        const metrics = await collector._registry.getMetricsAsJSON()
+        const byRoute = appRequestTotalsByRoute(metrics)
+        expect(byRoute['/a']).toBe(0)
+        expect(byRoute['/b']).toBe(18)
+      }
+    })
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [fieldB, '18'],
+        [fieldB, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [fieldA, '1', fieldB, '20'],
+        [fieldA, '0', fieldB, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+
+    const final = appRequestTotalsByRoute(await collector._registry.getMetricsAsJSON())
+    expect(final['/a']).toBe(1)
+    expect(final['/b']).toBe(38)
+    expect(pushSpy).toHaveBeenCalledTimes(2)
+
+    pushSpy.mockRestore()
+  })
+
+  it('does not prime POST when drain only has already-seen routes (was a:1 b:18, then a:1 b:20)', async () => {
+    const redis = createRedisV3Mock()
+    const fieldA = buildFieldKey('GET', '/a', 200)
+    const fieldB = buildFieldKey('GET', '/b', 200)
+
+    const collector = new HttpMetricsRedisCollector({
+      redisClient: redis,
+      appName: 'test-app',
+      dynoId: 'dyno-1',
+      processType: 'http-metrics',
+      redisProcessTypeForKeys: 'web',
+      disablePushgateway: true,
+    })
+
+    const pushSpy = jest.spyOn(collector, 'gatewayPush').mockResolvedValue()
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [fieldA, '1', fieldB, '18'],
+        [fieldA, '0', fieldB, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+    expect(pushSpy).toHaveBeenCalledTimes(1)
+
+    redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+      cb(null, [
+        [fieldA, '1', fieldB, '20'],
+        [fieldA, '0', fieldB, '0'],
+      ])
+    })
+    await collector.pushMetrics()
+    expect(pushSpy).toHaveBeenCalledTimes(1)
+
+    const final = appRequestTotalsByRoute(await collector._registry.getMetricsAsJSON())
+    expect(final['/a']).toBe(2)
+    expect(final['/b']).toBe(38)
+
+    pushSpy.mockRestore()
+  })
+})

package/__tests__/httpMetricsRedisRecorder.test.js

@@ -0,0 +1,60 @@
+const { HttpMetricsRedisRecorder } = require('../src/metrics/httpMetricsRedisRecorder')
+const { buildFieldKey } = require('../src/metrics/httpMetricsRedisStore')
+
+const flushMicrotasks = () => new Promise(resolve => setImmediate(resolve))
+
+function createRedisV3Mock() {
+  const multiChain = {
+    hincrby: jest.fn().mockReturnThis(),
+    expire: jest.fn().mockReturnThis(),
+    exec: jest.fn(cb => {
+      if (cb) {
+        setImmediate(() => cb(null))
+      }
+    }),
+  }
+  return {
+    multi: jest.fn(() => multiChain),
+    set: jest.fn(),
+    eval: jest.fn(),
+    del: jest.fn(),
+    _multiChain: multiChain,
+  }
+}
+
+describe('HttpMetricsRedisRecorder', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    process.env = { ...originalEnv, BUILD_APP_NAME: 'app' }
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  it('throws without redisClient', () => {
+    expect(() => new HttpMetricsRedisRecorder({})).toThrow('redisClient is required')
+  })
+
+  it('trackHttpRequest forwards to Redis multi/hincrby', async () => {
+    const redis = createRedisV3Mock()
+    const rec = new HttpMetricsRedisRecorder({
+      redisClient: redis,
+    })
+    const countKey = rec._store.countKey
+    const durKey = rec._store.durKey
+    const field = buildFieldKey('GET', '/p', 404)
+
+    rec.trackHttpRequest({
+      method: 'GET',
+      route: '/p',
+      status_code: 404,
+      duration: 5,
+    })
+    await flushMicrotasks()
+
+    expect(redis._multiChain.hincrby).toHaveBeenCalledWith(countKey, field, 1)
+    expect(redis._multiChain.hincrby).toHaveBeenCalledWith(durKey, field, 5)
+  })
+})

package/__tests__/httpMetricsRedisStore.test.js

@@ -0,0 +1,431 @@
+const {
+  HttpMetricsRedisStore,
+  buildFieldKey,
+  FIELD_SEP,
+} = require('../src/metrics/httpMetricsRedisStore')
+
+const flushMicrotasks = () => new Promise(resolve => setImmediate(resolve))
+
+/**
+ * redis@3-style mock: multi().hincrby().expire().exec(cb)
+ */
+function createRedisV3Mock() {
+  const multiChain = {
+    hincrby: jest.fn().mockReturnThis(),
+    expire: jest.fn().mockReturnThis(),
+    exec: jest.fn(cb => {
+      if (cb) {
+        setImmediate(() => cb(null))
+      }
+    }),
+  }
+  return {
+    multi: jest.fn(() => multiChain),
+    eval: jest.fn(),
+    _multiChain: multiChain,
+  }
+}
+
+/**
+ * In-memory redis@3 mock: MULTI/EXEC applies HINCRBY to shared hashes; EVAL returns
+ * [HGETALL+DEL countKey, HGETALL+DEL durKey] like the real drain Lua. Use this to
+ * simulate many writers (same client) without Redis.
+ */
+function createRedisV3InMemoryMock() {
+  /** @type {Record<string, Record<string, string>>} */
+  const hashes = {}
+
+  function hgetallFlat(key) {
+    const h = hashes[key]
+    if (!h) return []
+    const flat = []
+    for (const [f, v] of Object.entries(h)) {
+      flat.push(f, v)
+    }
+    return flat
+  }
+
+  function drainKey(key) {
+    const flat = hgetallFlat(key)
+    delete hashes[key]
+    return flat
+  }
+
+  const client = {
+    multi: jest.fn(() => {
+      const ops = []
+      const chain = {}
+      chain.hincrby = jest.fn((key, field, inc) => {
+        ops.push({ key, field, inc: Number(inc) })
+        return chain
+      })
+      chain.expire = jest.fn().mockReturnValue(chain)
+      chain.exec = jest.fn(cb => {
+        for (const op of ops) {
+          if (!hashes[op.key]) hashes[op.key] = {}
+          const cur = parseInt(hashes[op.key][op.field] || '0', 10)
+          hashes[op.key][op.field] = String(cur + op.inc)
+        }
+        if (cb) cb(null)
+      })
+      return chain
+    }),
+    eval: jest.fn((lua, numKeys, k1, k2, cb) => {
+      const out = [drainKey(k1), drainKey(k2)]
+      if (cb) cb(null, out)
+    }),
+    /** @param {string} key */
+    _fieldCount(key) {
+      return Object.keys(hashes[key] || {}).length
+    },
+    _peek(key) {
+      return { ...(hashes[key] || {}) }
+    },
+  }
+  return client
+}
+
+describe('HttpMetricsRedisStore', () => {
+  describe('buildFieldKey', () => {
+    it('joins method, route, status with FIELD_SEP', () => {
+      expect(buildFieldKey('GET', '/api', 200)).toBe(
+        ['GET', '/api', '200'].join(FIELD_SEP)
+      )
+    })
+  })
+
+  describe('constructor', () => {
+    it('throws without redisClient', () => {
+      expect(() => new HttpMetricsRedisStore({ appName: 'a', processType: 'web' })).toThrow(
+        'redisClient is required'
+      )
+    })
+
+    it('builds encoded v2 keys', () => {
+      const redis = createRedisV3Mock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'my app',
+        processType: 'web',
+      })
+      const seg = `${encodeURIComponent('my app')}:${encodeURIComponent('web')}`
+      expect(store.countKey).toBe(`metrics:http:v2:${seg}:count`)
+      expect(store.durKey).toBe(`metrics:http:v2:${seg}:dur`)
+    })
+  })
+
+  describe('record', () => {
+    it('increments count and duration hashes with TTL', async () => {
+      const redis = createRedisV3Mock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+        ttlSec: 90,
+      })
+      const field = buildFieldKey('GET', '/x', 200)
+
+      store.record('GET', '/x', 200, 12)
+      await flushMicrotasks()
+
+      expect(redis.multi).toHaveBeenCalled()
+      expect(redis._multiChain.hincrby).toHaveBeenCalledWith(store.countKey, field, 1)
+      expect(redis._multiChain.hincrby).toHaveBeenCalledWith(store.durKey, field, 12)
+      expect(redis._multiChain.expire).toHaveBeenCalledWith(store.countKey, 90)
+      expect(redis._multiChain.expire).toHaveBeenCalledWith(store.durKey, 90)
+      expect(redis._multiChain.exec).toHaveBeenCalled()
+    })
+  })
+
+  describe('flushToCounters', () => {
+    it('applies aggregated count and summed duration for one route (many requests → one field)', async () => {
+      const redis = createRedisV3Mock()
+      const field = buildFieldKey('GET', '/api/items', 200)
+      redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+        cb(null, [
+          [field, '100'],
+          [field, '4500'],
+        ])
+      })
+
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+
+      const ok = await store.flushToCounters(applyCount, applyDuration)
+
+      expect(ok).toBe(true)
+      expect(applyCount).toHaveBeenCalledWith(
+        {
+          method: 'GET',
+          route: '/api/items',
+          status_code: '200',
+        },
+        100
+      )
+      expect(applyDuration).toHaveBeenCalledWith(
+        {
+          method: 'GET',
+          route: '/api/items',
+          status_code: '200',
+        },
+        4500
+      )
+    })
+
+    it('drains hashes and applies count and duration', async () => {
+      const redis = createRedisV3Mock()
+      const field = buildFieldKey('POST', '/r', 201)
+      redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+        cb(null, [
+          [field, '2'],
+          [field, '50'],
+        ])
+      })
+
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+
+      const ok = await store.flushToCounters(applyCount, applyDuration)
+
+      expect(ok).toBe(true)
+      expect(redis.eval).toHaveBeenCalledWith(
+        expect.stringContaining('HGETALL'),
+        2,
+        store.countKey,
+        store.durKey,
+        expect.any(Function)
+      )
+      expect(applyCount).toHaveBeenCalledWith(
+        {
+          method: 'POST',
+          route: '/r',
+          status_code: '201',
+        },
+        2
+      )
+      expect(applyDuration).toHaveBeenCalledWith(
+        {
+          method: 'POST',
+          route: '/r',
+          status_code: '201',
+        },
+        50
+      )
+    })
+
+    it('legacy 6-part hash fields still drain (labels from first three segments)', async () => {
+      const redis = createRedisV3Mock()
+      const legacyField = ['GET', '/old', '200', 'a', 'd', '999'].join(FIELD_SEP)
+      redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+        cb(null, [
+          [legacyField, '3'],
+          [legacyField, '9'],
+        ])
+      })
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      const ok = await store.flushToCounters(applyCount, applyDuration)
+      expect(ok).toBe(true)
+      expect(applyCount).toHaveBeenCalledWith(
+        {
+          method: 'GET',
+          route: '/old',
+          status_code: '200',
+        },
+        3
+      )
+      expect(applyDuration).toHaveBeenCalledWith(
+        {
+          method: 'GET',
+          route: '/old',
+          status_code: '200',
+        },
+        9
+      )
+    })
+
+    it('resolves true with no applies when eval returns short array', async () => {
+      const redis = createRedisV3Mock()
+      redis.eval.mockImplementation((lua, numKeys, k1, k2, cb) => {
+        cb(null, [])
+      })
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+      const applyCount = jest.fn()
+      const ok = await store.flushToCounters(applyCount, jest.fn())
+      expect(ok).toBe(true)
+      expect(applyCount).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('in-memory integration (many fields, shared writers)', () => {
+    it('flush applies many distinct hash fields (many routes / labels)', async () => {
+      const redis = createRedisV3InMemoryMock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'svc',
+        processType: 'web',
+      })
+      const routes = Array.from({ length: 24 }, (_, i) => `/api/v${i % 3}/item/${i}`)
+      for (let i = 0; i < routes.length; i++) {
+        const method = i % 2 === 0 ? 'GET' : 'POST'
+        const status = i % 5 === 0 ? 500 : 200
+        store.record(method, routes[i], status, 10 + i)
+      }
+      expect(redis._fieldCount(store.countKey)).toBe(routes.length)
+
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      const ok = await store.flushToCounters(applyCount, applyDuration)
+
+      expect(ok).toBe(true)
+      expect(applyCount).toHaveBeenCalledTimes(routes.length)
+      let sumCount = 0
+      let sumDur = 0
+      applyCount.mock.calls.forEach(([, c]) => {
+        sumCount += c
+      })
+      applyDuration.mock.calls.forEach(([, d]) => {
+        sumDur += d
+      })
+      expect(sumCount).toBe(routes.length)
+      expect(sumDur).toBe(routes.reduce((acc, _, i) => acc + (10 + i), 0))
+      expect(redis._peek(store.countKey)).toEqual({})
+    })
+
+    it('many requests for the same field aggregate to one apply (like one dyno hot route)', async () => {
+      const redis = createRedisV3InMemoryMock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+      const n = 80
+      for (let i = 0; i < n; i++) {
+        store.record('GET', '/hot', 200, 5)
+      }
+      expect(redis._fieldCount(store.countKey)).toBe(1)
+
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      await store.flushToCounters(applyCount, applyDuration)
+
+      expect(applyCount).toHaveBeenCalledTimes(1)
+      expect(applyCount).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          route: '/hot',
+          status_code: '200',
+        }),
+        n
+      )
+      expect(applyDuration).toHaveBeenCalledWith(
+        expect.objectContaining({ route: '/hot' }),
+        n * 5
+      )
+    })
+
+    it('multiple store instances on the same redis client combine like multiple dynos', async () => {
+      const redis = createRedisV3InMemoryMock()
+      const opts = { redisClient: redis, appName: 'prod', processType: 'web' }
+      const dynoA = new HttpMetricsRedisStore(opts)
+      const dynoB = new HttpMetricsRedisStore(opts)
+
+      dynoA.record('GET', '/a', 200, 3)
+      dynoB.record('GET', '/b', 304, 7)
+      dynoA.record('POST', '/c', 201, 11)
+
+      expect(redis._fieldCount(dynoA.countKey)).toBe(3)
+
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      const ok = await dynoB.flushToCounters(applyCount, applyDuration)
+
+      expect(ok).toBe(true)
+      expect(applyCount).toHaveBeenCalledTimes(3)
+      expect(applyDuration).toHaveBeenCalledTimes(3)
+    })
+
+    it('interleaved record() calls from parallel async work combine correctly', async () => {
+      const redis = createRedisV3InMemoryMock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'app',
+        processType: 'web',
+      })
+
+      await Promise.all(
+        [0, 1, 2, 3, 4].map(worker =>
+          Promise.all(
+            Array.from({ length: 15 }, (_, j) => {
+              const route = `/w${worker}/r${j}`
+              store.record('GET', route, 200, 2)
+              return Promise.resolve()
+            })
+          )
+        )
+      )
+
+      expect(redis._fieldCount(store.countKey)).toBe(5 * 15)
+
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      await store.flushToCounters(applyCount, applyDuration)
+
+      expect(applyCount).toHaveBeenCalledTimes(75)
+      let total = 0
+      applyCount.mock.calls.forEach(([, c]) => {
+        total += c
+      })
+      expect(total).toBe(75)
+      expect(
+        applyDuration.mock.calls.reduce((acc, [, d]) => acc + d, 0)
+      ).toBe(75 * 2)
+    })
+
+    it('mixed methods, statuses, and apps in one drain', async () => {
+      const redis = createRedisV3InMemoryMock()
+      const store = new HttpMetricsRedisStore({
+        redisClient: redis,
+        appName: 'mixed',
+        processType: 'api',
+      })
+      const samples = [
+        ['GET', '/x', 200, 1],
+        ['GET', '/x', 404, 2],
+        ['DELETE', '/x|y', 204, 3],
+      ]
+      for (const [m, r, s, dur] of samples) {
+        store.record(m, r, s, dur)
+      }
+
+      const applyCount = jest.fn()
+      const applyDuration = jest.fn()
+      await store.flushToCounters(applyCount, applyDuration)
+
+      expect(applyCount).toHaveBeenCalledTimes(3)
+      expect(applyCount.mock.calls.map(([{ method, route, status_code }]) => `${method} ${route} ${status_code}`).sort()).toEqual(
+        ['DELETE /x|y 204', 'GET /x 200', 'GET /x 404'].sort()
+      )
+      expect(applyDuration.mock.calls.reduce((acc, [, v]) => acc + v, 0)).toBe(6)
+    })
+  })
+})