mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-08-08 00:02:20 +03:00
342cd87e12
Add an `endpoint` column to `usage_history` (migration 103) so the proxy records which API entry point a request came through — typically `/v1/chat/completions`, `/v1/messages`, or `/v1/responses`. Every `saveRequestUsage(...)` call site in `open-sse/handlers/chatCore.ts` (success, stream, failure) and the codex-responses-ws route now plumbs the endpoint through, and a new `getEndpointUsageRows(...)` analytics query in `src/lib/db/usageAnalytics.ts` aggregates per endpoint × provider × model with NULL → 'unknown' folding for backward compatibility with rows from before the migration. The aggregation reads directly from `usage_history` (matching the `getAutoRoutingVariantBreakdown` pattern) so the existing unified-source CTE — and the `daily_usage_summary` rollup it joins — stay untouched. TDD: tests/unit/usage-endpoint-dimension.test.ts covers persistence round-trip, NULL fallback, and the sinceIso filter (3/3 passing). Co-authored-by: toanalien <toanalien@gmail.com> Inspired-by: https://github.com/decolua/9router/pull/152
80 lines
3.0 KiB
TypeScript
80 lines
3.0 KiB
TypeScript
/**
|
|
* chatCore streaming usage-stats persistence (Quality Gate v2 / Fase 9 — chatCore god-file
|
|
* decomposition, #3501).
|
|
*
|
|
* Extracted from handleChatCore's onStreamComplete: records per-request usage analytics for a
|
|
* completed streaming response — the fire-and-forget `saveRequestUsage` row and the per-api-key
|
|
* billable-token counter (only on a 200 stream). Side-effect only (no handler state is mutated,
|
|
* nothing is returned); best-effort, every write swallows its own errors. The per-request context
|
|
* is threaded via `ctx` so the call site stays byte-identical; behaviour is unchanged. The
|
|
* compression usage-receipt attach stays in the handler (it is a handler-bound closure).
|
|
*/
|
|
|
|
import { saveRequestUsage } from "@/lib/usageDb";
|
|
import { recordTokenUsage } from "../../services/tokenLimitCounter.ts";
|
|
import { computeBillableTokens } from "./upstreamTimeouts.ts";
|
|
import { type EffectiveServiceTier } from "./serviceTier.ts";
|
|
|
|
export type RecordStreamingUsageStatsContext = {
|
|
provider: string | null | undefined;
|
|
model: string | null | undefined;
|
|
streamStatus: number;
|
|
startTime: number;
|
|
ttft: number;
|
|
streamErrorCode: string | null | undefined;
|
|
connectionId: string | null | undefined;
|
|
apiKeyInfo: { id?: string | null; name?: string | null } | null | undefined;
|
|
effectiveServiceTier: EffectiveServiceTier;
|
|
isCombo: boolean;
|
|
comboStrategy: string | null | undefined;
|
|
endpoint?: string | null | undefined;
|
|
};
|
|
|
|
function persistStreamingUsageRow(usage: object, ctx: RecordStreamingUsageStatsContext): void {
|
|
const { provider, model, streamStatus, startTime, ttft, streamErrorCode } = ctx;
|
|
saveRequestUsage({
|
|
provider: provider || "unknown",
|
|
model: model || "unknown",
|
|
tokens: usage,
|
|
status: String(streamStatus),
|
|
success: streamStatus === 200,
|
|
latencyMs: Date.now() - startTime,
|
|
timeToFirstTokenMs: ttft,
|
|
errorCode: streamStatus === 200 ? null : streamErrorCode || String(streamStatus),
|
|
timestamp: new Date().toISOString(),
|
|
connectionId: ctx.connectionId || undefined,
|
|
apiKeyId: ctx.apiKeyInfo?.id || undefined,
|
|
apiKeyName: ctx.apiKeyInfo?.name || undefined,
|
|
serviceTier: ctx.effectiveServiceTier,
|
|
comboStrategy: ctx.isCombo ? ctx.comboStrategy || undefined : undefined,
|
|
endpoint: ctx.endpoint || undefined,
|
|
}).catch((err) => {
|
|
console.error("Failed to save usage stats:", err.message);
|
|
});
|
|
}
|
|
|
|
function recordStreamingBillableTokens(usage: object, ctx: RecordStreamingUsageStatsContext): void {
|
|
if (!ctx.apiKeyInfo?.id || ctx.streamStatus !== 200) return;
|
|
try {
|
|
const billable = computeBillableTokens(usage);
|
|
if (billable > 0)
|
|
recordTokenUsage(
|
|
ctx.apiKeyInfo.id,
|
|
ctx.provider || "unknown",
|
|
ctx.model || "unknown",
|
|
billable
|
|
);
|
|
} catch {
|
|
// never block the stream on counter recording
|
|
}
|
|
}
|
|
|
|
export function recordStreamingUsageStats(
|
|
usage: unknown,
|
|
ctx: RecordStreamingUsageStatsContext
|
|
): void {
|
|
if (!usage || typeof usage !== "object") return;
|
|
persistStreamingUsageRow(usage, ctx);
|
|
recordStreamingBillableTokens(usage, ctx);
|
|
}
|