@wopr-network/platform-core 0.1.0

package/src/metering/index.ts

@@ -0,0 +1,21 @@
+export type { IMeterAggregator } from "./aggregator.js";
+export { DrizzleMeterAggregator, MeterAggregator } from "./aggregator.js";
+export type {
+  AggregatedWindowRow,
+  IUsageSummaryRepository,
+  UsageSummaryInsert,
+} from "./drizzle-usage-summary-repository.js";
+export { DrizzleUsageSummaryRepository, UsageSummaryRepository } from "./drizzle-usage-summary-repository.js";
+export type { IMeterEmitter } from "./emitter.js";
+export { DrizzleMeterEmitter, MeterEmitter } from "./emitter.js";
+export type { IMeterEventRepository, MeterEventInsert } from "./meter-event-repository.js";
+export { DrizzleMeterEventRepository } from "./meter-event-repository.js";
+export type { ReconciliationConfig, ReconciliationResult } from "./reconciliation-cron.js";
+export { runReconciliation } from "./reconciliation-cron.js";
+export type {
+  BillingPeriod,
+  BillingPeriodSummary,
+  MeterEvent,
+  MeterEventRow,
+  UsageSummary,
+} from "./types.js";

package/src/metering/load-test.bench.ts

@@ -0,0 +1,130 @@
+import { unlinkSync } from "node:fs";
+import type { PGlite } from "@electric-sql/pglite";
+import { afterEach, beforeEach, bench, describe } from "vitest";
+import type { PlatformDb } from "../db/index.js";
+import { createTestDb } from "../test/db.js";
+import { Credit } from "../credits/credit.js";
+import { MeterAggregator } from "./aggregator.js";
+import { DrizzleUsageSummaryRepository } from "./drizzle-usage-summary-repository.js";
+import { MeterEmitter } from "./emitter.js";
+import { DrizzleMeterEventRepository } from "./meter-event-repository.js";
+import type { MeterEvent } from "./types.js";
+
+function makeEvent(i: number): MeterEvent {
+  return {
+    tenant: `tenant-${i % 100}`,
+    cost: Credit.fromDollars(0.001 * (i % 10)),
+    charge: Credit.fromDollars(0.002 * (i % 10)),
+    capability: ["chat", "voice", "embeddings", "tts", "stt"][i % 5],
+    provider: ["openai", "deepgram", "elevenlabs", "openrouter"][i % 4],
+    timestamp: Date.now() - 120_000 + i,
+    sessionId: `session-${i % 50}`,
+    duration: i % 2 === 0 ? 1000 + i : undefined,
+    usage: i % 3 === 0 ? { units: 100 + i, unitType: "tokens" } : undefined,
+    tier: (["branded", "wopr", "byok"] as const)[i % 3],
+  };
+}
+
+describe("MeterEmitter throughput", () => {
+  let db: PlatformDb;
+  let pool: PGlite;
+  let emitter: MeterEmitter;
+  const walPath = `/tmp/wopr-bench-wal-${process.pid}.jsonl`;
+  const dlqPath = `/tmp/wopr-bench-dlq-${process.pid}.jsonl`;
+
+  beforeEach(async () => {
+    ({ db, pool } = await createTestDb());
+    emitter = new MeterEmitter(new DrizzleMeterEventRepository(db), {
+      flushIntervalMs: 60_000,
+      batchSize: 1000,
+      walPath,
+      dlqPath,
+    });
+  });
+
+  afterEach(async () => {
+    emitter.close();
+    await pool.close();
+    try {
+      unlinkSync(walPath);
+    } catch {
+      /* */
+    }
+    try {
+      unlinkSync(dlqPath);
+    } catch {
+      /* */
+    }
+  });
+
+  let eventCounter = 0;
+
+  bench(
+    "emit single event (includes WAL write)",
+    () => {
+      emitter.emit(makeEvent(eventCounter++));
+    },
+    { iterations: 10_000 },
+  );
+
+  bench(
+    "emit + flush batch of 100",
+    async () => {
+      for (let i = 0; i < 100; i++) {
+        emitter.emit(makeEvent(eventCounter++));
+      }
+      await emitter.flush();
+    },
+    { iterations: 100 },
+  );
+
+  bench(
+    "emit + flush batch of 1000",
+    async () => {
+      for (let i = 0; i < 1000; i++) {
+        emitter.emit(makeEvent(eventCounter++));
+      }
+      await emitter.flush();
+    },
+    { iterations: 50 },
+  );
+});
+
+describe("MeterAggregator throughput", () => {
+  let db: PlatformDb;
+  let pool: PGlite;
+  let emitter: MeterEmitter;
+  let aggregator: MeterAggregator;
+  const walPath = `/tmp/wopr-bench-agg-wal-${process.pid}.jsonl`;
+  const dlqPath = `/tmp/wopr-bench-agg-dlq-${process.pid}.jsonl`;
+
+  beforeEach(async () => {
+    ({ db, pool } = await createTestDb());
+    emitter = new MeterEmitter(new DrizzleMeterEventRepository(db), { flushIntervalMs: 60_000, walPath, dlqPath });
+    aggregator = new MeterAggregator(new DrizzleUsageSummaryRepository(db), { windowMs: 60_000 });
+  });
+
+  afterEach(async () => {
+    aggregator.stop();
+    emitter.close();
+    await pool.close();
+    try {
+      unlinkSync(walPath);
+    } catch {
+      /* */
+    }
+    try {
+      unlinkSync(dlqPath);
+    } catch {
+      /* */
+    }
+  });
+
+  bench(
+    "aggregate 10K events",
+    async () => {
+      await aggregator.aggregate();
+    },
+    { iterations: 10 },
+  );
+});

