mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-19 06:23:32 +00:00
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
* 🔭 feat: Recover Stale Chunks Without the Error Page and Ship Client Logs to RUM Stale chunks: a tab left open across a deploy that opens a code-split panel requests a hashed chunk the new deploy removed. Vite's preload handler hands the failure to the stale-asset recovery, which reloads, but the import then resolves to `undefined` and `React.lazy` throws a TypeError into the route error boundary, so the error page flashes before the reload. Lazy imports now go through `lazyWithRecovery`/`importWithRecovery`, which turn that result into a `ChunkLoadError`; the route boundary recognizes chunk failures (and any error while a recovery reload is underway), asks the page recovery once, and renders a localized "Updating to the latest version…" status. When the loop guard declines, the normal error page with its reload action shows instead. The page recovery is now idempotent within a page, so concurrent callers join the in-flight reload rather than tripping the guard. Client logs: with RUM in proxy mode, the client logger's warn/error calls, error-boundary catches and stale-asset recovery events are exported as OTLP log records through the authenticated `/api/rum/v1/logs` proxy. Records carry allowlisted, scrubbed fields only, follow RUM session sampling, dedupe repeats with a count, are budgeted per minute and per page, batch with backoff, flush with keepalive on page hide, and stop after persistent failures. The proxy now refuses non-OTLP content types and applies a per-user rate limit. `RUM_CLIENT_LOGS=false` turns the export off. * 🔒 fix: Keep Client Logs Opt-In and Drop Application Error Messages - RUM_CLIENT_LOGS now defaults to off, like console capture, so enabling RUM proxy mode never starts a new log stream on its own. - Error messages are exported only for engine, browser and library generated types (TypeError, SyntaxError, DOMException, AxiosError, chunk failures); application errors keep type, status and stack only, since their messages can echo prompt or response text. All quoted fragments are now redacted. - Batches are measured in encoded UTF-8 bytes of the exact request body, and page hide drains every queued record that fits the keepalive quota. - Queued stale-asset events are delivered as soon as the log exporter starts, independent of the RUM SDK loading, and marked so they are never logged twice. * 🔒 fix: Export Only Known Generated Error Messages and Ack Queued Events - Error messages are exported only when the whole text matches a known engine, browser or library message shape (property access on undefined, "x is not a function", fetch/abort/axios status, chunk and CSS preload failures). The error class alone no longer qualifies, since any code can throw a TypeError carrying arbitrary text. - Queued stale-asset events are marked logged only after the collector accepts the record carrying them, so an undelivered event replays on the next page; in-flight events are skipped by the SDK path. - A fractional RUM_PROXY_USER_MAX below one falls back to the default instead of flooring to a limit of zero. * 🔒 fix: Hold Unacknowledged Asset Events, Re-send In-Flight Logs on Hide - The RUM SDK flush no longer drops queued stale-asset events whose client log record is still unacknowledged: they stay queued and persisted, flagged so their SDK action is not repeated, and leave the queue once the collector accepts the record. - Page hide re-sends the records of an unanswered regular request with keepalive; each record belongs to the latest request carrying it, so a late response to the original request neither marks nor requeues it. - Client-log export stops when the authenticated layout unmounts. - The proxy refuses /v1/logs while client logs, console capture and replay are all off, so turning RUM_CLIENT_LOGS off also stops tabs that still hold an older startup config. * 🔒 fix: Export Only Complete Stack Frames, Never the Message Header Stack reduction now strips the V8 `name: message` header (including every line of a multi-line message) and keeps only lines with a complete V8, Gecko or WebKit frame shape that ends in a URL or absolute path with a line number. A message ending in a source-position-like suffix can no longer pass as a frame. * fix: centralize RUM delivery and asset recovery lifecycle * fix: preserve RUM page lifetime and collector acknowledgements * fix: retain page transport quotas and recover functional chunks * fix: scope RUM client sessions to authenticated identity --------- Co-authored-by: Lia <lia@librechat.ai>
188 lines
6.4 KiB
JavaScript
188 lines
6.4 KiB
JavaScript
const express = require('express');
|
|
const request = require('supertest');
|
|
|
|
const mockRequireRumProxyAuth = jest.fn((_req, _res, next) => next());
|
|
const mockIsRumProxyEnabled = jest.fn();
|
|
const mockIsRumLogsEndpointEnabled = jest.fn(() => true);
|
|
const mockProxyRumRequest = jest.fn((_req, res) => res.status(202).send());
|
|
const mockRumProxyLimiter = jest.fn((_req, _res, next) => next());
|
|
const mockLimiterSetup = [];
|
|
const mockCreateRumProxyLimiter = jest.fn((options) => {
|
|
mockLimiterSetup.push(['createRumProxyLimiter', options]);
|
|
return mockRumProxyLimiter;
|
|
});
|
|
const mockLimiterCache = jest.fn((prefix) => {
|
|
mockLimiterSetup.push(['limiterCache', prefix]);
|
|
return 'limiter-store';
|
|
});
|
|
|
|
jest.mock('~/server/middleware', () => ({
|
|
requireRumProxyAuth: (...args) => mockRequireRumProxyAuth(...args),
|
|
}));
|
|
|
|
jest.mock('@librechat/api', () => ({
|
|
getRumProxyBodyLimit: jest.fn(() => '3mb'),
|
|
limiterCache: (...args) => mockLimiterCache(...args),
|
|
createRumProxyLimiter: (...args) => mockCreateRumProxyLimiter(...args),
|
|
requireRumProxyEnabled: (_req, res, next) =>
|
|
mockIsRumProxyEnabled()
|
|
? next()
|
|
: res.status(404).json({ message: 'RUM proxy is not configured' }),
|
|
requireRumLogsEnabled: (_req, res, next) =>
|
|
mockIsRumLogsEndpointEnabled()
|
|
? next()
|
|
: res.status(404).json({ message: 'RUM logs are not enabled' }),
|
|
handleJsonParseError: (err, _req, res, next) =>
|
|
err.type === 'entity.parse.failed' ? res.status(400).end() : next(err),
|
|
proxyRumRequest: (...args) => mockProxyRumRequest(...args),
|
|
}));
|
|
|
|
describe('RUM proxy routes', () => {
|
|
let app;
|
|
|
|
beforeAll(() => {
|
|
const rumRouter = require('../rum');
|
|
|
|
app = express();
|
|
app.use('/api/rum', rumRouter);
|
|
});
|
|
|
|
beforeEach(() => {
|
|
mockRequireRumProxyAuth.mockClear();
|
|
mockIsRumProxyEnabled.mockReset();
|
|
mockProxyRumRequest.mockClear();
|
|
mockRumProxyLimiter.mockClear();
|
|
mockIsRumLogsEndpointEnabled.mockReset();
|
|
mockIsRumLogsEndpointEnabled.mockReturnValue(true);
|
|
});
|
|
|
|
it('refuses logs, but not traces, when no browser log source is enabled', async () => {
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
mockIsRumLogsEndpointEnabled.mockReturnValue(false);
|
|
|
|
const logs = await request(app)
|
|
.post('/api/rum/v1/logs')
|
|
.set('Content-Type', 'application/json')
|
|
.send({ resourceLogs: [] });
|
|
const traces = await request(app)
|
|
.post('/api/rum/v1/traces')
|
|
.set('Content-Type', 'application/json')
|
|
.send({ resourceSpans: [] });
|
|
|
|
expect(logs.status).toBe(404);
|
|
expect(traces.status).toBe(202);
|
|
expect(mockProxyRumRequest).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
afterEach(() => {
|
|
delete process.env.RUM_PROXY_AUTHORIZATION;
|
|
});
|
|
|
|
it('returns 404 before auth and proxying when RUM proxy mode is disabled', async () => {
|
|
mockIsRumProxyEnabled.mockReturnValue(false);
|
|
|
|
const response = await request(app)
|
|
.post('/api/rum/v1/traces')
|
|
.set('Content-Type', 'application/x-protobuf')
|
|
.send(Buffer.from('payload'));
|
|
|
|
expect(response.status).toBe(404);
|
|
expect(response.body).toEqual({ message: 'RUM proxy is not configured' });
|
|
expect(mockRequireRumProxyAuth).not.toHaveBeenCalled();
|
|
expect(mockProxyRumRequest).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it.each(['traces', 'logs'])(
|
|
'passes server authorization to the %s proxy after auth',
|
|
async (signal) => {
|
|
process.env.RUM_PROXY_AUTHORIZATION = 'server-only-ingestion-key';
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
|
|
const response = await request(app)
|
|
.post(`/api/rum/v1/${signal}`)
|
|
.set('Content-Type', 'application/x-protobuf')
|
|
.send(Buffer.from('payload'));
|
|
|
|
expect(response.status).toBe(202);
|
|
expect(mockRequireRumProxyAuth).toHaveBeenCalledTimes(1);
|
|
expect(mockProxyRumRequest).toHaveBeenCalledTimes(1);
|
|
expect(mockProxyRumRequest).toHaveBeenCalledWith(
|
|
expect.any(Object),
|
|
expect.any(Object),
|
|
'server-only-ingestion-key',
|
|
);
|
|
},
|
|
);
|
|
|
|
it.each(['traces', 'logs'])(
|
|
'does not export %s when session authentication fails',
|
|
async (signal) => {
|
|
process.env.RUM_PROXY_AUTHORIZATION = 'server-only-ingestion-key';
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
mockRequireRumProxyAuth.mockImplementationOnce((_req, res) => res.status(401).end());
|
|
|
|
const response = await request(app)
|
|
.post(`/api/rum/v1/${signal}`)
|
|
.set('Content-Type', 'application/x-protobuf')
|
|
.send(Buffer.from('payload'));
|
|
|
|
expect(response.status).toBe(401);
|
|
expect(mockProxyRumRequest).not.toHaveBeenCalled();
|
|
},
|
|
);
|
|
|
|
it('uses RUM-specific auth for logs as well as traces', async () => {
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
|
|
const response = await request(app)
|
|
.post('/api/rum/v1/logs')
|
|
.set('Content-Type', 'application/x-protobuf')
|
|
.send(Buffer.from('payload'));
|
|
|
|
expect(response.status).toBe(202);
|
|
expect(mockRequireRumProxyAuth).toHaveBeenCalledTimes(1);
|
|
expect(mockProxyRumRequest).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it('builds the per-user limiter on the shared limiter store', () => {
|
|
expect(mockLimiterSetup).toEqual([
|
|
['limiterCache', 'rum_proxy_user_limiter'],
|
|
['createRumProxyLimiter', { store: 'limiter-store' }],
|
|
]);
|
|
});
|
|
|
|
it.each(['traces', 'logs'])('rate limits %s after auth and before proxying', async (signal) => {
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
const order = [];
|
|
mockRequireRumProxyAuth.mockImplementationOnce((_req, _res, next) => {
|
|
order.push('auth');
|
|
next();
|
|
});
|
|
mockRumProxyLimiter.mockImplementationOnce((_req, res) => {
|
|
order.push('limit');
|
|
res.status(429).json({ message: 'Too many RUM telemetry requests' });
|
|
});
|
|
|
|
const response = await request(app)
|
|
.post(`/api/rum/v1/${signal}`)
|
|
.set('Content-Type', 'application/json')
|
|
.send({ resourceLogs: [] });
|
|
|
|
expect(response.status).toBe(429);
|
|
expect(order).toEqual(['auth', 'limit']);
|
|
expect(mockProxyRumRequest).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('skips the limiter when session authentication drops the request', async () => {
|
|
mockIsRumProxyEnabled.mockReturnValue(true);
|
|
mockRequireRumProxyAuth.mockImplementationOnce((_req, res) => res.status(204).end());
|
|
|
|
const response = await request(app)
|
|
.post('/api/rum/v1/logs')
|
|
.set('Content-Type', 'application/json')
|
|
.send({ resourceLogs: [] });
|
|
|
|
expect(response.status).toBe(204);
|
|
expect(mockRumProxyLimiter).not.toHaveBeenCalled();
|
|
});
|
|
});
|