Consolidate MCP metrics helpers and add regression tests

utils/mcp/__tests__/metrics.test.ts

@@ -0,0 +1,130 @@
+const BASE_TIME_MS = Date.UTC(2026, 0, 1, 0, 0, 0);
+const ONE_MINUTE_MS = 60 * 1000;
+const FIVE_MINUTES_MS = 5 * ONE_MINUTE_MS;
+const ONE_HOUR_MS = 60 * ONE_MINUTE_MS;
+const MAX_REQUEST_RECORDS = 10000;
+
+describe("MCP metrics helpers", () => {
+  let metricsModule: typeof import("../metrics");
+  let compatModule: typeof import("../metric");
+
+  beforeEach(async () => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+    jest.setSystemTime(BASE_TIME_MS);
+
+    metricsModule = await import("../metrics");
+    compatModule = await import("../metric");
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("tracks current metrics behavior and exposes additive observability fields", () => {
+    metricsModule.recordRequest(100, true, "search_products");
+    metricsModule.recordRequest(300, false, "search_products");
+    metricsModule.recordRequest(500, true, "get_product_details");
+
+    const metrics = metricsModule.getMetrics();
+
+    expect(metrics.status).toBe("healthy");
+    expect(metrics.uptime.ms).toBe(0);
+    expect(metrics.uptime.human).toBe("0h 0m");
+    expect(metrics.uptime.startedAt).toBe("2026-01-01T00:00:00.000Z");
+    expect(metrics.uptime.durationSeconds).toBe(0);
+    expect(metrics.uptime.durationHuman).toBe("0s");
+
+    expect(metrics.latency).toEqual({
+      p50: 300,
+      p95: 500,
+      p99: 500,
+      unit: "ms",
+      sampleSize: 3,
+      window: "5m",
+    });
+
+    expect(metrics.throughput).toEqual({
+      total: 3,
+      successful: 2,
+      failed: 1,
+      reliabilityRate: "66.67%",
+      requestsPerMinute: 0.6,
+      recentRequests: 3,
+    });
+
+    expect(metrics.toolUsage).toEqual({
+      search_products: 2,
+      get_product_details: 1,
+    });
+  });
+
+  it("keeps cumulative counters while recent-window fields only include the last five minutes", () => {
+    metricsModule.recordRequest(100, true, "older_request");
+
+    jest.advanceTimersByTime(FIVE_MINUTES_MS + ONE_MINUTE_MS);
+
+    metricsModule.recordRequest(200, false, "recent_request");
+    const metrics = metricsModule.getMetrics();
+
+    expect(metrics.latency.p50).toBe(100);
+    expect(metrics.latency.p95).toBe(200);
+    expect(metrics.latency.p99).toBe(200);
+    expect(metrics.latency.sampleSize).toBe(1);
+
+    expect(metrics.throughput.total).toBe(2);
+    expect(metrics.throughput.successful).toBe(1);
+    expect(metrics.throughput.failed).toBe(1);
+    expect(metrics.throughput.reliabilityRate).toBe("50.00%");
+    expect(metrics.throughput.requestsPerMinute).toBe(0.2);
+    expect(metrics.throughput.recentRequests).toBe(1);
+
+    expect(metrics.toolUsage).toEqual({
+      older_request: 1,
+      recent_request: 1,
+    });
+  });
+
+  it("resets onboarding rate limits after the existing one-hour window", () => {
+    for (let i = 0; i < 10; i += 1) {
+      expect(metricsModule.checkOnboardRateLimit("127.0.0.1")).toBe(true);
+    }
+
+    expect(metricsModule.checkOnboardRateLimit("127.0.0.1")).toBe(false);
+
+    jest.advanceTimersByTime(ONE_HOUR_MS + 1);
+
+    expect(metricsModule.checkOnboardRateLimit("127.0.0.1")).toBe(true);
+  });
+
+  it("shares state through the compatibility re-export", () => {
+    compatModule.recordRequest(250, true, "compat_request");
+    metricsModule.recordRequest(750, false, "live_request");
+
+    const metricsFromCompat = compatModule.getMetrics();
+    const metricsFromLive = metricsModule.getMetrics();
+
+    expect(metricsFromCompat).toEqual(metricsFromLive);
+    expect(metricsFromLive.throughput.total).toBe(2);
+    expect(metricsFromLive.toolUsage).toEqual({
+      compat_request: 1,
+      live_request: 1,
+    });
+  });
+
+  it("trims recent request records without changing all-time totals", () => {
+    for (let i = 0; i < MAX_REQUEST_RECORDS + 1; i += 1) {
+      metricsModule.recordRequest(100, true);
+    }
+
+    const metrics = metricsModule.getMetrics();
+
+    expect(metrics.throughput.total).toBe(MAX_REQUEST_RECORDS + 1);
+    expect(metrics.throughput.successful).toBe(MAX_REQUEST_RECORDS + 1);
+    expect(metrics.throughput.failed).toBe(0);
+    expect(metrics.throughput.reliabilityRate).toBe("100.00%");
+    expect(metrics.throughput.recentRequests).toBe(MAX_REQUEST_RECORDS);
+    expect(metrics.latency.sampleSize).toBe(MAX_REQUEST_RECORDS);
+  });
+});

utils/mcp/auth.ts

@@ -96,7 +96,7 @@ export async function initializeApiKeysTable(): Promise<void> {
       CREATE INDEX IF NOT EXISTS idx_mcp_api_keys_pubkey ON mcp_api_keys(pubkey);
 
       CREATE TABLE IF NOT EXISTS mcp_request_proofs (
-        event_id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL,
         pubkey TEXT NOT NULL,
         action TEXT NOT NULL,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

utils/mcp/metric.ts

@@ -1,116 +1,5 @@
-const SERVER_START_TIME = Date.now();
-
-interface RequestRecord {
-  timestamp: number;
-  durationMs: number;
-  success: boolean;
-  tool?: string;
-}
-
-const MAX_RECORDS = 10000;
-const records: RequestRecord[] = [];
-
-const onboardAttempts = new Map<
-  string,
-  { count: number; windowStart: number }
->();
-
-export function recordRequest(
-  durationMs: number,
-  success: boolean,
-  tool?: string
-) {
-  records.push({ timestamp: Date.now(), durationMs, success, tool });
-  if (records.length > MAX_RECORDS) {
-    records.splice(0, records.length - MAX_RECORDS);
-  }
-}
-
-export function getMetrics() {
-  const now = Date.now();
-  const uptimeMs = now - SERVER_START_TIME;
-
-  const recentWindow = 5 * 60 * 1000;
-  const recentRecords = records.filter((r) => now - r.timestamp < recentWindow);
-
-  const totalRequests = records.length;
-  const totalErrors = records.filter((r) => !r.success).length;
-  const successRate =
-    totalRequests > 0
-      ? parseFloat(((1 - totalErrors / totalRequests) * 100).toFixed(2))
-      : 100;
-
-  const durations = recentRecords
-    .map((r) => r.durationMs)
-    .sort((a, b) => a - b);
-
-  const p50 = percentile(durations, 50);
-  const p95 = percentile(durations, 95);
-  const p99 = percentile(durations, 99);
-
-  const requestsPerMinute =
-    recentRecords.length > 0
-      ? parseFloat((recentRecords.length / (recentWindow / 60000)).toFixed(1))
-      : 0;
-
-  return {
-    status: "operational" as const,
-    uptime: {
-      startedAt: new Date(SERVER_START_TIME).toISOString(),
-      durationSeconds: Math.floor(uptimeMs / 1000),
-      durationHuman: formatDuration(uptimeMs),
-    },
-    latency: {
-      p50,
-      p95,
-      p99,
-      unit: "ms",
-      sampleSize: durations.length,
-      window: "5m",
-    },
-    throughput: {
-      requestsPerMinute,
-      totalRequests,
-      recentRequests: recentRecords.length,
-    },
-    reliability: {
-      successRate,
-      errorRate: parseFloat((100 - successRate).toFixed(2)),
-      totalErrors,
-    },
-  };
-}
-
-function percentile(sorted: number[], pct: number): number {
-  if (sorted.length === 0) return 0;
-  const idx = Math.ceil((pct / 100) * sorted.length) - 1;
-  return sorted[Math.max(0, idx)]!;
-}
-
-function formatDuration(ms: number): string {
-  const seconds = Math.floor(ms / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const days = Math.floor(hours / 24);
-
-  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
-  if (hours > 0) return `${hours}h ${minutes % 60}m`;
-  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
-  return `${seconds}s`;
-}
-
-export function checkOnboardRateLimit(ip: string): boolean {
-  const now = Date.now();
-  const windowMs = 60 * 60 * 1000;
-  const maxAttempts = 10;
-
-  const entry = onboardAttempts.get(ip);
-  if (!entry || now - entry.windowStart > windowMs) {
-    onboardAttempts.set(ip, { count: 1, windowStart: now });
-    return true;
-  }
-
-  if (entry.count >= maxAttempts) return false;
-  entry.count++;
-  return true;
-}
+export {
+  checkOnboardRateLimit,
+  getMetrics,
+  recordRequest,
+} from "./metrics";

utils/mcp/metrics.ts

@@ -1,4 +1,17 @@
+interface RequestRecord {
+  timestamp: number;
+  durationMs: number;
+  success: boolean;
+  tool?: string;
+}
+
+const MAX_REQUEST_DURATION_SAMPLES = 1000;
+const MAX_REQUEST_RECORDS = 10000;
+const RECENT_WINDOW_MS = 5 * 60 * 1000;
+const ONE_HOUR_MS = 60 * 60 * 1000;
+
 const requestDurations: number[] = [];
+const requestRecords: RequestRecord[] = [];
 let totalRequests = 0;
 let successfulRequests = 0;
 let failedRequests = 0;
@@ -12,14 +25,24 @@ export function recordRequest(
   success: boolean,
   toolName?: string
 ) {
+  requestRecords.push({
+    timestamp: Date.now(),
+    durationMs,
+    success,
+    tool: toolName,
+  });
+  if (requestRecords.length > MAX_REQUEST_RECORDS) {
+    requestRecords.shift();
+  }
+
   totalRequests++;
   if (success) {
     successfulRequests++;
   } else {
     failedRequests++;
   }
   requestDurations.push(durationMs);
-  if (requestDurations.length > 1000) {
+  if (requestDurations.length > MAX_REQUEST_DURATION_SAMPLES) {
     requestDurations.shift();
   }
   if (toolName) {
@@ -34,20 +57,42 @@ function percentile(arr: number[], p: number): number {
   return sorted[Math.max(0, idx)]!;
 }
 
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
 export function getMetrics() {
-  const uptimeMs = Date.now() - startTime;
+  const now = Date.now();
+  const uptimeMs = now - startTime;
+  const recentRecords = requestRecords.filter(
+    (record) => now - record.timestamp < RECENT_WINDOW_MS
+  );
   return {
     status: "healthy",
     uptime: {
       ms: uptimeMs,
       human: `${Math.floor(uptimeMs / 3600000)}h ${Math.floor(
         (uptimeMs % 3600000) / 60000
       )}m`,
+      startedAt: new Date(startTime).toISOString(),
+      durationSeconds: Math.floor(uptimeMs / 1000),
+      durationHuman: formatDuration(uptimeMs),
     },
     latency: {
       p50: percentile(requestDurations, 50),
       p95: percentile(requestDurations, 95),
       p99: percentile(requestDurations, 99),
+      unit: "ms",
+      sampleSize: recentRecords.length,
+      window: "5m",
     },
     throughput: {
       total: totalRequests,
@@ -57,6 +102,13 @@ export function getMetrics() {
         totalRequests > 0
           ? ((successfulRequests / totalRequests) * 100).toFixed(2) + "%"
           : "N/A",
+      requestsPerMinute:
+        recentRecords.length > 0
+          ? parseFloat(
+              (recentRecords.length / (RECENT_WINDOW_MS / 60000)).toFixed(1)
+            )
+          : 0,
+      recentRequests: recentRecords.length,
     },
     toolUsage,
   };
@@ -67,7 +119,7 @@ export function checkOnboardRateLimit(ip: string): boolean {
   const entry = onboardRateLimits.get(ip);
 
   if (!entry || now > entry.resetAt) {
-    onboardRateLimits.set(ip, { count: 1, resetAt: now + 3600000 });
+    onboardRateLimits.set(ip, { count: 1, resetAt: now + ONE_HOUR_MS });
     return true;
   }