| import { describe, it, before, beforeEach, after } from "node:test";
|
| import assert from "node:assert/strict";
|
| import { mkdtempSync, rmSync } from "node:fs";
|
| import { tmpdir } from "node:os";
|
| import { join } from "node:path";
|
|
|
| const tmpDir = mkdtempSync(join(tmpdir(), "omniroute-test-"));
|
| process.env.DATA_DIR = tmpDir;
|
|
|
| const core = await import("../../../src/lib/db/core.ts");
|
| core.resetDbInstance();
|
| const { insertCompressionAnalyticsRow, getCompressionAnalyticsSummary } =
|
| await import("../../../src/lib/db/compressionAnalytics.ts");
|
| const { attachCompressionUsageReceipt } =
|
| await import("../../../src/lib/db/compressionAnalytics.ts");
|
| const { getDbInstance } = core;
|
|
|
| describe("compressionAnalytics", () => {
|
| before(() => {
|
| const db = getDbInstance();
|
| db.exec(`
|
| CREATE TABLE IF NOT EXISTS compression_analytics (
|
| id INTEGER PRIMARY KEY AUTOINCREMENT,
|
| timestamp TEXT NOT NULL,
|
| combo_id TEXT,
|
| provider TEXT,
|
| mode TEXT NOT NULL,
|
| original_tokens INTEGER NOT NULL,
|
| compressed_tokens INTEGER NOT NULL,
|
| tokens_saved INTEGER NOT NULL,
|
| duration_ms INTEGER,
|
| request_id TEXT
|
| )
|
| `);
|
| });
|
|
|
| beforeEach(() => {
|
|
|
| const db = getDbInstance();
|
| db.exec("DELETE FROM compression_analytics");
|
| });
|
|
|
| after(() => {
|
| core.closeDbInstance();
|
| rmSync(tmpDir, { recursive: true, force: true });
|
| });
|
|
|
| it("empty table returns zeroed summary", () => {
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.deepEqual(summary, {
|
| totalRequests: 0,
|
| totalTokensSaved: 0,
|
| avgSavingsPct: 0,
|
| avgDurationMs: 0,
|
| byMode: {},
|
| byEngine: {},
|
| byCompressionCombo: {},
|
| byProvider: {},
|
| last24h: summary.last24h,
|
| validationFallbacks: 0,
|
| realUsage: {
|
| requestsWithReceipts: 0,
|
| promptTokens: 0,
|
| completionTokens: 0,
|
| totalTokens: 0,
|
| cacheReadTokens: 0,
|
| cacheWriteTokens: 0,
|
| estimatedUsdSaved: 0,
|
| bySource: {},
|
| },
|
| mcpDescriptionCompression: {
|
| snapshots: 0,
|
| estimatedTokensSaved: 0,
|
| },
|
| });
|
| assert.equal(summary.last24h.length, 24);
|
| });
|
|
|
| it("insert single row does not throw", () => {
|
| const row = {
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| };
|
| assert.doesNotThrow(() => insertCompressionAnalyticsRow(row));
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.totalRequests, 1);
|
| });
|
|
|
| it("stores all RTK raw output pointers when provided", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "rtk",
|
| original_tokens: 1000,
|
| compressed_tokens: 500,
|
| tokens_saved: 500,
|
| rtk_raw_output_pointer: "raw_1",
|
| rtk_raw_output_bytes: 100,
|
| rtk_raw_output_pointers: JSON.stringify(["raw_1", "raw_2"]),
|
| rtk_raw_output_total_bytes: 250,
|
| });
|
|
|
| const db = getDbInstance();
|
| const row = db
|
| .prepare(
|
| "SELECT rtk_raw_output_pointer, rtk_raw_output_bytes, rtk_raw_output_pointers, rtk_raw_output_total_bytes FROM compression_analytics LIMIT 1"
|
| )
|
| .get() as {
|
| rtk_raw_output_pointer: string;
|
| rtk_raw_output_bytes: number;
|
| rtk_raw_output_pointers: string;
|
| rtk_raw_output_total_bytes: number;
|
| };
|
|
|
| assert.equal(row.rtk_raw_output_pointer, "raw_1");
|
| assert.equal(row.rtk_raw_output_bytes, 100);
|
| assert.equal(row.rtk_raw_output_pointers, JSON.stringify(["raw_1", "raw_2"]));
|
| assert.equal(row.rtk_raw_output_total_bytes, 250);
|
| });
|
|
|
| it("summary counts correctly after multiple inserts", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 300,
|
| compressed_tokens: 280,
|
| tokens_saved: 20,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "aggressive",
|
| original_tokens: 500,
|
| compressed_tokens: 400,
|
| tokens_saved: 100,
|
| });
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.totalRequests, 3);
|
| });
|
|
|
| it("totalTokensSaved sums correctly", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 300,
|
| compressed_tokens: 280,
|
| tokens_saved: 20,
|
| });
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.totalTokensSaved, 220);
|
| });
|
|
|
| it("byMode groups correctly", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 500,
|
| compressed_tokens: 400,
|
| tokens_saved: 100,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 300,
|
| compressed_tokens: 270,
|
| tokens_saved: 30,
|
| });
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.byMode["lite"].count, 2);
|
| assert.equal(summary.byMode["lite"].tokensSaved, 300);
|
| assert.equal(summary.byMode["standard"].count, 1);
|
| });
|
|
|
| it("byProvider groups correctly", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| provider: "ProviderA",
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 500,
|
| compressed_tokens: 400,
|
| tokens_saved: 100,
|
| provider: "ProviderB",
|
| });
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.deepEqual(summary.byProvider["ProviderA"], { count: 1, tokensSaved: 200 });
|
| assert.deepEqual(summary.byProvider["ProviderB"], { count: 1, tokensSaved: 100 });
|
| });
|
|
|
| it("since=24h filters rows older than 24h", () => {
|
| const oldTimestamp = new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString();
|
| const recentTimestamp = new Date().toISOString();
|
|
|
| insertCompressionAnalyticsRow({
|
| timestamp: oldTimestamp,
|
| mode: "lite",
|
| original_tokens: 2000,
|
| compressed_tokens: 1800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: recentTimestamp,
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 900,
|
| tokens_saved: 100,
|
| });
|
|
|
| const summary24h = getCompressionAnalyticsSummary("24h");
|
| assert.equal(summary24h.totalRequests, 1);
|
| assert.equal(summary24h.totalTokensSaved, 100);
|
| });
|
|
|
| it("since=undefined returns all rows including old ones", () => {
|
| const oldTimestamp = new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString();
|
| const recentTimestamp = new Date().toISOString();
|
|
|
| insertCompressionAnalyticsRow({
|
| timestamp: oldTimestamp,
|
| mode: "lite",
|
| original_tokens: 2000,
|
| compressed_tokens: 1800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: recentTimestamp,
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 900,
|
| tokens_saved: 100,
|
| });
|
|
|
| const summaryAll = getCompressionAnalyticsSummary();
|
| assert.equal(summaryAll.totalRequests, 2);
|
| assert.equal(summaryAll.totalTokensSaved, 300);
|
| });
|
|
|
| it("avgSavingsPct calculates correctly", () => {
|
|
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| });
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 500,
|
| compressed_tokens: 400,
|
| tokens_saved: 100,
|
| });
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.avgSavingsPct, 20);
|
| });
|
|
|
| it("last24h hourly buckets have correct shape", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "lite",
|
| original_tokens: 1000,
|
| compressed_tokens: 800,
|
| tokens_saved: 200,
|
| });
|
| const hourly = getCompressionAnalyticsSummary("24h").last24h;
|
| assert(Array.isArray(hourly));
|
| assert(hourly.length <= 24);
|
| hourly.forEach((bucket) => {
|
| assert(typeof bucket.hour === "string");
|
| assert(typeof bucket.count === "number");
|
| assert(typeof bucket.tokensSaved === "number");
|
| });
|
| });
|
|
|
| it("attaches real usage receipts to the latest compression row", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 1000,
|
| compressed_tokens: 700,
|
| tokens_saved: 300,
|
| request_id: "req-receipt",
|
| });
|
| attachCompressionUsageReceipt(
|
| "req-receipt",
|
| {
|
| prompt_tokens: 710,
|
| completion_tokens: 42,
|
| total_tokens: 752,
|
| prompt_tokens_details: { cached_tokens: 100, cache_creation_tokens: 12 },
|
| },
|
| "provider"
|
| );
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.realUsage.requestsWithReceipts, 1);
|
| assert.equal(summary.realUsage.promptTokens, 710);
|
| assert.equal(summary.realUsage.completionTokens, 42);
|
| assert.equal(summary.realUsage.totalTokens, 752);
|
| assert.equal(summary.realUsage.cacheReadTokens, 100);
|
| assert.equal(summary.realUsage.cacheWriteTokens, 12);
|
| assert.equal(summary.realUsage.bySource.provider, 1);
|
| });
|
|
|
| it("aggregates estimated USD savings separately from token estimates", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "standard",
|
| original_tokens: 1000,
|
| compressed_tokens: 700,
|
| tokens_saved: 300,
|
| request_id: "req-usd",
|
| estimated_usd_saved: 0.0015,
|
| });
|
| attachCompressionUsageReceipt("req-usd", { prompt_tokens: 700, total_tokens: 700 }, "provider");
|
|
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.realUsage.requestsWithReceipts, 1);
|
| assert.equal(summary.realUsage.estimatedUsdSaved, 0.0015);
|
| });
|
|
|
| it("summarizes validation fallback and output mode rows", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "output-caveman",
|
| original_tokens: 900,
|
| compressed_tokens: 900,
|
| tokens_saved: 0,
|
| request_id: "req-output",
|
| validation_fallback: true,
|
| output_mode: "full",
|
| });
|
| attachCompressionUsageReceipt(
|
| "req-output",
|
| { prompt_tokens: 900, completion_tokens: 120, total_tokens: 1020 },
|
| "provider"
|
| );
|
|
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.validationFallbacks, 1);
|
| assert.equal(summary.byMode["output-caveman"].count, 1);
|
| assert.equal(summary.realUsage.requestsWithReceipts, 1);
|
| assert.equal(summary.realUsage.totalTokens, 1020);
|
| });
|
|
|
| it("summarizes MCP description estimates without counting them as provider receipts", () => {
|
| insertCompressionAnalyticsRow({
|
| timestamp: new Date().toISOString(),
|
| mode: "mcp-description",
|
| engine: "mcp-description",
|
| original_tokens: 20,
|
| compressed_tokens: 12,
|
| tokens_saved: 8,
|
| mcp_description_tokens_saved: 8,
|
| });
|
|
|
| const summary = getCompressionAnalyticsSummary();
|
| assert.equal(summary.mcpDescriptionCompression.snapshots, 1);
|
| assert.equal(summary.mcpDescriptionCompression.estimatedTokensSaved, 8);
|
| assert.equal(summary.realUsage.requestsWithReceipts, 0);
|
| assert.equal(summary.realUsage.bySource.mcp_metadata_estimate, undefined);
|
| });
|
| });
|
|
|
