From 8b97ef99aa3c7c34548d82821831eee42d137540 Mon Sep 17 00:00:00 2001 From: Dizzle <112548150+maxmad64bis@users.noreply.github.com> Date: Tue, 4 Aug 2026 19:34:17 +0200 Subject: [PATCH] fix(db): persist account egress IP into proxy_logs (#9291) * fix(db): persist account egress IP into proxy_logs The account egress IP (outbound IP the upstream saw, resolved via proxyEgress.ts echo-IP probe with 5-min cache) was computed and surfaced in the proxy_logs console and ring buffer, but never persisted: proxy_logs.egress_ip did not exist, so the value was lost on restart and real traffic could not be attributed to the node/IP active at that instant. - migration 134 adds proxy_logs.egress_ip (nullable, backward-compatible) - schemaColumns.ensureProxyLogsColumns() idempotent reconciler - proxyLogger self-heals the schema in loadFromDb(), persists egress_ip on INSERT, and matches it in search Follows the session_tag (#8249) migration + schemaColumns reconciler pattern; base SCHEMA_SQL untouched. * docs(changelog): add 9291 fragment for proxy_logs egress_ip --------- Co-authored-by: Diego Rodrigues de Sa e Souza --- .../fixes/9291-proxy-logs-egress-ip.md | 1 + .../migrations/134_proxy_logs_egress_ip.sql | 2 + src/lib/db/schemaColumns.ts | 16 ++++ src/lib/proxyLogger.ts | 10 ++- tests/unit/db-schema-columns-split.test.ts | 32 +++++++ tests/unit/proxy-logs-egress-ip.test.ts | 86 +++++++++++++++++++ 6 files changed, 145 insertions(+), 2 deletions(-) create mode 100644 changelog.d/fixes/9291-proxy-logs-egress-ip.md create mode 100644 src/lib/db/migrations/134_proxy_logs_egress_ip.sql create mode 100644 tests/unit/proxy-logs-egress-ip.test.ts diff --git a/changelog.d/fixes/9291-proxy-logs-egress-ip.md b/changelog.d/fixes/9291-proxy-logs-egress-ip.md new file mode 100644 index 0000000000..11e6b18f08 --- /dev/null +++ b/changelog.d/fixes/9291-proxy-logs-egress-ip.md @@ -0,0 +1 @@ +- **fix(db):** persist the account egress IP into `proxy_logs.egress_ip` (migration 134 + schema reconciler) so real traffic stays attributable to the actual node/IP even after restart — the egress IP was previously computed and logged but silently dropped from persistence ([#9291](https://github.com/diegosouzapw/OmniRoute/pull/9291)) — thanks @maxmad64bis diff --git a/src/lib/db/migrations/134_proxy_logs_egress_ip.sql b/src/lib/db/migrations/134_proxy_logs_egress_ip.sql new file mode 100644 index 0000000000..2f910f895a --- /dev/null +++ b/src/lib/db/migrations/134_proxy_logs_egress_ip.sql @@ -0,0 +1,2 @@ +-- egress_ip: no index by design (not a query dimension) — YAGNI +ALTER TABLE proxy_logs ADD COLUMN egress_ip TEXT; \ No newline at end of file diff --git a/src/lib/db/schemaColumns.ts b/src/lib/db/schemaColumns.ts index a5fbd0b62a..f3a518adfc 100644 --- a/src/lib/db/schemaColumns.ts +++ b/src/lib/db/schemaColumns.ts @@ -273,6 +273,22 @@ export function ensureCallLogsColumns(db: SqliteDatabase) { } } +export function ensureProxyLogsColumns(db: SqliteDatabase) { + try { + const columns = db.prepare("PRAGMA table_info(proxy_logs)").all() as Array<{ + name?: string; + }>; + const columnNames = new Set(columns.map((column) => String(column.name ?? ""))); + if (!columnNames.has("egress_ip")) { + db.exec("ALTER TABLE proxy_logs ADD COLUMN egress_ip TEXT"); + console.log("[DB] Added proxy_logs.egress_ip column"); + } + } catch (error: unknown) { + const message = error instanceof Error ? error.message : String(error); + console.warn("[DB] Failed to verify proxy_logs schema:", message); + } +} + export function hasColumn(db: SqliteDatabase, tableName: string, columnName: string): boolean { const rows = db.prepare(`PRAGMA table_info(${tableName})`).all() as Array<{ name?: string }>; return rows.some((row) => row.name === columnName); diff --git a/src/lib/proxyLogger.ts b/src/lib/proxyLogger.ts index 3027419dd2..327d1d9b4f 100644 --- a/src/lib/proxyLogger.ts +++ b/src/lib/proxyLogger.ts @@ -8,6 +8,7 @@ */ import { v4 as uuidv4 } from "uuid"; import { getDbInstance, isCloud, isBuildPhase } from "./db/core"; +import { ensureProxyLogsColumns } from "./db/schemaColumns"; const shouldPersistToDisk = !isCloud && !isBuildPhase; @@ -64,6 +65,9 @@ function loadFromDb() { if (!shouldPersistToDisk) return; try { const db = getDbInstance(); + // Self-heal the proxy_logs schema before reading/writing (migration 134 + // guarantees egress_ip on every migrated DB; this covers restored/odd states). + ensureProxyLogsColumns(db); const rows = db .prepare("SELECT * FROM proxy_logs ORDER BY timestamp DESC LIMIT ?") .all(MAX_IN_MEMORY_ENTRIES) as any[]; @@ -145,10 +149,10 @@ export function logProxyEvent(entry: ProxyLogInput) { const db = getDbInstance(); db.prepare( `INSERT INTO proxy_logs (id, timestamp, status, proxy_type, proxy_host, proxy_port, - level, level_id, provider, target_url, public_ip, latency_ms, error, + level, level_id, provider, target_url, public_ip, egress_ip, latency_ms, error, connection_id, combo_id, account, tls_fingerprint) VALUES (@id, @timestamp, @status, @proxyType, @proxyHost, @proxyPort, - @level, @levelId, @provider, @targetUrl, @clientIp, @latencyMs, @error, + @level, @levelId, @provider, @targetUrl, @clientIp, @egressIp, @latencyMs, @error, @connectionId, @comboId, @account, @tlsFingerprint)` ).run({ id: log.id, @@ -162,6 +166,7 @@ export function logProxyEvent(entry: ProxyLogInput) { provider: log.provider, targetUrl: log.targetUrl, clientIp: log.clientIp, + egressIp: log.egressIp, latencyMs: log.latencyMs, error: log.error, connectionId: log.connectionId, @@ -214,6 +219,7 @@ export function getProxyLogs(filters: ProxyLogFilters = {}) { (l.provider || "").toLowerCase().includes(q) || (l.targetUrl || "").toLowerCase().includes(q) || (l.clientIp || "").toLowerCase().includes(q) || + (l.egressIp || "").toLowerCase().includes(q) || (l.level || "").toLowerCase().includes(q) || (l.error || "").toLowerCase().includes(q) || (l.account || "").toLowerCase().includes(q) diff --git a/tests/unit/db-schema-columns-split.test.ts b/tests/unit/db-schema-columns-split.test.ts index 0e89a5fa1f..52456ea364 100644 --- a/tests/unit/db-schema-columns-split.test.ts +++ b/tests/unit/db-schema-columns-split.test.ts @@ -4,10 +4,13 @@ // columns and is safe to re-run; hasTable/hasColumn/getTableColumns/quoteIdentifier introspect. import { test } from "node:test"; import assert from "node:assert/strict"; +import fs from "node:fs"; +import path from "node:path"; import { tryOpenSync } from "../../src/lib/db/adapters/driverFactory.ts"; import { ensureUsageHistoryColumns, ensureProviderConnectionsColumns, + ensureProxyLogsColumns, hasColumn, hasTable, quoteIdentifier, @@ -85,3 +88,32 @@ test("ensureProviderConnectionsColumns repairs quota visibility with a visible d db.close?.(); } }); + +test("ensureProxyLogsColumns self-heals a bare proxy_logs (upgrade path)", () => { + const db = openMemoryDb(); + try { + db.exec("CREATE TABLE proxy_logs (id TEXT PRIMARY KEY, timestamp TEXT NOT NULL)"); + assert.equal(hasColumn(db, "proxy_logs", "egress_ip"), false); + + ensureProxyLogsColumns(db); + assert.equal(hasColumn(db, "proxy_logs", "egress_ip"), true); + assert.doesNotThrow(() => ensureProxyLogsColumns(db)); + } finally { + db.close?.(); + } +}); + +test("migration 134 SQL applies egress_ip to a bare proxy_logs", () => { + const db = openMemoryDb(); + try { + db.exec("CREATE TABLE proxy_logs (id TEXT PRIMARY KEY, timestamp TEXT NOT NULL)"); + const sql = fs.readFileSync( + path.join(process.cwd(), "src/lib/db/migrations/134_proxy_logs_egress_ip.sql"), + "utf8" + ); + db.exec(sql); + assert.equal(hasColumn(db, "proxy_logs", "egress_ip"), true); + } finally { + db.close?.(); + } +}); diff --git a/tests/unit/proxy-logs-egress-ip.test.ts b/tests/unit/proxy-logs-egress-ip.test.ts new file mode 100644 index 0000000000..5dd571f135 --- /dev/null +++ b/tests/unit/proxy-logs-egress-ip.test.ts @@ -0,0 +1,86 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; + +// Persistence to SQLite only runs when shouldPersistToDisk is true +// (local mode: !isCloud && !isBuildPhase). Setting DATA_DIR to a fresh temp +// dir keeps the test in local mode; the assertions below would otherwise fail +// with no explanatory guard. +const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-proxy-egress-ip-")); +process.env.DATA_DIR = TEST_DATA_DIR; + +const core = await import("../../src/lib/db/core.ts"); +const proxyLogger = await import("../../src/lib/proxyLogger.ts"); + +// Fresh DB + fresh in-memory buffer per test (mirrors +// proxy-logger-client-ip.test.ts). clearProxyLogs() runs BEFORE closeDbInstance() +// so it never reopens a closed DB. +function resetStorage() { + proxyLogger.clearProxyLogs(); + core.closeDbInstance(); + fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true }); + fs.mkdirSync(TEST_DATA_DIR, { recursive: true }); +} + +test.beforeEach(() => { + resetStorage(); +}); + +test.after(() => { + core.closeDbInstance(); + fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true }); +}); + +test("fresh install exposes egress_ip and the reconciler is idempotent", async () => { + const { ensureProxyLogsColumns, hasColumn } = await import("../../src/lib/db/schemaColumns.ts"); + const db = core.getDbInstance(); + assert.equal(hasColumn(db, "proxy_logs", "egress_ip"), true, "column exists after migration"); + assert.doesNotThrow(() => ensureProxyLogsColumns(db)); + assert.doesNotThrow(() => ensureProxyLogsColumns(db)); +}); + +test("logProxyEvent persists egressIp into proxy_logs.egress_ip", () => { + proxyLogger.logProxyEvent({ + status: "success", + provider: "codex", + targetUrl: "codex/gpt-5.5", + egressIp: "203.0.113.9", + }); + const db = core.getDbInstance(); + const row = db.prepare("SELECT egress_ip FROM proxy_logs ORDER BY rowid DESC LIMIT 1").get() as { + egress_ip: string | null; + }; + assert.equal(row.egress_ip, "203.0.113.9"); +}); + +test("egress_ip survives a DB close/reopen cycle (on-disk)", () => { + proxyLogger.logProxyEvent({ + status: "success", + provider: "openai", + egressIp: "198.51.100.7", + }); + core.closeDbInstance(); + const db = core.getDbInstance(); + const row = db.prepare("SELECT egress_ip FROM proxy_logs ORDER BY rowid DESC LIMIT 1").get() as { + egress_ip: string | null; + }; + assert.equal(row.egress_ip, "198.51.100.7"); +}); + +test("egress_ip is NULL when not provided (never synthesized)", () => { + proxyLogger.logProxyEvent({ status: "success", provider: "claude" }); + const db = core.getDbInstance(); + const row = db.prepare("SELECT egress_ip FROM proxy_logs ORDER BY rowid DESC LIMIT 1").get() as { + egress_ip: string | null; + }; + assert.equal(row.egress_ip, null); +}); + +test("getProxyLogs search matches the egress IP", () => { + proxyLogger.logProxyEvent({ status: "success", provider: "codex", egressIp: "203.0.113.55" }); + const [log] = proxyLogger.getProxyLogs({ search: "203.0.113.55" }); + assert.ok(log, "expected a matching log"); + assert.equal(log.egressIp, "203.0.113.55"); +});