tapimo 0.10.2 → 0.11.0

package/src/Webhooks.memory.bench.ts

@@ -1,250 +0,0 @@
-/** @module-tag localnet */
-/**
- * Measures retained database-factory memory and dense transfer-scan allocations.
- * Set `WEBHOOK_MEMORY_SNAPSHOT_DIR` to write V8 heap snapshots for retained objects.
- */
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import * as v8 from 'node:v8'
-import { nanoid } from 'nanoid'
-import { sendTransactionSync } from 'viem/actions'
-import { Actions, Addresses } from 'viem/tempo'
-import { Webhooks } from 'tapimo'
-import { bench } from 'vite-plus/test'
-
-import * as Db from './db/Db.js'
-import * as Cursor from './internal/Cursor.js'
-import * as Runtime from '../test/runtime.js'
-import * as TestApp from '../test/App.js'
-import * as Tempo from '../test/Tempo.js'
-import * as TestViem from '../test/Viem.js'
-
-const batchSize = 200
-const endOfBlockIndex = 2_147_483_647
-const factoryTicks = positiveInteger('WEBHOOK_MEMORY_FACTORY_TICKS', 25)
-const mebibyte = 1024 * 1024
-const runtime = Runtime.get()
-const transferCallsPerTransaction = 32
-const transferCount = positiveInteger('WEBHOOK_MEMORY_TRANSFER_COUNT', 3_600)
-
-type Memory = {
-  arrayBuffers: number
-  external: number
-  heapUsed: number
-  rss: number
-}
-
-type Report = {
-  after: Memory
-  afterOperation: Memory
-  afterOperationDelta: Memory
-  before: Memory
-  delta: Memory
-  details?: Record<string, number> | undefined
-  label: string
-}
-
-const reports: Report[] = []
-
-beforeAll(() => {
-  if (runtime.mode !== 'localnet')
-    throw new Error('Run webhook memory benchmarks with TEMPO_ENV=localnet.')
-  if (!globalThis.gc)
-    throw new Error('Run webhook memory benchmarks with NODE_OPTIONS=--expose-gc.')
-})
-
-afterAll(() => {
-  process.stdout.write(`WEBHOOK_MEMORY_REPORT ${JSON.stringify(reports)}\n`)
-})
-
-describe('webhook poller memory', () => {
-  bench(
-    `factory-created databases / ${factoryTicks} ticks`,
-    async () => {
-      reports.push(await measureFactoryRetention())
-    },
-    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
-  )
-
-  bench(
-    `transfer firehose / ${transferCount} generated transfers`,
-    async () => {
-      reports.push(await measureTransferFirehose())
-    },
-    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
-  )
-})
-
-async function measureFactoryRetention(): Promise<Report> {
-  const databases: Db.Db[] = []
-  const schema = `memory_${nanoid()}`
-  const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
-  await database.migrate()
-  await Webhooks.createSubscription(database, {
-    chainId: runtime.chainId,
-    destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/factory' },
-    eventType: 'block:created',
-    owner: { orgId: 'org_benchmark', type: 'api_key' },
-  })
-  const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
-  const poller = Webhooks.createPoller({
-    db: () => {
-      const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
-      databases.push(database)
-      return database
-    },
-    defaultChainId: runtime.chainId,
-    dispatchBatch: async () => ({ ok: true }),
-    rpc: TestApp.rpc,
-  })
-
-  try {
-    const report = await measure('factory-retained', async () => {
-      for (let index = 0; index < factoryTicks; index++)
-        await poller.tick({
-          confirmations: 0,
-          eventTypes: ['block:created'],
-          headBlockNumber,
-          maxBlocks: 1,
-        })
-    })
-    writeHeapSnapshot('factory-retained')
-    return { ...report, details: { databases: databases.length, ticks: factoryTicks } }
-  } finally {
-    await Promise.allSettled(databases.map((database) => database.close()))
-    await database.close()
-  }
-}
-
-async function measureTransferFirehose(): Promise<Report> {
-  const database = TestApp.database()
-  const client = Tempo.getClient({ account: Tempo.accounts[0] })
-  const startBlockNumber = Number(await TestViem.getClient().getBlockNumber())
-
-  try {
-    for (let offset = 0; offset < transferCount; offset += transferCallsPerTransaction) {
-      const length = Math.min(transferCallsPerTransaction, transferCount - offset)
-      await sendTransactionSync(client, {
-        account: Tempo.accounts[0],
-        calls: Array.from({ length }, () =>
-          Actions.token.transfer.call(client, {
-            amount: 1n,
-            to: Tempo.accounts[1].address,
-            token: Addresses.pathUsd,
-          }),
-        ),
-      })
-    }
-
-    const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
-    const subscription = await Webhooks.createSubscription(database, {
-      chainId: runtime.chainId,
-      destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/firehose' },
-      eventType: 'token:transfer',
-      filters: {},
-      owner: { orgId: 'org_benchmark', type: 'api_key' },
-    })
-    await Webhooks.setCursor(
-      database,
-      subscription.id,
-      Cursor.encode([startBlockNumber, endOfBlockIndex]),
-    )
-
-    let dispatched = 0
-    let serializedBytes = 0
-    const poller = Webhooks.createPoller({
-      db: database,
-      defaultChainId: runtime.chainId,
-      dispatchBatch: async (dispatchables) => {
-        dispatched += dispatchables.length
-        for (const body of dispatchables)
-          serializedBytes += new TextEncoder().encode(JSON.stringify({ body })).byteLength
-        return { ok: true }
-      },
-      rpc: TestApp.rpc,
-    })
-
-    const report = await measure('transfer-firehose', async () => {
-      const result = await poller.tick({
-        batchSize,
-        confirmations: 0,
-        eventTypes: ['token:transfer'],
-        headBlockNumber,
-        maxBlocks: 500,
-      })
-      if (result.dispatched === 0 || result.dispatched !== dispatched)
-        throw new Error(`Unexpected dispatch count: ${result.dispatched} / ${dispatched}.`)
-      if (result.dispatched > batchSize)
-        throw new Error(`Dispatch count ${result.dispatched} exceeded batch size ${batchSize}.`)
-      if (serializedBytes === 0) throw new Error('Expected serialized webhook queue messages.')
-    })
-    writeHeapSnapshot('transfer-firehose-retained')
-    return {
-      ...report,
-      details: { dispatched, serializedBytes, transferCount },
-    }
-  } finally {
-    await database.close()
-  }
-}
-
-async function measure(label: string, fn: () => Promise<void>): Promise<Report> {
-  collectGarbage()
-  const before = memoryUsage()
-  await fn()
-  const afterOperation = memoryUsage()
-  collectGarbage()
-  const after = memoryUsage()
-  return {
-    after,
-    afterOperation,
-    afterOperationDelta: subtract(afterOperation, before),
-    before,
-    delta: subtract(after, before),
-    label,
-  }
-}
-
-function collectGarbage(): void {
-  globalThis.gc?.()
-  globalThis.gc?.()
-}
-
-function memoryUsage(): Memory {
-  const usage = process.memoryUsage()
-  return {
-    arrayBuffers: mebibytes(usage.arrayBuffers),
-    external: mebibytes(usage.external),
-    heapUsed: mebibytes(usage.heapUsed),
-    rss: mebibytes(usage.rss),
-  }
-}
-
-function mebibytes(bytes: number): number {
-  return Math.round((bytes / mebibyte) * 100) / 100
-}
-
-function positiveInteger(name: string, fallback: number): number {
-  const input = process.env[name]
-  if (!input) return fallback
-  const value = Number(input)
-  if (!Number.isSafeInteger(value) || value < 1)
-    throw new Error(`${name} must be a positive integer.`)
-  return value
-}
-
-function subtract(after: Memory, before: Memory): Memory {
-  return {
-    arrayBuffers: after.arrayBuffers - before.arrayBuffers,
-    external: after.external - before.external,
-    heapUsed: after.heapUsed - before.heapUsed,
-    rss: after.rss - before.rss,
-  }
-}
-
-function writeHeapSnapshot(label: string): void {
-  const directory = process.env.WEBHOOK_MEMORY_SNAPSHOT_DIR
-  if (!directory) return
-  fs.mkdirSync(directory, { recursive: true })
-  v8.writeHeapSnapshot(path.join(directory, `${label}.heapsnapshot`))
-}

