ldrouter 1.18.2 → 1.19.0

package/dist/server/routes/admin/stats.js

@@ -2,6 +2,7 @@
 import { and, eq, gte, lte, sql, desc } from 'drizzle-orm';
 import { getDb, schema } from '../../db/index.js';
 import { requireAdminAuth } from '../../auth/middleware.js';
+import { GatewayError } from '../../errors.js';
 import { toSummary, loadSummaryMaps } from './requests.js';
 const PRESETS = {
     today: () => {
@@ -62,6 +63,19 @@ export async function registerStatsRoutes(app) {
         const fromIso = from.toISOString();
         const toIso = to.toISOString();
         const conds = [gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso)];
+        const utcToday = new Date().toISOString().slice(0, 10);
+        const aggregateRows = db.select().from(schema.dailyModelStats).where(and(gte(schema.dailyModelStats.day, fromIso.slice(0, 10)), lte(schema.dailyModelStats.day, toIso.slice(0, 10)))).all();
+        const overlappingAggregateDays = [...new Set(aggregateRows.map((r) => r.day))].filter((day) => day < utcToday && `${day}T00:00:00.000Z` <= toIso && `${day}T23:59:59.999Z` >= fromIso);
+        const aggregateDays = overlappingAggregateDays.filter((day) => `${day}T00:00:00.000Z` >= fromIso && `${day}T23:59:59.999Z` <= toIso);
+        if (aggregateDays.length !== overlappingAggregateDays.length) {
+            throw new GatewayError('invalid_request_error', 'Statistics ranges overlapping compacted history must include complete UTC days.', { status: 400 });
+        }
+        const percentilesAvailable = aggregateDays.length === 0;
+        const aggregateOnly = aggregateDays.length > 0;
+        const rawConds = aggregateDays.length
+            ? and(...conds, sql `substr(created_at,1,10) NOT IN (${sql.join(aggregateDays.map((day) => sql `${day}`), sql `, `)})`)
+            : and(...conds);
+        const aggregateTotals = aggregateRows.filter((r) => aggregateDays.includes(r.day)).reduce((a, r) => ({ total: a.total + r.requests, success: a.success + r.successfulRequests, failed: a.failed + r.failedRequests, input: a.input + r.inputTokens, output: a.output + r.outputTokens, cacheRead: a.cacheRead + r.cacheReadTokens, cacheWrite: a.cacheWrite + r.cacheWriteTokens, reasoning: a.reasoning + r.reasoningTokens, gateway: a.gateway + r.gatewayCacheHits, fallback: a.fallback + r.fallbackRequests, latencySum: a.latencySum + r.latencySuccessSumMs, latencyCount: a.latencyCount + r.latencySuccessCount, ttftSum: a.ttftSum + r.ttftSumMs, ttftCount: a.ttftCount + r.ttftCount }), { total: 0, success: 0, failed: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, gateway: 0, fallback: 0, latencySum: 0, latencyCount: 0, ttftSum: 0, ttftCount: 0 });
         const summary = db
             .select({
             total: sql `COUNT(*)`,
@@ -76,13 +90,14 @@ export async function registerStatsRoutes(app) {
             fallbacks: sql `SUM(CASE WHEN attempts_count > 1 THEN 1 ELSE 0 END)`,
         })
             .from(schema.requests)
-            .where(and(...conds))
+            .where(rawConds)
             .get();
-        const cacheHitRate = cacheHitRateFor(db, conds);
+        // Aggregate rows retain cache counts but not provider-specific prompt denominator semantics.
+        const cacheHitRate = aggregateDays.length ? null : cacheHitRateFor(db, conds);
         const latRows = db
             .select({ v: schema.requests.totalLatencyMs })
             .from(schema.requests)
-            .where(and(...conds, eq(schema.requests.success, true)))
+            .where(and(rawConds, eq(schema.requests.success, true)))
             .all();
         const latencies = latRows.map((r) => r.v).filter((v) => v > 0).sort((a, b) => a - b);
         const avg = latencies.length ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0;
@@ -90,32 +105,32 @@ export async function registerStatsRoutes(app) {
         const ttftRows = db
             .select({ v: schema.requests.ttftMs })
             .from(schema.requests)
-            .where(and(...conds, sql `ttft_ms IS NOT NULL`))
+            .where(and(rawConds, sql `ttft_ms IS NOT NULL`))
             .all();
         const ttfts = ttftRows.map((r) => r.v).filter((v) => v !== null).sort((a, b) => a - b);
         const avgTtft = ttfts.length ? ttfts.reduce((a, b) => a + b, 0) / ttfts.length : null;
         const p95Ttft = ttfts.length ? percentile(ttfts, 95) : null;
-        const total = Number(summary?.total ?? 0);
-        const success = Number(summary?.success ?? 0);
-        const failed = Number(summary?.failed ?? 0);
+        const total = Number(summary?.total ?? 0) + aggregateTotals.total;
+        const success = Number(summary?.success ?? 0) + aggregateTotals.success;
+        const failed = Number(summary?.failed ?? 0) + aggregateTotals.failed;
         const statsSummary = {
             totalRequests: total,
             successfulRequests: success,
             failedRequests: failed,
             successRate: total ? success / total : 0,
-            inputTokens: Number(summary?.inputTokens ?? 0),
-            outputTokens: Number(summary?.outputTokens ?? 0),
-            totalTokens: Number(summary?.inputTokens ?? 0) + Number(summary?.outputTokens ?? 0),
-            cacheReadTokens: Number(summary?.cacheRead ?? 0),
-            cacheWriteTokens: Number(summary?.cacheWrite ?? 0),
-            reasoningTokens: Number(summary?.reasoning ?? 0),
-            averageLatencyMs: avg,
-            p95LatencyMs: p95,
-            averageTtftMs: avgTtft,
-            p95TtftMs: p95Ttft,
+            inputTokens: Number(summary?.inputTokens ?? 0) + aggregateTotals.input,
+            outputTokens: Number(summary?.outputTokens ?? 0) + aggregateTotals.output,
+            totalTokens: Number(summary?.inputTokens ?? 0) + aggregateTotals.input + Number(summary?.outputTokens ?? 0) + aggregateTotals.output,
+            cacheReadTokens: Number(summary?.cacheRead ?? 0) + aggregateTotals.cacheRead,
+            cacheWriteTokens: Number(summary?.cacheWrite ?? 0) + aggregateTotals.cacheWrite,
+            reasoningTokens: Number(summary?.reasoning ?? 0) + aggregateTotals.reasoning,
+            averageLatencyMs: aggregateOnly ? (aggregateTotals.latencySum + latencies.reduce((a, b) => a + b, 0)) / (aggregateTotals.latencyCount + latencies.length || 1) : avg,
+            p95LatencyMs: percentilesAvailable ? p95 : null,
+            averageTtftMs: aggregateOnly ? (aggregateTotals.ttftSum + ttfts.reduce((a, b) => a + b, 0)) / (aggregateTotals.ttftCount + ttfts.length || 1) : avgTtft,
+            p95TtftMs: percentilesAvailable ? p95Ttft : null,
             cacheHitRate,
-            gatewayCacheHitRate: total ? Number(summary?.gatewayCacheHits ?? 0) / total : 0,
-            fallbackRate: total ? Number(summary?.fallbacks ?? 0) / total : 0,
+            gatewayCacheHitRate: total ? (Number(summary?.gatewayCacheHits ?? 0) + aggregateTotals.gateway) / total : 0,
+            fallbackRate: total ? (Number(summary?.fallbacks ?? 0) + aggregateTotals.fallback) / total : 0,
         };
         // Time-bucketed series
         const bucketExpr = bucket === 'hour' ? sql `strftime('%Y-%m-%dT%H:00:00Z', created_at)` : sql `strftime('%Y-%m-%dT00:00:00Z', created_at)`;
@@ -130,10 +145,18 @@ export async function registerStatsRoutes(app) {
             cacheRead: sql `COALESCE(SUM(cache_read_tokens),0)`,
         })
             .from(schema.requests)
-            .where(and(...conds))
+            .where(rawConds)
             .groupBy(bucketExpr)
             .orderBy(bucketExpr)
             .all();
+        const seriesMap = new Map(seriesRows.map((r) => [r.t, { t: r.t, requests: Number(r.requests), errors: Number(r.errors), inputTokens: Number(r.inputTokens), outputTokens: Number(r.outputTokens), avgLatency: Number(r.avgLatency ?? 0), cacheRead: Number(r.cacheRead ?? 0) }]));
+        for (const r of aggregateRows.filter((x) => aggregateDays.includes(x.day))) {
+            const t = `${r.day}T00:00:00Z`;
+            const old = seriesMap.get(t) ?? { t, requests: 0, errors: 0, inputTokens: 0, outputTokens: 0, avgLatency: 0, cacheRead: 0 };
+            const oldSuccesses = old.requests - old.errors;
+            const count = oldSuccesses + r.latencySuccessCount;
+            seriesMap.set(t, { t, requests: old.requests + r.requests, errors: old.errors + r.failedRequests, inputTokens: old.inputTokens + r.inputTokens, outputTokens: old.outputTokens + r.outputTokens, avgLatency: count ? (old.avgLatency * oldSuccesses + r.latencySuccessSumMs) / count : 0, cacheRead: old.cacheRead + r.cacheReadTokens });
+        }
         // Top models
         const topModels = db
             .select({
@@ -143,7 +166,7 @@ export async function registerStatsRoutes(app) {
             tokens: sql `COALESCE(SUM(total_tokens),0)`,
         })
             .from(schema.requests)
-            .where(and(...conds))
+            .where(rawConds)
             .groupBy(schema.requests.finalModelId)
             // Order by the aggregate expression itself: SQLite rejects ORDER BY on a
             // quoted select alias ("no such column: c").
@@ -152,6 +175,23 @@ export async function registerStatsRoutes(app) {
             .all();
         const models = db.select().from(schema.models).all();
         const modelMap = new Map(models.map((m) => [m.id, m]));
+        const mergedModels = new Map();
+        for (const r of topModels) {
+            const id = r.modelId ? modelMap.get(r.modelId)?.publicModelId ?? r.modelId : 'unknown';
+            const v = mergedModels.get(id) ?? { requests: 0, errors: 0, tokens: 0 };
+            v.requests += Number(r.c);
+            v.errors += Number(r.err);
+            v.tokens += Number(r.tokens);
+            mergedModels.set(id, v);
+        }
+        for (const r of aggregateRows.filter((x) => aggregateDays.includes(x.day))) {
+            const id = r.modelId ? modelMap.get(r.modelId)?.publicModelId ?? r.modelId : 'unknown';
+            const v = mergedModels.get(id) ?? { requests: 0, errors: 0, tokens: 0 };
+            v.requests += r.requests;
+            v.errors += r.failedRequests;
+            v.tokens += r.inputTokens + r.outputTokens;
+            mergedModels.set(id, v);
+        }
         const topKeys = db
             .select({
             apiKeyId: schema.requests.apiKeyId,
@@ -159,13 +199,29 @@ export async function registerStatsRoutes(app) {
             tokens: sql `COALESCE(SUM(total_tokens),0)`,
         })
             .from(schema.requests)
-            .where(and(...conds))
+            .where(rawConds)
             .groupBy(schema.requests.apiKeyId)
             .orderBy(desc(sql `COUNT(*)`))
             .limit(10)
             .all();
         const keys = db.select().from(schema.apiKeys).all();
         const keyMap = new Map(keys.map((k) => [k.id, k]));
+        const mergedKeys = new Map();
+        for (const r of topKeys) {
+            const id = r.apiKeyId ? keyMap.get(r.apiKeyId)?.name ?? 'deleted' : 'unknown';
+            const v = mergedKeys.get(id) ?? { requests: 0, tokens: 0 };
+            v.requests += Number(r.c);
+            v.tokens += Number(r.tokens);
+            mergedKeys.set(id, v);
+        }
+        const keyAggregateRows = db.select().from(schema.dailyApiKeyStats).where(and(gte(schema.dailyApiKeyStats.day, fromIso.slice(0, 10)), lte(schema.dailyApiKeyStats.day, toIso.slice(0, 10)))).all().filter((r) => aggregateDays.includes(r.day));
+        for (const r of keyAggregateRows) {
+            const id = r.apiKeyId ? keyMap.get(r.apiKeyId)?.name ?? 'deleted' : 'unknown';
+            const v = mergedKeys.get(id) ?? { requests: 0, tokens: 0 };
+            v.requests += r.requests;
+            v.tokens += r.totalTokens;
+            mergedKeys.set(id, v);
+        }
         // ─── Previous period (for delta badges in summary cards) ───────────────
         const durationMs = to.getTime() - from.getTime();
         const prevFrom = new Date(from.getTime() - durationMs).toISOString();
@@ -200,43 +256,44 @@ export async function registerStatsRoutes(app) {
             .groupBy(schema.models.providerId)
             .all();
         const countMap = new Map(modelCounts.map((r) => [r.providerId, Number(r.c)]));
-        const providers = providerAggs
-            .map((r) => {
-            const p = providerLookup.get(r.providerId);
+        const providerTotals = new Map(providerAggs.map((r) => [r.providerId, { total: Number(r.total), errors: Number(r.err), latencySum: Number(r.avgLat) * (Number(r.total) - Number(r.err)), latencyCount: Number(r.total) - Number(r.err) }]));
+        const providerAggregateRows = db.select().from(schema.dailyProviderStats).where(and(gte(schema.dailyProviderStats.day, fromIso.slice(0, 10)), lte(schema.dailyProviderStats.day, toIso.slice(0, 10)))).all().filter((r) => aggregateDays.includes(r.day));
+        for (const r of providerAggregateRows) {
+            const a = providerTotals.get(r.providerId) ?? { total: 0, errors: 0, latencySum: 0, latencyCount: 0 };
+            a.total += r.attempts;
+            a.errors += r.failedAttempts;
+            a.latencySum += r.latencySuccessSumMs;
+            a.latencyCount += r.latencySuccessCount;
+            providerTotals.set(r.providerId, a);
+        }
+        const providers = [...providerTotals].map(([providerId, r]) => {
+            const p = providerLookup.get(providerId);
             if (!p)
                 return null;
-            const total = Number(r.total);
+            const total = r.total;
             return {
-                id: r.providerId,
+                id: providerId,
                 name: p.name,
                 slug: p.slug,
                 health: p.healthState,
                 enabled: p.enabled,
-                modelCount: countMap.get(r.providerId) ?? 0,
+                modelCount: countMap.get(providerId) ?? 0,
                 requests: total,
-                errorRate: total > 0 ? Number(r.err) / total : 0,
-                avgLatencyMs: Number(r.avgLat),
+                errorRate: total > 0 ? r.errors / total : 0,
+                avgLatencyMs: r.latencyCount ? r.latencySum / r.latencyCount : 0,
             };
         })
             .filter((x) => x !== null)
             .sort((a, b) => b.requests - a.requests);
         const range = { from: fromIso, to: toIso, bucket };
         return {
+            percentilesAvailable,
             range,
             summary: statsSummary,
             previous: previousSummary,
-            series: seriesRows.map((r) => ({ t: r.t, requests: Number(r.requests), errors: Number(r.errors), inputTokens: Number(r.inputTokens), outputTokens: Number(r.outputTokens), avgLatency: Number(r.avgLatency ?? 0), cacheRead: Number(r.cacheRead ?? 0) })),
-            topModels: topModels.map((r) => ({
-                publicId: r.modelId ? modelMap.get(r.modelId)?.publicModelId ?? r.modelId : 'unknown',
-                requests: Number(r.c),
-                errorRate: Number(r.c) > 0 ? Number(r.err) / Number(r.c) : 0,
-                totalTokens: Number(r.tokens),
-            })),
-            topApiKeys: topKeys.map((r) => ({
-                name: r.apiKeyId ? keyMap.get(r.apiKeyId)?.name ?? 'deleted' : 'unknown',
-                requests: Number(r.c),
-                totalTokens: Number(r.tokens),
-            })),
+            series: [...seriesMap.values()].sort((a, b) => a.t.localeCompare(b.t)),
+            topModels: [...mergedModels].map(([publicId, v]) => ({ publicId, requests: v.requests, errorRate: v.requests ? v.errors / v.requests : 0, totalTokens: v.tokens })).sort((a, b) => b.requests - a.requests).slice(0, 10),
+            topApiKeys: [...mergedKeys].map(([name, v]) => ({ name, requests: v.requests, totalTokens: v.tokens })).sort((a, b) => b.requests - a.requests).slice(0, 10),
             recent,
             providers,
         };
@@ -247,6 +304,12 @@ export async function registerStatsRoutes(app) {
  * incremental aggregation). Returns counts sufficient to derive ratios.
  */
 function buildSummary(db, fromIso, toIso) {
+    // For previous period, use the same aggregate/raw partition as the primary range.
+    const days = db.select().from(schema.dailyModelStats).where(and(gte(schema.dailyModelStats.day, fromIso.slice(0, 10)), lte(schema.dailyModelStats.day, toIso.slice(0, 10)))).all();
+    const daySet = [...new Set(days.map((x) => x.day))].filter((day) => day < new Date().toISOString().slice(0, 10) && `${day}T00:00:00.000Z` >= fromIso && `${day}T23:59:59.999Z` <= toIso);
+    const aggregates = days.filter((x) => daySet.includes(x.day));
+    const rawOnly = daySet.length ? and(gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso), sql `substr(created_at,1,10) NOT IN (${sql.join(daySet.map((day) => sql `${day}`), sql `, `)})`) : and(gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso));
+    const agg = aggregates.reduce((a, x) => ({ total: a.total + x.requests, success: a.success + x.successfulRequests, failed: a.failed + x.failedRequests, input: a.input + x.inputTokens, output: a.output + x.outputTokens, cacheRead: a.cacheRead + x.cacheReadTokens, cacheWrite: a.cacheWrite + x.cacheWriteTokens, reasoning: a.reasoning + x.reasoningTokens, gateway: a.gateway + x.gatewayCacheHits, fallback: a.fallback + x.fallbackRequests, latency: a.latency + x.latencySuccessSumMs, latencyCount: a.latencyCount + x.latencySuccessCount, ttft: a.ttft + x.ttftSumMs, ttftCount: a.ttftCount + x.ttftCount }), { total: 0, success: 0, failed: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, gateway: 0, fallback: 0, latency: 0, latencyCount: 0, ttft: 0, ttftCount: 0 });
     const conds = [gte(schema.requests.createdAt, fromIso), lte(schema.requests.createdAt, toIso)];
     const r = db
         .select({
@@ -258,37 +321,42 @@ function buildSummary(db, fromIso, toIso) {
         cacheRead: sql `COALESCE(SUM(cache_read_tokens),0)`,
         cacheWrite: sql `COALESCE(SUM(cache_write_tokens),0)`,
         reasoning: sql `COALESCE(SUM(reasoning_tokens),0)`,
-        avgLatency: sql `COALESCE(AVG(CASE WHEN success=1 THEN total_latency_ms END),0)`,
-        avgTtft: sql `AVG(CASE WHEN success=1 AND ttft_ms IS NOT NULL THEN ttft_ms END)`,
+        latencySum: sql `COALESCE(SUM(CASE WHEN success=1 THEN total_latency_ms ELSE 0 END),0)`,
+        latencyCount: sql `SUM(CASE WHEN success=1 AND total_latency_ms > 0 THEN 1 ELSE 0 END)`,
+        ttftSum: sql `COALESCE(SUM(CASE WHEN success=1 THEN COALESCE(ttft_ms,0) ELSE 0 END),0)`,
+        ttftCount: sql `SUM(CASE WHEN success=1 AND ttft_ms IS NOT NULL THEN 1 ELSE 0 END)`,
         gatewayCacheHits: sql `SUM(CASE WHEN gateway_cache_hit=1 THEN 1 ELSE 0 END)`,
         fallbacks: sql `SUM(CASE WHEN attempts_count > 1 THEN 1 ELSE 0 END)`,
     })
         .from(schema.requests)
-        .where(and(...conds))
+        .where(rawOnly)
         .get();
-    const total = Number(r?.total ?? 0);
-    const success = Number(r?.success ?? 0);
-    const cacheRead = Number(r?.cacheRead ?? 0);
-    const inputTokens = Number(r?.inputTokens ?? 0);
-    const cacheHitRate = cacheHitRateFor(db, conds);
+    const total = Number(r?.total ?? 0) + agg.total;
+    const success = Number(r?.success ?? 0) + agg.success;
+    const failed = Number(r?.failed ?? 0) + agg.failed;
+    const inputTokens = Number(r?.inputTokens ?? 0) + agg.input;
+    const outputTokens = Number(r?.outputTokens ?? 0) + agg.output;
+    const latencyCount = Number(r?.latencyCount ?? 0) + agg.latencyCount;
+    const ttftCount = Number(r?.ttftCount ?? 0) + agg.ttftCount;
+    const cacheHitRate = daySet.length ? null : cacheHitRateFor(db, conds);
     return {
         totalRequests: total,
         successfulRequests: success,
-        failedRequests: Number(r?.failed ?? 0),
+        failedRequests: failed,
         successRate: total ? success / total : 0,
         inputTokens,
-        outputTokens: Number(r?.outputTokens ?? 0),
-        totalTokens: inputTokens + Number(r?.outputTokens ?? 0),
-        cacheReadTokens: cacheRead,
-        cacheWriteTokens: Number(r?.cacheWrite ?? 0),
-        reasoningTokens: Number(r?.reasoning ?? 0),
-        averageLatencyMs: Number(r?.avgLatency ?? 0),
-        p95LatencyMs: 0, // caller fills via percentile query
-        averageTtftMs: (r?.avgTtft ?? null),
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        cacheReadTokens: Number(r?.cacheRead ?? 0) + agg.cacheRead,
+        cacheWriteTokens: Number(r?.cacheWrite ?? 0) + agg.cacheWrite,
+        reasoningTokens: Number(r?.reasoning ?? 0) + agg.reasoning,
+        averageLatencyMs: latencyCount ? (Number(r?.latencySum ?? 0) + agg.latency) / latencyCount : 0,
+        p95LatencyMs: null,
+        averageTtftMs: ttftCount ? (Number(r?.ttftSum ?? 0) + agg.ttft) / ttftCount : null,
         p95TtftMs: null,
         cacheHitRate,
-        gatewayCacheHitRate: total ? Number(r?.gatewayCacheHits ?? 0) / total : 0,
-        fallbackRate: total ? Number(r?.fallbacks ?? 0) / total : 0,
+        gatewayCacheHitRate: total ? (Number(r?.gatewayCacheHits ?? 0) + agg.gateway) / total : 0,
+        fallbackRate: total ? (Number(r?.fallbacks ?? 0) + agg.fallback) / total : 0,
     };
 }
 function percentile(sorted, p) {