Skip to content

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

22.8 KB
Raw Blame
import { act, renderHook, waitFor } from '@testing-library/react';
import useRum from './useRum';

const mockGetSessionId = jest.fn<string | undefined, []>();
const mockInit = jest.fn();
const mockStopSessionRecorder = jest.fn();
const mockResumeSessionRecorder = jest.fn();
const mockAddAction = jest.fn();
const mockSetGlobalAttributes = jest.fn();
const mockUseGetStartupConfig = jest.fn();
const mockUseAuthContext = jest.fn();
const mockUseLocation = jest.fn();

jest.mock('./browser', () => ({
  __esModule: true,
  default: {
    addAction: (...args: unknown[]) => mockAddAction(...args),
    init: (...args: unknown[]) => mockInit(...args),
    stopSessionRecorder: () => mockStopSessionRecorder(),
    resumeSessionRecorder: () => mockResumeSessionRecorder(),
    getSessionId: () => mockGetSessionId(),
    setGlobalAttributes: (...args: unknown[]) => mockSetGlobalAttributes(...args),
  },
}));

jest.mock('./diagnostics', () => ({
  discardEarlyRumQueue: jest.fn(),
  queueSpaRouteChange: jest.fn(),
  forwardQueuedAssetEvents: jest.fn(),
  restoreRumEmitter: jest.fn(),
  startRumDiagnostics: jest.fn(),
}));

const { discardEarlyRumQueue, queueSpaRouteChange, restoreRumEmitter, startRumDiagnostics } =
  jest.requireMock('./diagnostics');

jest.mock('./logs', () => ({
  startClientLogs: jest.fn(),
  stopClientLogs: jest.fn(),
}));

const { startClientLogs, stopClientLogs } = jest.requireMock('./logs');

jest.mock('~/data-provider', () => ({
  useGetStartupConfig: () => mockUseGetStartupConfig(),
}));

jest.mock('~/hooks/AuthContext', () => ({
  useAuthContext: () => mockUseAuthContext(),
}));

jest.mock('react-router-dom', () => ({
  ...jest.requireActual('react-router-dom'),
  useLocation: () => mockUseLocation(),
}));