package/src/Webhooks.test.ts

@@ -1,146 +0,0 @@
-import { Metrics, Webhooks } from 'tapimo'
-import * as TestApp from '../test/App.js'
-
-describe('createPoller', () => {
-  /** Decodes the opaque `(block, index)` keyset cursor the poller stores. */
-  function decodeCursor(token: string | null): [number, number] | null {
-    if (!token) return null
-    const json = atob(token.replaceAll('-', '+').replaceAll('_', '/'))
-    return JSON.parse(json) as [number, number]
-  }
-
-  test('binds a database and runs a tick at an injected head', async () => {
-    const db = TestApp.database()
-    const subscription = await Webhooks.createSubscription(db, {
-      chainId: 42431,
-      destination: { type: 'url', url: 'https://hooks.example.com/x' },
-      eventType: 'token:transfer',
-      owner: { orgId: 'org_test', type: 'api_key' },
-    })
-
-    const poller = Webhooks.createPoller({
-      db,
-      defaultChainId: 42431,
-    })
-
-    // A brand-new subscription anchors at the confirmed head on its first tick
-    // (no backfill), so this exercises the createPoller → poll wiring (db
-    // binding, default chain id, injected head, and result shape) without an
-    // upstream request. Detailed scanner behavior lives in the route test.
-    const result = await poller.tick({ headBlockNumber: 200 })
-
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "chainId": 42431,
-        "dispatched": 0,
-        "failed": 0,
-        "safeBlock": 199,
-        "scanned": 0,
-        "subscriptions": 1,
-      }
-    `)
-    expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toMatchInlineSnapshot(`
-      [
-        199,
-        2147483647,
-      ]
-    `)
-  })
-
-  test('records active subscriptions before scanning', async () => {
-    const db = TestApp.database()
-    await Webhooks.createSubscription(db, {
-      chainId: 42431,
-      destination: { type: 'url', url: 'https://hooks.example.com/x' },
-      eventType: 'block:created',
-      owner: { orgId: 'org_test', type: 'api_key' },
-    })
-    const gauges: { name: string; tags: Metrics.Tags; value: number }[] = []
-    const poller = Webhooks.createPoller({
-      db,
-      defaultChainId: 42431,
-      metrics: Metrics.from({
-        count() {},
-        flush() {},
-        gauge(name, value, tags = {}) {
-          gauges.push({ name, tags, value })
-        },
-        histogram() {},
-      }),
-    })
-
-    await poller.tick({ eventTypes: ['block:created'], headBlockNumber: 200 })
-
-    expect(gauges).toMatchInlineSnapshot(`
-      [
-        {
-          "name": "webhook_poller_active_subscription_count",
-          "tags": {
-            "chain_id": "42431",
-          },
-          "value": 1,
-        },
-        {
-          "name": "webhook_subscription_cursor_lag_blocks",
-          "tags": {
-            "chain_id": "42431",
-          },
-          "value": 0,
-        },
-        {
-          "name": "webhook_poller_safe_block",
-          "tags": {
-            "chain_id": "42431",
-          },
-          "value": 199,
-        },
-      ]
-    `)
-  })
-
-  test('clamps a creation checkpoint to genesis', async () => {
-    const db = TestApp.database()
-    const subscription = await Webhooks.createSubscription(
-      db,
-      {
-        chainId: 42431,
-        destination: { type: 'url', url: 'https://hooks.example.com/x' },
-        eventType: 'block:created',
-        owner: { orgId: 'org_test', type: 'api_key' },
-      },
-      { startBlockNumber: 1 },
-    )
-    const poller = Webhooks.createPoller({
-      db,
-      defaultChainId: 42431,
-    })
-
-    await poller.tick({
-      eventTypes: ['block:created'],
-      headBlockNumber: 1,
-    })
-
-    expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toEqual([0, 2_147_483_647])
-  })
-
-  test('keeps a factory-created database open after each tick', async () => {
-    const db = TestApp.database()
-    await Webhooks.createSubscription(db, {
-      chainId: 42431,
-      destination: { type: 'url', url: 'https://hooks.example.com/x' },
-      eventType: 'block:created',
-      owner: { orgId: 'org_test', type: 'api_key' },
-    })
-    const poller = Webhooks.createPoller({
-      db: () => db,
-      defaultChainId: 42431,
-    })
-
-    await poller.tick({
-      eventTypes: ['block:created'],
-      headBlockNumber: 1,
-    })
-
-    await expect(Webhooks.maxCursorBlock(db, 42431)).resolves.toBe(0)
-  })
-})