@crimson-education/browser-logger 5.0.3 → 5.0.5

package/src/reporters/datadogReporter.ts

@@ -14,6 +14,7 @@ import { datadogLogs, HandlerType, LogsInitConfiguration } from '@datadog/browse
 import { datadogRum, DefaultPrivacyLevel, RumInitConfiguration } from '@datadog/browser-rum';
 import { logTransports } from '../logger';
 import { DatadogLogTransportConfig, datadogTransport } from '../logger/datadogTransport';
+import { shouldSuppressAnalyticsEvent } from './analyticsNoise';
 
 // User frustration detection for Datadog Gen2
 class DatadogFrustrationDetector {
@@ -105,6 +106,16 @@ class DatadogFrustrationDetector {
 }
 
 export interface DatadogReporterConfig extends ReporterConfigBase {
+  /**
+   * Enable Datadog Browser Logs initialization and log transport wiring.
+   * Defaults to true.
+   */
+  logsEnabled?: boolean;
+  /**
+   * Enable Datadog Browser RUM initialization.
+   * Defaults to true.
+   */
+  rumEnabled?: boolean;
   /** The RUM application ID. */
   applicationId: string;
   /** A Datadog client token (Generated in the RUM Page) */
@@ -241,6 +252,8 @@ export interface DatadogReporterConfig extends ReporterConfigBase {
 
 export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig): IReporter {
   const isLocalhost = window.location.hostname === 'localhost';
+  const logsEnabled = config.logsEnabled ?? true;
+  const rumEnabled = config.rumEnabled ?? true;
 
   // Don't forward error logs by default, do enable the log transport by default
   // forwardErrorsToLogs incorrectly is called forwardConsoleLogs, this is for backwards compatibility
@@ -248,7 +261,7 @@ 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 (logsEnabled && (forwardErrorsToLogs === true || enableLogTransport === true)) {
     datadogLogs.init({
       site: config.site as any,
       clientToken: config.clientToken,
@@ -270,45 +283,67 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
   }
 
   // Add the datadog log transport
-  if (enableLogTransport) {
+  if (logsEnabled && enableLogTransport) {
     logTransports.push(datadogTransport(typeof config.logTransport === 'boolean' ? {} : config.logTransport));
   }
 
-  datadogRum.init({
-    enableExperimentalFeatures: ['feature_flags'],
-    site: config.site as any,
-    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,
-
-    useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-    // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
-    trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
-    trackViewsManually: config.trackViewsManually ?? false,
-    actionNameAttribute: config.actionNameAttribute ?? 'data-analytics-name',
-    beforeSend: config.beforeSend,
-
-    defaultPrivacyLevel: config.defaultPrivacyLevel ?? 'mask-user-input',
-    allowedTracingUrls: config.allowedTracingUrls ?? config.allowedTrackingOrigins,
- 
-    excludedActivityUrls: config.excludedActivityUrls,
-  });
-
-  // Initialize frustration detector
-  new DatadogFrustrationDetector(config);
+  if (rumEnabled) {
+    datadogRum.init({
+      enableExperimentalFeatures: ['feature_flags'],
+      site: config.site as any,
+      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,
+
+      useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
+      // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
+      trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
+      trackViewsManually: config.trackViewsManually ?? false,
+      actionNameAttribute: config.actionNameAttribute ?? 'data-analytics-name',
+      beforeSend: config.beforeSend,
+
+      defaultPrivacyLevel: config.defaultPrivacyLevel ?? 'mask-user-input',
+      allowedTracingUrls: config.allowedTracingUrls ?? config.allowedTrackingOrigins,
+
+      excludedActivityUrls: config.excludedActivityUrls,
+    });
+
+    // Initialize frustration detector
+    new DatadogFrustrationDetector(config);
+  }
+
+  function normalizeErrorForLogs(error: ReportError) {
+    if (error instanceof Error) {
+      return {
+        message: error.message,
+        name: error.name,
+        stack: error.stack,
+      };
+    }
+
+    return {
+      message: String(error),
+    };
+  }
 
   const reporter: IReporter = {
     trackEvent: function (event: ReporterEvent): void {
+      if (!rumEnabled) {
+        return;
+      }
+      if (shouldSuppressAnalyticsEvent(event.message, config.ignoreTrackEventPatterns)) {
+        return;
+      }
       datadogRum.addAction(event.message, {
         level: event.level,
         ...event.metadata,
@@ -317,6 +352,9 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
       });
     },
     addBreadcrumb: function (breadcrumb: ReporterBreadcrumb): void {
+      if (!rumEnabled) {
+        return;
+      }
       datadogRum.addAction(breadcrumb.message, {
         ...breadcrumb.metadata,
         category: breadcrumb.category,
@@ -325,20 +363,29 @@ 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);
-
-          // 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);
+          if (rumEnabled) {
+            datadogRum.setGlobalContextProperty(key, value);
+          }
+          if (logsEnabled) {
+            // 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);
+          }
         } else {
-          datadogRum.removeGlobalContextProperty(key);
-
-          // But this is valuable for logs ingested outside of the browser logger.
-          datadogLogs.removeGlobalContextProperty(key);
+          if (rumEnabled) {
+            datadogRum.removeGlobalContextProperty(key);
+          }
+          if (logsEnabled) {
+            // But this is valuable for logs ingested outside of the browser logger.
+            datadogLogs.removeGlobalContextProperty(key);
+          }
         }
       }
     },
     setUser: function (user: ReportUser | null): void {
+      if (!rumEnabled) {
+        return;
+      }
       if (user) {
         datadogRum.setUser({
           ...user,
@@ -351,9 +398,15 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
       }
     },
     setRouteName: function (routeName: string): void {
+      if (!rumEnabled) {
+        return;
+      }
       reporter.addMetadata({ routeName });
     },
     setPageName: function (pageName: string): void {
+      if (!rumEnabled) {
+        return;
+      }
       if (config.trackViewsManually) {
         datadogRum.startView(pageName);
       } else {
@@ -361,15 +414,35 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
       }
     },
     reportError: function (error: ReportError, metadata?: Metadata): void {
-      datadogRum.addError(error, metadata);
+      if (rumEnabled) {
+        datadogRum.addError(error, metadata);
+        return;
+      }
+      if (logsEnabled) {
+        const normalized = normalizeErrorForLogs(error);
+        datadogLogs.logger.error(normalized.message, {
+          ...metadata,
+          errorName: normalized.name,
+          errorStack: normalized.stack,
+        });
+      }
     },
     reportFeatureFlag: function (flag: ReporterFlag): void {
+      if (!rumEnabled) {
+        return;
+      }
       datadogRum.addFeatureFlagEvaluation(flag.name, flag.value);
     },
     recordSession: function (): void {
+      if (!rumEnabled) {
+        return;
+      }
       datadogRum.startSessionReplayRecording();
     },
     recordSessionStop: function (): void {
+      if (!rumEnabled) {
+        return;
+      }
       datadogRum.stopSessionReplayRecording();
     },
   };

package/src/reporters/posthogReporter.test.ts

@@ -154,6 +154,64 @@ describe('posthogReporter', () => {
     expect(posthogMock.stopSessionRecording).toHaveBeenCalled();
   });
 
+  it('suppresses configured trackEvent messages from PostHog analytics', () => {
+    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',
+        ignoreTrackEventPatterns: ['feedback fetch success'],
+      },
+    );
+
+    reporter.trackEvent({
+      message: 'feedback fetch success',
+      level: LogLevel.Info,
+    });
+
+    expect(posthogMock.capture).not.toHaveBeenCalled();
+
+    reporter.trackEvent({
+      message: 'message-sent',
+      level: LogLevel.Info,
+    });
+
+    expect(posthogMock.capture).toHaveBeenCalledWith('message-sent', {
+      message: 'message-sent',
+      level: LogLevel.Info,
+    });
+  });
+
+  it('does not suppress trackEvent messages unless configured', () => {
+    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',
+      },
+    );
+
+    reporter.trackEvent({
+      message: 'feedback fetch success',
+      level: LogLevel.Info,
+    });
+
+    expect(posthogMock.capture).toHaveBeenCalledWith('feedback fetch success', {
+      message: 'feedback fetch success',
+      level: LogLevel.Info,
+    });
+  });
+
   it('adds compatibility properties in before_send', () => {
     const beforeSend = jest.fn((captureResult) => captureResult);
 
@@ -198,6 +256,102 @@ describe('posthogReporter', () => {
     expect(beforeSend).toHaveBeenCalledWith(captureResult);
   });
 
+  it('uses the current URL for automatic pageviews instead of stale page metadata', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'crimson-app-frontend',
+        application: 'crimson-app',
+        environment: 'production',
+        version: '1.2.3',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://us.i.posthog.com',
+      },
+    );
+
+    reporter.setPageName('/calendar/schedule');
+    reporter.setRouteName('/calendar');
+
+    const initConfig = posthogMock.init.mock.calls[0]?.[1];
+    const captureResult = initConfig.before_send({
+      uuid: 'event-uuid',
+      event: '$pageview',
+      properties: {
+        $current_url: 'https://app.crimsoneducation.org/messages',
+      },
+    });
+
+    expect(captureResult.properties).toEqual(
+      expect.objectContaining({
+        url_path: '/messages',
+        url_path_group: '/messages',
+        view_name: '/messages',
+      }),
+    );
+  });
+
+  it('keeps a matching route template as the automatic pageview path group', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'crimson-app-frontend',
+        application: 'crimson-app',
+        environment: 'production',
+        version: '1.2.3',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://us.i.posthog.com',
+      },
+    );
+
+    reporter.setRouteName('/users/:id/roadmap');
+
+    const initConfig = posthogMock.init.mock.calls[0]?.[1];
+    const captureResult = initConfig.before_send({
+      uuid: 'event-uuid',
+      event: '$pageview',
+      properties: {
+        $current_url: 'https://app.crimsoneducation.org/users/123/roadmap',
+      },
+    });
+
+    expect(captureResult.properties).toEqual(
+      expect.objectContaining({
+        url_path: '/users/123/roadmap',
+        url_path_group: '/users/:id/roadmap',
+        view_name: '/users/123/roadmap',
+      }),
+    );
+  });
+
+  it('updates page metadata before capturing manual pageviews', () => {
+    const reporter = posthogReporter(
+      {
+        service: 'crimson-app-frontend',
+        application: 'crimson-app',
+        environment: 'production',
+        version: '1.2.3',
+      },
+      {
+        apiKey: 'ph_key',
+        apiHost: 'https://us.i.posthog.com',
+        trackViewsManually: true,
+      },
+    );
+
+    reporter.setRouteName('/users/:id/roadmap');
+    reporter.setPageName('/users/123/roadmap');
+
+    expect(posthogMock.register).toHaveBeenLastCalledWith({
+      pageName: '/users/123/roadmap',
+    });
+    expect(posthogMock.capture).toHaveBeenCalledWith('$pageview', {
+      pageName: '/users/123/roadmap',
+      routeName: '/users/:id/roadmap',
+    });
+  });
+
   it('preserves registered metadata when clearing the user', () => {
     const reporter = posthogReporter(
       {

package/src/reporters/posthogReporter.ts

@@ -10,6 +10,7 @@ import {
   ReportUser,
   ServiceInfo,
 } from '../types';
+import { shouldSuppressAnalyticsEvent } from './analyticsNoise';
 
 type PostHogValue = Properties[string];
 
@@ -106,6 +107,20 @@ function getCurrentUrl(captureResult: CaptureResult): string | undefined {
   return undefined;
 }
 
+function getStringProperty(properties: Properties | undefined, key: string): string | undefined {
+  const value = properties?.[key];
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function routeMatchesPath(routeName: string, urlPath: string): boolean {
+  const escapedRoute = routeName
+    .split('/')
+    .map((segment) => (segment.startsWith(':') ? '[^/]+' : segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')))
+    .join('/');
+
+  return new RegExp(`^${escapedRoute}/?$`).test(urlPath);
+}
+
 function getUserRoleValue(user: CompatibilityUser | null, metadata: Metadata): PostHogValue | undefined {
   const candidate =
     user?.userRole ?? user?.role ?? user?.userRoles ?? user?.roles ?? metadata.userRole ?? metadata.userRoles;
@@ -123,7 +138,15 @@ function buildCompatibilityProperties(
   const baseOrigin = typeof window !== 'undefined' ? window.location.origin : 'https://example.invalid';
   const urlObject = url ? new URL(url, baseOrigin) : null;
   const urlPath = urlObject?.pathname;
-  const pageName = typeof metadata.pageName === 'string' ? metadata.pageName : undefined;
+  const isPageview = captureResult.event === '$pageview';
+  const capturedPageName = getStringProperty(captureResult.properties, 'pageName');
+  const metadataPageName = typeof metadata.pageName === 'string' ? metadata.pageName : undefined;
+  const pageName = isPageview ? capturedPageName ?? urlPath : metadataPageName;
+  const capturedRouteName = getStringProperty(captureResult.properties, 'routeName');
+  const metadataRouteName = typeof metadata.routeName === 'string' ? metadata.routeName : undefined;
+  const routeName =
+    capturedRouteName ??
+    (urlPath && metadataRouteName && routeMatchesPath(metadataRouteName, urlPath) ? metadataRouteName : undefined);
 
   return {
     app_name: String(metadata.application ?? info.application ?? info.service),
@@ -139,6 +162,7 @@ function buildCompatibilityProperties(
     user_role: getUserRoleValue(user, metadata),
     url,
     url_path: urlPath,
+    url_path_group: routeName ?? (isPageview ? urlPath : undefined),
     view_id: posthog.getPageViewId(),
     view_name: pageName,
     browser: captureResult.properties?.$browser,
@@ -283,6 +307,9 @@ export function posthogReporter(info: ServiceInfo, config: PostHogReporterConfig
   const reporter: IReporter = {
     ...config,
     trackEvent: function (event: ReporterEvent): void {
+      if (shouldSuppressAnalyticsEvent(event.message, config.ignoreTrackEventPatterns)) {
+        return;
+      }
       posthog.capture(event.message, {
         message: event.message,
         level: event.level,
@@ -342,14 +369,14 @@ export function posthogReporter(info: ServiceInfo, config: PostHogReporterConfig
       reporter.addMetadata({ routeName });
     },
     setPageName: function (pageName: string): void {
+      reporter.addMetadata({ pageName });
+
       if (manualPageviews) {
         posthog.capture('$pageview', {
           pageName,
+          routeName: typeof currentMetadata.routeName === 'string' ? currentMetadata.routeName : undefined,
         });
-        return;
       }
-
-      reporter.addMetadata({ pageName });
     },
     reportError: function (error: ReportError, metadata?: Metadata): void {
       posthog.captureException(error, {

package/src/types/reporter.ts

@@ -163,6 +163,12 @@ export interface ReporterConfigBase {
    * This is useful to prevent data of no use for the reporter, or if the data keys are too long.
    */
   ignoreMetadataPatterns?: (string | RegExp)[];
+
+  /**
+   * Ignore specific trackEvent messages from analytics-style reporters.
+   * This keeps technical log noise out of product analytics/RUM while preserving log reporter output.
+   */
+  ignoreTrackEventPatterns?: (string | RegExp)[];
 }
 
 /**