@crimson-education/browser-logger 5.0.1-beta.3 → 5.0.1

package/src/reporters/datadogReporter.ts

@@ -15,95 +15,6 @@ import { datadogRum, DefaultPrivacyLevel, RumInitConfiguration } from '@datadog/
 import { logTransports } from '../logger';
 import { DatadogLogTransportConfig, datadogTransport } from '../logger/datadogTransport';
 
-// User frustration detection for Datadog Gen2
-class DatadogFrustrationDetector {
-  private config: DatadogReporterConfig;
-  private frustrationEvents: Array<{ type: string; timestamp: number }> = [];
-  private readonly FRUSTRATION_THRESHOLD = 3; // Number of events to trigger frustration
-  private readonly FRUSTRATION_WINDOW = 5000; // Time window in ms
-
-  constructor(config: DatadogReporterConfig) {
-    this.config = config;
-    if (config.trackFrustrations) {
-      this.setupFrustrationDetection();
-    }
-  }
-
-  private setupFrustrationDetection() {
-    // Track rapid clicks (potential frustration)
-    let clickCount = 0;
-    let lastClickTime = 0;
-
-    document.addEventListener('click', () => {
-      const now = Date.now();
-      if (now - lastClickTime < 1000) {
-        // Rapid clicks within 1 second
-        clickCount++;
-        if (clickCount >= 3) {
-          this.recordFrustrationEvent('rapid_clicks');
-          clickCount = 0;
-        }
-      } else {
-        clickCount = 1;
-      }
-      lastClickTime = now;
-    });
-
-    // Track form errors (potential frustration)
-    document.addEventListener('invalid', () => {
-      this.recordFrustrationEvent('form_validation_error');
-    });
-
-    // Track 404 errors (potential frustration)
-    window.addEventListener('error', (event) => {
-      if (event.message.includes('404') || event.message.includes('Not Found')) {
-        this.recordFrustrationEvent('page_not_found');
-      }
-    });
-
-    // Track network errors (potential frustration)
-    window.addEventListener('unhandledrejection', (event) => {
-      if (event.reason && typeof event.reason === 'object' && 'status' in event.reason) {
-        const status = (event.reason as any).status;
-        if (status >= 400) {
-          this.recordFrustrationEvent('network_error');
-        }
-      }
-    });
-  }
-
-  private recordFrustrationEvent(type: string) {
-    const now = Date.now();
-    this.frustrationEvents.push({ type, timestamp: now });
-
-    // Clean old events outside the window
-    this.frustrationEvents = this.frustrationEvents.filter((event) => now - event.timestamp < this.FRUSTRATION_WINDOW);
-
-    // Check if we have enough events to trigger frustration
-    if (this.frustrationEvents.length >= this.FRUSTRATION_THRESHOLD) {
-      this.triggerFrustrationDetection();
-    }
-  }
-
-  private triggerFrustrationDetection() {
-    const frustrationData = {
-      frustrationType: 'user_frustration_detected',
-      frustrationEvents: this.frustrationEvents.map((e) => e.type),
-      frustrationCount: this.frustrationEvents.length,
-      pageUrl: window.location.href,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Send frustration event to Datadog
-    if (typeof datadogRum !== 'undefined') {
-      datadogRum.addAction('User Frustration Detected', frustrationData);
-    }
-
-    // Clear events after reporting
-    this.frustrationEvents = [];
-  }
-}
-
 export interface DatadogReporterConfig extends ReporterConfigBase {
   /** The RUM application ID. */
   applicationId: string;
@@ -125,17 +36,11 @@ export interface DatadogReporterConfig extends ReporterConfigBase {
    * @deprecated Prefer using the dedicated `logSampleRate`, `rumSampleRate`, and `replaySampleRate` options.
    */
   sampleRate?: number;
-
-  sessionSampleRate?: number;
-  sessionReplaySampleRate?: number;
-
   /**
    * Sampling rate for browser log collection. Defaults to 100, meaning every log message is sent to Datadog.
    */
   logSampleRate?: number;
-
   /**
-   * @deprecated Prefer using `sessionSampleRate`.
    * Sampling rate for RUM session collection. Defaults to 100, meaning every browser session is tracked.
    *
    * RUM can be used to track things like core web vitals.
@@ -143,9 +48,7 @@ export interface DatadogReporterConfig extends ReporterConfigBase {
    * @see https://www.datadoghq.com/product/real-user-monitoring/
    */
   rumSampleRate?: number;
-
   /**
-   * @deprecated Prefer using `sessionReplaySampleRate`.
    * Applied after the RUM sample rate, and controls the percentage of sessions tracked as Browser RUM & Session Replay.
    * It defaults to 100, so every session is tracked as Browser RUM & Session Replay by default.
    *
@@ -157,21 +60,11 @@ export interface DatadogReporterConfig extends ReporterConfigBase {
    * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
    */
   useSecureSessionCookie?: boolean;
-
   /**
-   * @deprecated Prefer using `usePartitionedCrossSiteSessionCookie`.
    * Use a secure cross-site session cookie.
    * This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`
    */
   useCrossSiteSessionCookie?: boolean;
-
-  /**
-   * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.
-   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
-   * @default false
-   */
-  usePartitionedCrossSiteSessionCookie?: boolean;
-
   /**
    * Preserve the session across subdomains for the same site.
    */
@@ -224,8 +117,7 @@ export interface DatadogReporterConfig extends ReporterConfigBase {
   /**
    * A list of request origins used to inject tracing headers, to be able to connect RUM and backend tracing.
    */
-  allowedTrackingOrigins?: (string | RegExp)[];
-  allowedTracingUrls?: (string | RegExp)[];
+  allowedTracingOrigins?: (string | RegExp)[];
   /**
    * Enables action tracking for user interactions. This enables the Heatmap tab within Datadog
    */
@@ -248,23 +140,23 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
   const enableLogTransport = config.logTransport !== false;
 
   // Only init datadog logs if something is using it.
-  if (forwardErrorsToLogs === true || enableLogTransport === true) {
+  if (forwardErrorsToLogs !== true && enableLogTransport !== true) {
     datadogLogs.init({
-      site: config.site as any,
+      site: config.site,
+      proxyUrl: config.proxyUrl,
       clientToken: config.clientToken,
       service: info.service,
       env: info.environment,
       version: config.version ?? info.version,
 
+      sampleRate: config.logSampleRate ?? config.sampleRate ?? 100,
       beforeSend: config.beforeLogsSend,
 
-      usePartitionedCrossSiteSessionCookie: config.usePartitionedCrossSiteSessionCookie,
       useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-      // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
+      useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
       trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
 
       forwardErrorsToLogs,
-      allowedTrackingOrigins: config.allowedTrackingOrigins,
     });
     datadogLogs.logger.setHandler(HandlerType.http);
   }
@@ -276,37 +168,34 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
 
   datadogRum.init({
     enableExperimentalFeatures: ['feature_flags'],
-    site: config.site as any,
+    site: config.site,
+    proxyUrl: config.proxyUrl,
     clientToken: config.clientToken,
     applicationId: config.applicationId,
     service: info.service,
     env: info.environment,
     version: config.version ?? info.version,
 
-    usePartitionedCrossSiteSessionCookie: config.usePartitionedCrossSiteSessionCookie,
-    // Use correct Datadog v6 SDK options
-    sessionSampleRate: config.sessionSampleRate ?? config.rumSampleRate ?? config.sampleRate ?? 100,
-    sessionReplaySampleRate: config.sessionReplaySampleRate?? config.replaySampleRate ?? 100,
-
-    // Track interactions (Note: trackFrustrations is not available in Datadog v6)
-    trackUserInteractions: config.trackUserInteractions ?? config.trackInteractions ?? false,
+    sampleRate: config.rumSampleRate ?? config.sampleRate ?? 100,
+    replaySampleRate: config.replaySampleRate ?? 100,
 
     useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-    // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
+    useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
     trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
+
+    trackInteractions: config.trackInteractions ?? false,
+    trackFrustrations: config.trackFrustrations ?? false,
     trackViewsManually: config.trackViewsManually ?? false,
     actionNameAttribute: config.actionNameAttribute ?? 'data-analytics-name',
     beforeSend: config.beforeSend,
 
     defaultPrivacyLevel: config.defaultPrivacyLevel ?? 'mask-user-input',
-    allowedTracingUrls: config.allowedTracingUrls ?? config.allowedTrackingOrigins,
- 
+    allowedTracingOrigins: config.allowedTracingOrigins,
+    trackUserInteractions: config.trackUserInteractions ?? false,
+
     excludedActivityUrls: config.excludedActivityUrls,
   });
 
-  // Initialize frustration detector
-  new DatadogFrustrationDetector(config);
-
   const reporter: IReporter = {
     trackEvent: function (event: ReporterEvent): void {
       datadogRum.addAction(event.message, {
@@ -325,16 +214,16 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
     addMetadata: function (metadata: Metadata): void {
       for (const [key, value] of Object.entries(metadata)) {
         if (value !== null) {
-          datadogRum.setGlobalContextProperty(key, value);
+          datadogRum.addRumGlobalContext(key, value);
 
           // Note, this will add duplicate context data in logs.
           // But this is valuable for logs ingested outside of the browser logger.
-          datadogLogs.setGlobalContextProperty(key, value);
+          datadogLogs.addLoggerGlobalContext(key, value);
         } else {
-          datadogRum.removeGlobalContextProperty(key);
+          datadogRum.removeRumGlobalContext(key);
 
           // But this is valuable for logs ingested outside of the browser logger.
-          datadogLogs.removeGlobalContextProperty(key);
+          datadogLogs.removeLoggerGlobalContext(key);
         }
       }
     },
@@ -347,7 +236,7 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
           name: user.name ?? user.email,
         });
       } else {
-        datadogRum.setUser({});
+        datadogRum.removeUser();
       }
     },
     setRouteName: function (routeName: string): void {

package/src/reporters/posthogReporter.test.ts

@@ -0,0 +1,244 @@
+jest.mock('posthog-js', () => ({
+  __esModule: true,
+  default: {
+    init: jest.fn(),
+    capture: jest.fn(),
+    captureException: jest.fn(),
+    getPageViewId: jest.fn(() => 'view-123'),
+    get_session_id: jest.fn(() => 'session-123'),
+    identify: jest.fn(),
+    register: jest.fn(),
+    reset: jest.fn(),
+    startSessionRecording: jest.fn(),
+    stopSessionRecording: jest.fn(),
+    unregister: jest.fn(),
+  },
+}));
+
+import posthog from 'posthog-js';
+import { LogLevel } from '../types';
+import { normalizeProperties, posthogReporter } from './posthogReporter';
+
+const posthogMock = posthog as unknown as {
+  init: jest.Mock;
+  capture: jest.Mock;
+  captureException: jest.Mock;
+  getPageViewId: jest.Mock;
+  get_session_id: jest.Mock;
+  identify: jest.Mock;
+  register: jest.Mock;
+  reset: jest.Mock;
+  startSessionRecording: jest.Mock;
+  stopSessionRecording: jest.Mock;
+  unregister: jest.Mock;
+};
+
+describe('posthogReporter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('normalizes metadata into PostHog-safe properties', () => {
+    const normalized = normalizeProperties({
+      a: 1,
+      b: true,
+      c: 'value',
+      d: undefined,
+      e: null,
+      f: new Date('2026-07-03T00:00:00.000Z'),
+      g: new Error('boom'),
+      h: {
+        nested: 'yes',
+      },
+      i: [1, undefined, 'x'],
+    });
+
+    expect(normalized).toEqual({
+      a: 1,
+      b: true,
+      c: 'value',
+      f: '2026-07-03T00:00:00.000Z',
+      g: {
+        message: 'boom',
+        name: 'Error',
+        stack: expect.any(String),
+      },
+      h: {
+        nested: 'yes',
+      },
+      i: [1, 'x'],
+    });
+  });
+
+  it('maps browser-logger APIs onto PostHog', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'crimson-app-frontend',
+        application: 'crimson-app',
+        environment: 'production',
+        version: '1.2.3',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://eu.i.posthog.com',
+        replaySampleRate: 0,
+      },
+    );
+
+    expect(posthogMock.init).toHaveBeenCalledWith(
+      'ph_key',
+      expect.objectContaining({
+        api_host: 'https://eu.i.posthog.com',
+        before_send: expect.any(Function),
+        capture_pageview: 'history_change',
+        disable_session_recording: true,
+        person_profiles: 'identified_only',
+      }),
+    );
+
+    reporter.addMetadata({
+      namespace: 'production',
+      clearMe: null,
+    });
+    expect(posthogMock.unregister).toHaveBeenCalledWith('clearMe');
+    expect(posthogMock.register).toHaveBeenCalledWith({
+      namespace: 'production',
+    });
+
+    reporter.trackEvent({
+      message: 'message-sent',
+      level: LogLevel.Info,
+      metadata: {
+        userId: '123',
+      },
+      metrics: {
+        durationMs: 42,
+      },
+    });
+    expect(posthogMock.capture).toHaveBeenCalledWith('message-sent', {
+      message: 'message-sent',
+      level: LogLevel.Info,
+      userId: '123',
+      durationMs: 42,
+    });
+
+    reporter.setUser({
+      id: '123',
+      email: 'user@crimsoneducation.org',
+      name: 'Crimson User',
+    });
+    expect(posthogMock.identify).toHaveBeenCalledWith('123', {
+      email: 'user@crimsoneducation.org',
+      name: 'Crimson User',
+    });
+
+    reporter.reportError?.(new Error('broken'), {
+      routeName: 'messages',
+    });
+    expect(posthogMock.captureException).toHaveBeenCalledWith(
+      expect.any(Error),
+      expect.objectContaining({
+        message: 'broken',
+        routeName: 'messages',
+      }),
+    );
+
+    reporter.recordSession?.();
+    reporter.recordSessionStop?.();
+    expect(posthogMock.startSessionRecording).toHaveBeenCalledWith(true);
+    expect(posthogMock.stopSessionRecording).toHaveBeenCalled();
+  });
+
+  it('adds compatibility properties in before_send', () => {
+    const beforeSend = jest.fn((captureResult) => captureResult);
+
+    posthogReporter(
+      {
+        service: 'crimson-app-frontend',
+        application: 'crimson-app',
+        environment: 'production',
+        version: '1.2.3',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://eu.i.posthog.com',
+        beforeSend,
+      },
+    );
+
+    const initConfig = posthogMock.init.mock.calls[0]?.[1];
+    const captureResult = initConfig.before_send({
+      uuid: 'event-uuid',
+      event: 'message-sent',
+      properties: {
+        $current_url: 'https://app.crimsoneducation.org/messages/1',
+        $browser: 'Chrome',
+        $device_type: 'Desktop',
+        $geoip_country_name: 'New Zealand',
+      },
+    });
+
+    expect(captureResult.properties).toEqual(
+      expect.objectContaining({
+        app_name: 'crimson-app',
+        domain: 'app.crimsoneducation.org',
+        event_type: 'message-sent',
+        url: 'https://app.crimsoneducation.org/messages/1',
+        url_path: '/messages/1',
+        browser: 'Chrome',
+        device: 'Desktop',
+        geo: 'New Zealand',
+      }),
+    );
+    expect(beforeSend).toHaveBeenCalledWith(captureResult);
+  });
+
+  it('preserves registered metadata when clearing the user', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'student-center-frontend',
+        application: 'core-student-center',
+        environment: 'production',
+        version: '2.0.0',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://eu.i.posthog.com',
+      },
+    );
+
+    reporter.addMetadata({
+      application: 'core-student-center',
+      namespace: 'production',
+    });
+
+    reporter.setUser(null);
+
+    expect(posthogMock.reset).toHaveBeenCalled();
+    expect(posthogMock.register).toHaveBeenLastCalledWith({
+      application: 'core-student-center',
+      namespace: 'production',
+    });
+  });
+
+  it('treats an empty user id as a cleared user', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'new-roadmap',
+        environment: 'staging',
+        version: '1.0.0',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://eu.i.posthog.com',
+      },
+    );
+
+    reporter.setUser({
+      id: '',
+    });
+
+    expect(posthogMock.reset).toHaveBeenCalled();
+    expect(posthogMock.identify).not.toHaveBeenCalled();
+  });
+});