package/src/metering/meter-event-repository.ts

@@ -0,0 +1,87 @@
+import { desc, eq } from "drizzle-orm";
+import type { PlatformDb } from "../db/index.js";
+import { meterEvents } from "../db/schema/meter-events.js";
+import type { MeterEventRow } from "./types.js";
+
+/** Values needed to insert a single meter event row. */
+export interface MeterEventInsert {
+  id: string;
+  tenant: string;
+  cost: number;
+  charge: number;
+  capability: string;
+  provider: string;
+  timestamp: number;
+  sessionId: string | null;
+  duration: number | null;
+  usageUnits: number | null;
+  usageUnitType: string | null;
+  tier: string | null;
+  metadata: string | null;
+}
+
+export interface IMeterEventRepository {
+  /** Check if an event ID already exists in the database. */
+  existsById(id: string): Promise<boolean>;
+  /** Insert a batch of events in a single transaction. */
+  insertBatch(events: MeterEventInsert[]): Promise<void>;
+  /** Query persisted events for a tenant, ordered by timestamp desc. */
+  queryByTenant(tenant: string, limit: number): Promise<MeterEventRow[]>;
+}
+
+export class DrizzleMeterEventRepository implements IMeterEventRepository {
+  constructor(private readonly db: PlatformDb) {}
+
+  async existsById(id: string): Promise<boolean> {
+    const row = (await this.db.select({ id: meterEvents.id }).from(meterEvents).where(eq(meterEvents.id, id)))[0];
+    return !!row;
+  }
+
+  async insertBatch(events: MeterEventInsert[]): Promise<void> {
+    if (events.length === 0) return;
+    await this.db.transaction(async (tx) => {
+      for (const e of events) {
+        await tx.insert(meterEvents).values({
+          id: e.id,
+          tenant: e.tenant,
+          cost: e.cost,
+          charge: e.charge,
+          capability: e.capability,
+          provider: e.provider,
+          timestamp: e.timestamp,
+          sessionId: e.sessionId,
+          duration: e.duration,
+          usageUnits: e.usageUnits,
+          usageUnitType: e.usageUnitType,
+          tier: e.tier,
+          metadata: e.metadata,
+        });
+      }
+    });
+  }
+
+  async queryByTenant(tenant: string, limit: number): Promise<MeterEventRow[]> {
+    const rows = await this.db
+      .select()
+      .from(meterEvents)
+      .where(eq(meterEvents.tenant, tenant))
+      .orderBy(desc(meterEvents.timestamp))
+      .limit(limit);
+
+    return rows.map((r) => ({
+      id: r.id,
+      tenant: r.tenant,
+      cost: r.cost,
+      charge: r.charge,
+      capability: r.capability,
+      provider: r.provider,
+      timestamp: r.timestamp,
+      session_id: r.sessionId,
+      duration: r.duration,
+      usage_units: r.usageUnits,
+      usage_unit_type: r.usageUnitType,
+      tier: r.tier,
+      metadata: r.metadata,
+    }));
+  }
+}