describe('useRum', () => {
  beforeEach(() => {
    jest.clearAllMocks();
    mockGetSessionId.mockReset();
    mockInit.mockReset();
    mockUseGetStartupConfig.mockReturnValue({ data: undefined, isFetched: false });
    mockUseLocation.mockReturnValue({ pathname: '/c/conversation-123' });
    mockUseAuthContext.mockReturnValue({
      isAuthenticated: true,
      token: 'jwt-token',
      user: {
        id: 'user-123',
        role: 'USER',
        tenantId: 'org-123',
        email: '[email protected]',
      },
    });
  });

  it('initializes HyperDX public-token RUM with privacy defaults and safe attributes', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: 'https://rum.example.com',
          serviceName: 'librechat-web',
          authMode: 'publicToken',
          publicToken: 'public-token',
          tracePropagationTargets: ['https://librechat.example.com'],
        },
      },
    });

    renderHook(() => useRum());

    await waitFor(() => {
      expect(mockInit).toHaveBeenCalledWith({
        advancedNetworkCapture: false,
        apiKey: 'public-token',
        consoleCapture: false,
        disableReplay: true,
        maskAllInputs: true,
        maskAllText: true,
        service: 'librechat-web',
        tracePropagationTargets: ['https://librechat.example.com'],
        url: 'https://rum.example.com',
      });
    });

    expect(mockSetGlobalAttributes).toHaveBeenCalledWith({
      clientBuildId: 'unknown',
      route: '/c/:conversationId',
      role: 'USER',
      userId: 'user-123',
      orgId: 'org-123',
      serviceName: 'librechat-web',
    });
    expect(mockSetGlobalAttributes).not.toHaveBeenCalledWith(
      expect.objectContaining({ email: '[email protected]' }),
    );
    expect(startRumDiagnostics).toHaveBeenCalledWith(
      expect.objectContaining({ init: expect.any(Function) }),
      expect.any(Function),
    );
    expect(mockResumeSessionRecorder).not.toHaveBeenCalled();
  });

  it('does not initialize RUM for unsupported auth modes', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: 'https://rum.example.com/ingest',
          serviceName: 'librechat-web',
          authMode: 'userJwt',
          publicToken: 'public-token',
        },
      },
    });

    renderHook(() => useRum());

    expect(mockInit).not.toHaveBeenCalled();
    expect(discardEarlyRumQueue).toHaveBeenCalled();
  });

  it('captures masked replays only when opted in and stops recording on unmount', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
          sessionReplay: { enabled: true },
          disableReplay: true,
        },
      },
    });

    const { unmount } = renderHook(() => useRum());
    await waitFor(() => expect(mockResumeSessionRecorder).toHaveBeenCalled());
    expect(mockInit).toHaveBeenCalledWith(
      expect.objectContaining({ disableReplay: false, maskAllInputs: true, maskAllText: true }),
    );
    unmount();
    expect(mockStopSessionRecorder).toHaveBeenCalledTimes(1);
  });

  it('honors an explicit replay-off policy over a legacy replay opt-in', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
          sessionReplay: { enabled: false },
          disableReplay: false,
        },
      },
    });
    renderHook(() => useRum());
    await waitFor(() => expect(mockInit).toHaveBeenCalled());
    expect(mockInit).toHaveBeenCalledWith(expect.objectContaining({ disableReplay: true }));
    expect(mockResumeSessionRecorder).not.toHaveBeenCalled();
  });

  it.each([
    '/login',
    '/login/2fa',
    '/login/2fa/setup',
    '/register',
    '/reset-password',
    '/verify',
    '/oauth/success',
  ])('does not start replay on %s even in public-token mode', async (pathname) => {
    mockUseAuthContext.mockReturnValue({ token: undefined, user: undefined });
    mockUseLocation.mockReturnValue({ pathname, search: '?tempToken=fake-login-token' });
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: 'https://collector.example',
          serviceName: 'librechat-web',
          authMode: 'publicToken',
          publicToken: 'public-test-key',
          sessionReplay: { enabled: true },
        },
      },
    });
    renderHook(() => useRum());
    await waitFor(() => expect(mockInit).toHaveBeenCalled());
    expect(mockInit).toHaveBeenCalledWith(expect.objectContaining({ disableReplay: true }));
    expect(mockResumeSessionRecorder).not.toHaveBeenCalled();
  });

  it('stops recording on an auth-route transition even while a session token remains present', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
          sessionReplay: { enabled: true },
        },
      },
    });
    const { rerender } = renderHook(() => useRum());
    await waitFor(() => expect(mockResumeSessionRecorder).toHaveBeenCalledTimes(1));
    mockUseLocation.mockReturnValue({
      pathname: '/login/2fa',
      search: '?tempToken=fake-login-token',
    });
    rerender();
    await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
    expect(mockStopSessionRecorder).toHaveBeenCalledTimes(1);
    expect(mockInit).toHaveBeenLastCalledWith(expect.objectContaining({ disableReplay: true }));
    expect(mockResumeSessionRecorder).toHaveBeenCalledTimes(1);
  });

  it('stops recording when proxy authentication is lost', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
          disableReplay: false,
        },
      },
    });

    const { rerender } = renderHook(() => useRum());
    await waitFor(() => expect(mockResumeSessionRecorder).toHaveBeenCalled());
    mockUseAuthContext.mockReturnValue({ token: undefined, user: undefined });
    rerender();
    expect(mockStopSessionRecorder).toHaveBeenCalledTimes(1);
  });

  it('stops an active recorder when replay is disabled in startup config', async () => {
    let rum = {
      provider: 'hyperdx',
      enabled: true,
      url: '/api/rum',
      serviceName: 'librechat-web',
      authMode: 'proxy',
      disableReplay: false,
    };
    mockUseGetStartupConfig.mockImplementation(() => ({ isFetched: true, data: { rum } }));
    const { rerender } = renderHook(() => useRum());
    await waitFor(() => expect(mockResumeSessionRecorder).toHaveBeenCalledTimes(1));

    rum = { ...rum, disableReplay: true };
    rerender();
    await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
    expect(mockStopSessionRecorder).toHaveBeenCalledTimes(1);
    expect(mockResumeSessionRecorder).toHaveBeenCalledTimes(1);
    expect(mockInit).toHaveBeenLastCalledWith(expect.objectContaining({ disableReplay: true }));
  });

  it('does not re-sample general RUM when replay policy changes', async () => {
    const random = jest.spyOn(Math, 'random').mockReturnValueOnce(0.1).mockReturnValue(0.9);
    try {
      let rum = {
        provider: 'hyperdx',
        enabled: true,
        url: '/api/rum',
        serviceName: 'librechat-web',
        authMode: 'proxy',
        sessionReplay: { enabled: true },
        sampleRate: 0.5,
      };
      mockUseGetStartupConfig.mockImplementation(() => ({ isFetched: true, data: { rum } }));
      const { rerender } = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      rum = { ...rum, sessionReplay: { enabled: false } };
      rerender();
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
      expect(random).toHaveBeenCalledTimes(1);
      expect(mockStopSessionRecorder).toHaveBeenCalledTimes(1);
      expect(mockInit).toHaveBeenLastCalledWith(expect.objectContaining({ disableReplay: true }));
    } finally {
      random.mockRestore();
    }
  });

  it('discards the early RUM queue when sampling excludes the page', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: 'https://rum.example.com',
          serviceName: 'librechat-web',
          authMode: 'publicToken',
          publicToken: 'public-token',
          sampleRate: 0,
        },
      },
    });

    renderHook(() => useRum());

    expect(mockInit).not.toHaveBeenCalled();
    expect(discardEarlyRumQueue).toHaveBeenCalled();
  });

  it('discards and stops route buffering when startup config has no RUM config', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      data: {},
      isFetched: true,
    });

    const { rerender } = renderHook(() => useRum());

    expect(discardEarlyRumQueue).toHaveBeenCalled();

    mockUseLocation.mockReturnValue({ pathname: '/login' });
    rerender();

    expect(queueSpaRouteChange).not.toHaveBeenCalled();
  });

  it('preserves the early RUM queue while proxy mode waits for an auth token', async () => {
    mockUseAuthContext.mockReturnValue({
      isAuthenticated: false,
      token: undefined,
      user: undefined,
    });
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
        },
      },
    });

    renderHook(() => useRum());

    expect(mockInit).not.toHaveBeenCalled();
    expect(discardEarlyRumQueue).not.toHaveBeenCalled();
  });

  it('restores the RUM emitter when an initialized config becomes valid again', async () => {
    const validRumConfig = {
      provider: 'hyperdx',
      enabled: true,
      url: 'https://rum.example.com',
      serviceName: 'librechat-web',
      authMode: 'publicToken',
      publicToken: 'public-token',
    };
    let rumConfig = validRumConfig;
    mockUseGetStartupConfig.mockImplementation(() => ({
      isFetched: true,
      data: {
        rum: rumConfig,
      },
    }));

    const { rerender } = renderHook(() => useRum());

    await waitFor(() => {
      expect(mockInit).toHaveBeenCalled();
    });

    rumConfig = { ...validRumConfig, enabled: false };
    rerender();

    expect(discardEarlyRumQueue).toHaveBeenCalled();

    rumConfig = { ...validRumConfig };
    rerender();

    expect(restoreRumEmitter).toHaveBeenCalledWith(
      expect.objectContaining({ init: expect.any(Function) }),
    );
  });

  it('initializes proxy RUM with the LibreChat bearer token for same-origin ingest', async () => {
    const fetchMock = jest.fn(
      (_input: RequestInfo | URL, _init?: RequestInit): Promise<Response> =>
        Promise.resolve({ ok: true, status: 200 } as Response),
    );
    window.fetch = Object.assign(fetchMock, { preconnect: () => undefined });
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
        },
      },
    });

    renderHook(() => useRum());

    await waitFor(() => {
      expect(mockInit).toHaveBeenCalledWith({
        advancedNetworkCapture: false,
        apiKey: 'librechat-rum-proxy',
        consoleCapture: false,
        disableReplay: true,
        maskAllInputs: true,
        maskAllText: true,
        service: 'librechat-web',
        tracePropagationTargets: undefined,
        url: '/api/rum',
      });
    });

    await window.fetch('/api/rum/v1/traces', { method: 'POST' });

    const headers = fetchMock.mock.calls[0]?.[1]?.headers;
    expect(headers).toBeInstanceOf(Headers);
    expect((headers as Headers).get('authorization')).toBe('Bearer jwt-token');
  });

  it('does not initialize proxy RUM without an authenticated token', async () => {
    mockUseAuthContext.mockReturnValue({
      isAuthenticated: false,
      token: undefined,
      user: undefined,
    });
    mockUseGetStartupConfig.mockReturnValue({
      isFetched: true,
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: '/api/rum',
          serviceName: 'librechat-web',
          authMode: 'proxy',
        },
      },
    });

    renderHook(() => useRum());

    expect(mockInit).not.toHaveBeenCalled();
    expect(discardEarlyRumQueue).not.toHaveBeenCalled();
  });

  it('queues SPA route changes through the shared early RUM channel', async () => {
    mockUseGetStartupConfig.mockReturnValue({
      data: {
        rum: {
          provider: 'hyperdx',
          enabled: true,
          url: 'https://rum.example.com',
          serviceName: 'librechat-web',
          authMode: 'publicToken',
          publicToken: 'public-token',
        },
      },
    });

    const { rerender } = renderHook(() => useRum());

    await waitFor(() => {
      expect(mockInit).toHaveBeenCalled();
    });

    mockUseLocation.mockReturnValue({ pathname: '/login' });
    rerender();

    expect(queueSpaRouteChange).toHaveBeenCalledWith('/c/:conversationId', '/login');
  });
  describe('client logs', () => {
    const proxyRum = {
      provider: 'hyperdx',
      enabled: true,
      url: '/api/rum',
      serviceName: 'librechat-web',
      authMode: 'proxy',
      environment: 'demo',
      clientLogs: true,
    };

    it('starts proxy-mode client logs on the same-origin logs path with the session token', () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });

      renderHook(() => useRum());

      expect(startClientLogs).toHaveBeenCalledWith(
        expect.objectContaining({
          endpoint: '/api/rum/v1/logs',
          serviceName: 'librechat-web',
          environment: 'demo',
        }),
      );
      const [{ getToken }] = startClientLogs.mock.calls[0];
      expect(getToken()).toBe('jwt-token');
    });

    const currentSessionReader = (): (() => string | undefined) =>
      startClientLogs.mock.calls.at(-1)[0].getSessionId;

    const signInAsNextUser = () => {
      mockUseAuthContext.mockReturnValue({
        isAuthenticated: true,
        token: 'next-user-token',
        user: { id: 'user-456', role: 'USER', tenantId: 'org-456' },
      });
      mockInit.mockImplementationOnce(() => mockGetSessionId.mockReturnValue('sdk-session-next'));
    };

    it('never reads a retired hook SDK session when a new authenticated layout mounts', async () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      mockGetSessionId.mockReturnValue('sdk-session-prior');
      const first = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      const retiredReader = currentSessionReader();
      expect(retiredReader()).toBe('sdk-session-prior');
      first.unmount();
      signInAsNextUser();
      renderHook(() => useRum());
      expect(retiredReader()).toBeUndefined();
      expect(currentSessionReader()()).toBeUndefined();
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
      expect(currentSessionReader()()).toBe('sdk-session-next');
    });

    it('clears SDK correlation on logout and waits for the new login initialization', async () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      mockGetSessionId.mockReturnValue('sdk-session-prior');
      const { rerender } = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      const priorReader = currentSessionReader();
      mockUseAuthContext.mockReturnValue({ token: undefined, user: undefined });
      rerender();
      expect(priorReader()).toBeUndefined();
      signInAsNextUser();
      rerender();
      expect(currentSessionReader()()).toBeUndefined();
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
      expect(currentSessionReader()()).toBe('sdk-session-next');
    });

    it('replaces the exporter before correlating a direct account or tenant switch', async () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      mockGetSessionId.mockReturnValue('sdk-session-prior');
      const { rerender } = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      const stopCount = stopClientLogs.mock.calls.length;
      signInAsNextUser();
      rerender();
      expect(stopClientLogs.mock.calls.length).toBeGreaterThan(stopCount);
      expect(currentSessionReader()()).toBeUndefined();
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
      expect(currentSessionReader()()).toBe('sdk-session-next');
    });

    it('keeps SDK correlation on a same-account token refresh without reinitialization', async () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      mockGetSessionId.mockReturnValue('sdk-session-current');
      const { rerender } = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      mockUseAuthContext.mockReturnValue({
        token: 'refreshed-token',
        user: { id: 'user-123', role: 'USER', tenantId: 'org-123' },
      });
      rerender();
      expect(currentSessionReader()()).toBe('sdk-session-current');
      expect(startClientLogs.mock.calls.at(-1)[0].getToken()).toBe('refreshed-token');
      await act(async () => undefined);
      expect(mockInit).toHaveBeenCalledTimes(1);
    });

    it('keeps new-login logs on fallback correlation if SDK initialization fails', async () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      mockGetSessionId.mockReturnValue('sdk-session-prior');
      const first = renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(1));
      first.unmount();
      mockUseAuthContext.mockReturnValue({ token: 'next-user-token', user: { id: 'user-456' } });
      mockInit.mockImplementationOnce(() => {
        throw new Error('SDK unavailable');
      });
      renderHook(() => useRum());
      await waitFor(() => expect(mockInit).toHaveBeenCalledTimes(2));
      expect(currentSessionReader()()).toBeUndefined();
      expect(startClientLogs.mock.calls.at(-1)[0].getToken()).toBe('next-user-token');
    });

    it('keeps client logs off when the server leaves them disabled', () => {
      mockUseGetStartupConfig.mockReturnValue({
        isFetched: true,
        data: { rum: { ...proxyRum, clientLogs: false } },
      });

      renderHook(() => useRum());

      expect(startClientLogs).not.toHaveBeenCalled();
      expect(stopClientLogs).toHaveBeenCalled();
    });

    it('never starts client logs in public-token mode', () => {
      mockUseGetStartupConfig.mockReturnValue({
        isFetched: true,
        data: {
          rum: {
            ...proxyRum,
            url: 'https://rum.example.com',
            authMode: 'publicToken',
            publicToken: 'public-token',
          },
        },
      });

      renderHook(() => useRum());

      expect(startClientLogs).not.toHaveBeenCalled();
    });

    it('follows RUM session sampling', () => {
      mockUseGetStartupConfig.mockReturnValue({
        isFetched: true,
        data: { rum: { ...proxyRum, sampleRate: 0 } },
      });

      renderHook(() => useRum());

      expect(startClientLogs).not.toHaveBeenCalled();
      expect(stopClientLogs).toHaveBeenCalled();
    });

    it('stops client logs when the session token goes away', () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      const { rerender } = renderHook(() => useRum());
      expect(startClientLogs).toHaveBeenCalledTimes(1);

      mockUseAuthContext.mockReturnValue({
        isAuthenticated: false,
        token: undefined,
        user: undefined,
      });
      rerender();

      expect(stopClientLogs).toHaveBeenCalled();
    });

    it('stops client logs when the authenticated layout unmounts', () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: { rum: proxyRum } });
      const { unmount } = renderHook(() => useRum());
      stopClientLogs.mockClear();

      unmount();

      expect(stopClientLogs).toHaveBeenCalledTimes(1);
    });

    it('stops client logs when startup config has no RUM config', () => {
      mockUseGetStartupConfig.mockReturnValue({ isFetched: true, data: {} });

      renderHook(() => useRum());

      expect(startClientLogs).not.toHaveBeenCalled();
      expect(stopClientLogs).toHaveBeenCalled();
    });
  });
});