Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { EventEmitter } from 'node:events';
import { context, SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
import type { Response } from 'express';
import type { Span, Tracer } from '@opentelemetry/api';
import type { ServerRequest } from '~/types';
import { createSseStreamTelemetry } from './stream';
interface MockResponse extends EventEmitter {
writableEnded: boolean;
}
function createSpan(): jest.Mocked<Span> {
const span = {} as jest.Mocked<Span>;
span.addEvent = jest.fn<jest.Mocked<Span>, Parameters<Span['addEvent']>>(() => span);
span.addLink = jest.fn<jest.Mocked<Span>, Parameters<Span['addLink']>>(() => span);
span.addLinks = jest.fn<jest.Mocked<Span>, Parameters<Span['addLinks']>>(() => span);
span.end = jest.fn<void, Parameters<Span['end']>>();
span.isRecording = jest.fn<boolean, Parameters<Span['isRecording']>>(() => true);
span.recordException = jest.fn<void, Parameters<Span['recordException']>>();
span.setAttribute = jest.fn<jest.Mocked<Span>, Parameters<Span['setAttribute']>>(() => span);
span.setAttributes = jest.fn<jest.Mocked<Span>, Parameters<Span['setAttributes']>>(() => span);
span.setStatus = jest.fn<jest.Mocked<Span>, Parameters<Span['setStatus']>>(() => span);
span.spanContext = jest.fn<ReturnType<Span['spanContext']>, Parameters<Span['spanContext']>>(
() => ({
spanId: '0000000000000000',
traceFlags: 0,
traceId: '00000000000000000000000000000000',
}),
);
span.updateName = jest.fn<jest.Mocked<Span>, Parameters<Span['updateName']>>(() => span);
return span;
}
function createRequest(): ServerRequest {
return {
method: 'GET',
} as ServerRequest;
}
function createResponse(): MockResponse {
const res = new EventEmitter() as MockResponse;
res.writableEnded = false;
return res;
}
function mockTracer(span: jest.Mocked<Span>): jest.Mock {
const startSpan = jest.fn(() => span);
jest.spyOn(trace, 'getTracer').mockReturnValue({ startSpan } as unknown as Tracer);
return startSpan;
}
afterEach(() => {
jest.restoreAllMocks();
});
describe('createSseStreamTelemetry', () => {
it('records normal stream completion attributes', () => {
const span = createSpan();
const startSpan = mockTracer(span);
const res = createResponse();
const telemetry = createSseStreamTelemetry({
isResume: false,
req: createRequest(),
res: res as Response,
streamId: 'stream-1',
});
const payload = 'event: message\ndata: {"final":true}\n\n';
telemetry.recordHeadersFlushed();
telemetry.recordFinalEventEmitted();
telemetry.recordWrite(payload, { final: true });
res.writableEnded = true;
res.emit('finish');
expect(startSpan).toHaveBeenCalledWith(
'librechat.sse.stream',
{
kind: SpanKind.INTERNAL,
attributes: expect.objectContaining({
'http.request.method': 'GET',
'http.route': '/api/agents/chat/stream/:streamId',
'librechat.stream.id': 'stream-1',
'librechat.stream.resume': false,
'librechat.stream.route': '/api/agents/chat/stream/:streamId',
}),
},
context.active(),
);
expect(span.addEvent).toHaveBeenCalledWith('headers_flushed');
expect(span.addEvent).toHaveBeenCalledWith('first_chunk');
expect(span.addEvent).toHaveBeenCalledWith('final_event_emitted');
expect(span.addEvent).toHaveBeenCalledWith('final_event_written');
expect(span.setAttributes).toHaveBeenCalledWith(
expect.objectContaining({
'http.response.body.size': Buffer.byteLength(payload),
'librechat.stream.bytes.sent': Buffer.byteLength(payload),
'librechat.stream.chunks.count': 1,
'librechat.stream.completed': true,
'librechat.stream.end_reason': 'done',
'librechat.stream.error_event_emitted': false,
'librechat.stream.final_event_emitted': true,
'librechat.stream.final_event_written': true,
'librechat.stream.time_to_first_chunk_ms': expect.any(Number),
}),
);
expect(span.setStatus).not.toHaveBeenCalled();
expect(span.end).toHaveBeenCalledTimes(1);
});
it('records client aborts on close before writableEnded', () => {
const span = createSpan();
mockTracer(span);
const res = createResponse();
const telemetry = createSseStreamTelemetry({
isResume: true,
req: createRequest(),
res: res as Response,
streamId: 'stream-2',
});
telemetry.recordWrite('event: message\ndata: {}\n\n');
res.emit('close');
expect(span.addEvent).toHaveBeenCalledWith('client_aborted');
expect(span.setAttributes).toHaveBeenCalledWith(
expect.objectContaining({
'librechat.stream.completed': false,
'librechat.stream.end_reason': 'client_aborted',
}),
);
expect(span.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });
expect(span.setAttribute).toHaveBeenCalledWith('error.type', 'client_aborted');
expect(span.end).toHaveBeenCalledTimes(1);
});
it('preserves subscribe_failed as the terminal reason when an error event is sent', () => {
const span = createSpan();
mockTracer(span);
const res = createResponse();
const telemetry = createSseStreamTelemetry({
isResume: false,
req: createRequest(),
res: res as Response,
streamId: 'stream-3',
});
telemetry.recordSubscribeFailed();
telemetry.recordErrorEventEmitted();
telemetry.recordWrite('event: error\ndata: {"error":"Failed to subscribe to stream"}\n\n');
res.writableEnded = true;
res.emit('finish');
expect(span.addEvent).toHaveBeenCalledWith('subscribe_failed');
expect(span.addEvent).toHaveBeenCalledWith('error_event_emitted');
expect(span.setAttributes).toHaveBeenCalledWith(
expect.objectContaining({
'librechat.stream.completed': false,
'librechat.stream.end_reason': 'subscribe_failed',
'librechat.stream.error_event_emitted': true,
}),
);
expect(span.setStatus).toHaveBeenCalledWith({ code: SpanStatusCode.ERROR });
expect(span.setAttribute).toHaveBeenCalledWith('error.type', 'subscribe_failed');
expect(span.end).toHaveBeenCalledTimes(1);
});
it('ends only once when finish and close both fire', () => {
const span = createSpan();
mockTracer(span);
const res = createResponse();
const telemetry = createSseStreamTelemetry({
isResume: false,
req: createRequest(),
res: res as Response,
streamId: 'stream-4',
});
telemetry.recordFinalEventEmitted();
telemetry.recordWrite('event: message\ndata: {"final":true}\n\n', { final: true });
res.writableEnded = true;
res.emit('finish');
res.emit('close');
expect(span.end).toHaveBeenCalledTimes(1);
expect(span.setAttributes).toHaveBeenCalledTimes(1);
});
it('does not count writes after the stream span has ended', () => {
const span = createSpan();
mockTracer(span);
const res = createResponse();
const telemetry = createSseStreamTelemetry({
isResume: false,
req: createRequest(),
res: res as Response,
streamId: 'stream-5',
});
const firstPayload = 'event: message\ndata: {"index":1}\n\n';
telemetry.recordWrite(firstPayload);
res.emit('close');
telemetry.recordWrite('event: message\ndata: {"index":2}\n\n');
expect(span.setAttributes).toHaveBeenCalledWith(
expect.objectContaining({
'librechat.stream.bytes.sent': Buffer.byteLength(firstPayload),
'librechat.stream.chunks.count': 1,
}),
);
expect(span.end).toHaveBeenCalledTimes(1);
});
});