mirror of
https://github.com/mudler/LocalAI.git
synced 2026-08-02 03:20:12 -04:00
ff299df453
Three measured HTTP-layer regressions on a live deployment, fixed together
because they all shape the bytes on the wire.
1. No compression. The server sent no Content-Encoding regardless of what
the client asked for, confirmed with curl straight at 127.0.0.1:8080 so
it was not an ingress artefact. Adds gzip middleware, on by default and
configurable via LOCALAI_DISABLE_HTTP_COMPRESSION and
LOCALAI_HTTP_COMPRESSION_MIN_LENGTH (default 1024 bytes so tiny bodies
are not wastefully wrapped). Streaming routes are skipped explicitly:
an SSE Accept header, a WebSocket upgrade, and the completion / SSE /
log-tail path prefixes, because whether a completion request streams is
decided by the request body, which the middleware runs too early to see.
Already-compressed formats (woff2, png, mp4, ...) are skipped too; gzip
made those marginally larger. Measured over the embedded React build:
JS+CSS 2815 KB raw to 808 KB gzipped (3.48x).
2. No cache headers on content-hashed assets. Vite hashes the filenames,
so a given /assets/ URL can never change content, yet they shipped with
no Cache-Control, ETag or Last-Modified, and the browser re-fetched the
whole bundle on every navigation with no conditional request available.
/assets/* now carries public, max-age=31536000, immutable. index.html
stays no-cache so a deploy is picked up, and the unhashed locale JSONs
get a short TTL rather than the immutable one.
3. Unbounded trace endpoints. /api/traces returned 21,033,606 bytes in
4.65s and /api/backend-traces 3,471,682 bytes in 1.50s, and the admin
UI polls both every few seconds. The ring buffer holds up to 1024
entries, each embedding full input_text payloads. Both list endpoints
now take limit / offset / full, default to 50 entries, and strip the
heavy fields (request and response bodies plus headers for API traces,
body and data for backend traces) unless full=true. Every trace gets a
process-lifetime ID and GET /api/traces/{id} and
/api/backend-traces/{id} serve the full record, which is what the UI
fetches when a row is expanded. The list body stays a JSON array;
paging metadata rides in X-Total-Count, X-Trace-Offset and
X-Trace-Limit. Reproducing the live shape in a test, the polled payload
goes from 21,131,097 bytes to 7,201 bytes.
Assisted-by: Claude:claude-opus-4-8 [Claude Code]
Signed-off-by: Ettore Di Giacinto <mudler@localai.io>
Co-authored-by: Ettore Di Giacinto <mudler@localai.io>
83 lines
3.0 KiB
JavaScript
83 lines
3.0 KiB
JavaScript
import { test, expect } from './coverage-fixtures.js'
|
|
|
|
// The trace list endpoints return a bounded page with the heavy request /
|
|
// response bodies stripped; the full record is fetched per trace when a row
|
|
// is expanded. Without this the admin UI polled a multi-megabyte JSON blob
|
|
// every few seconds. These specs pin both halves of the contract from the
|
|
// browser's side: the page asks for a bounded list, and expanding a row
|
|
// issues the per-trace detail request whose payload is what gets rendered.
|
|
|
|
const LIST_BODY = [
|
|
{
|
|
id: '7',
|
|
request: { method: 'POST', path: '/v1/chat/completions', body: null },
|
|
response: { status: 200, body: null, body_bytes: 65536 },
|
|
},
|
|
]
|
|
|
|
const DETAIL_BODY = {
|
|
id: '7',
|
|
request: {
|
|
method: 'POST',
|
|
path: '/v1/chat/completions',
|
|
// "hello from the request body" base64-encoded, matching the wire shape.
|
|
body: Buffer.from('hello from the request body').toString('base64'),
|
|
},
|
|
response: {
|
|
status: 200,
|
|
body: Buffer.from('hello from the response body').toString('base64'),
|
|
body_bytes: 65536,
|
|
},
|
|
client_ip: '203.0.113.9',
|
|
}
|
|
|
|
test.describe('Traces - bounded list and on-demand detail', () => {
|
|
let listUrls = []
|
|
|
|
test.beforeEach(async ({ page }) => {
|
|
listUrls = []
|
|
await page.route('**/api/traces?*', (route) => {
|
|
listUrls.push(route.request().url())
|
|
route.fulfill({
|
|
contentType: 'application/json',
|
|
headers: { 'X-Total-Count': '842' },
|
|
body: JSON.stringify(LIST_BODY),
|
|
})
|
|
})
|
|
await page.route('**/api/traces/7', (route) => {
|
|
route.fulfill({ contentType: 'application/json', body: JSON.stringify(DETAIL_BODY) })
|
|
})
|
|
await page.route('**/api/backend-traces?*', (route) => {
|
|
route.fulfill({
|
|
contentType: 'application/json',
|
|
headers: { 'X-Total-Count': '0' },
|
|
body: '[]',
|
|
})
|
|
})
|
|
await page.goto('/app/traces')
|
|
await expect(page.locator('text=Tracing is')).toBeVisible({ timeout: 10_000 })
|
|
})
|
|
|
|
test('requests a bounded page rather than the whole buffer', async () => {
|
|
expect(listUrls.length).toBeGreaterThan(0)
|
|
expect(listUrls[0]).toContain('limit=')
|
|
expect(listUrls[0]).not.toContain('limit=0')
|
|
})
|
|
|
|
test('reports the server-side total, not the page length', async ({ page }) => {
|
|
// The tab counter reflects X-Total-Count (842 buffered) even though only
|
|
// one entry was returned in the page.
|
|
await expect(page.locator('button', { hasText: 'API Traces' })).toContainText('842')
|
|
})
|
|
|
|
test('fetches the full record when a row is expanded', async ({ page }) => {
|
|
await page.locator('tr', { hasText: '/v1/chat/completions' }).first().click()
|
|
|
|
// The bodies live only in the detail response, so seeing them proves the
|
|
// per-trace fetch happened and its payload is what gets rendered.
|
|
await expect(page.locator('text=hello from the request body')).toBeVisible()
|
|
await expect(page.locator('text=hello from the response body')).toBeVisible()
|
|
await expect(page.locator('text=203.0.113.9').first()).toBeVisible()
|
|
})
|
|
})
|