@crimson-education/browser-logger 4.1.4 → 5.0.0-beta.10

package/src/reporters/datadogReporter.ts

@@ -15,6 +15,95 @@ 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', (event) => {
+      const now = Date.now();
+      if (now - lastClickTime < 1000) {
+        // Rapid clicks within 1 second
+        clickCount++;
+        if (clickCount >= 3) {
+          this.recordFrustrationEvent('rapid_clicks', event);
+          clickCount = 0;
+        }
+      } else {
+        clickCount = 1;
+      }
+      lastClickTime = now;
+    });
+
+    // Track form errors (potential frustration)
+    document.addEventListener('invalid', (event) => {
+      this.recordFrustrationEvent('form_validation_error', event);
+    });
+
+    // Track 404 errors (potential frustration)
+    window.addEventListener('error', (event) => {
+      if (event.message.includes('404') || event.message.includes('Not Found')) {
+        this.recordFrustrationEvent('page_not_found', event);
+      }
+    });
+
+    // 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', event);
+        }
+      }
+    });
+  }
+
+  private recordFrustrationEvent(type: string, originalEvent: Event) {
+    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;
@@ -117,7 +206,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.
    */
-  allowedTracingOrigins?: (string | RegExp)[];
+  allowedTrackingOrigins?: (string | RegExp)[];
   /**
    * Enables action tracking for user interactions. This enables the Heatmap tab within Datadog
    */
@@ -142,21 +231,21 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
   // Only init datadog logs if something is using it.
   if (forwardErrorsToLogs !== true && enableLogTransport !== true) {
     datadogLogs.init({
-      site: config.site,
-      proxyUrl: config.proxyUrl,
+      site: config.site as any,
       clientToken: config.clientToken,
       service: info.service,
       env: info.environment,
       version: config.version ?? info.version,
 
-      sampleRate: config.logSampleRate ?? config.sampleRate ?? 100,
+      // Note: sampleRate is not available in newer Datadog versions
       beforeSend: config.beforeLogsSend,
 
       useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-      useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
+      // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
       trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
 
       forwardErrorsToLogs,
+      allowedTrackingOrigins: config.allowedTrackingOrigins,
     });
     datadogLogs.logger.setHandler(HandlerType.http);
   }
@@ -168,34 +257,33 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
 
   datadogRum.init({
     enableExperimentalFeatures: ['feature_flags'],
-    site: config.site,
-    proxyUrl: config.proxyUrl,
+    site: config.site as any,
     clientToken: config.clientToken,
     applicationId: config.applicationId,
     service: info.service,
     env: info.environment,
     version: config.version ?? info.version,
 
-    sampleRate: config.rumSampleRate ?? config.sampleRate ?? 100,
-    replaySampleRate: config.replaySampleRate ?? 100,
+    // Note: sampleRate is not available in newer Datadog versions
+    // Note: replaySampleRate is not available in newer Datadog versions
 
     useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-    useCrossSiteSessionCookie: config.useCrossSiteSessionCookie ?? false,
+    // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
     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',
-    allowedTracingOrigins: config.allowedTracingOrigins,
+    allowedTrackingOrigins: config.allowedTrackingOrigins,
     trackUserInteractions: config.trackUserInteractions ?? false,
 
     excludedActivityUrls: config.excludedActivityUrls,
   });
 
+  // Initialize frustration detector
+  // const frustrationDetector = new DatadogFrustrationDetector(config);
+
   const reporter: IReporter = {
     trackEvent: function (event: ReporterEvent): void {
       datadogRum.addAction(event.message, {
@@ -214,16 +302,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.addRumGlobalContext(key, value);
+          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.addLoggerGlobalContext(key, value);
+          datadogLogs.setGlobalContextProperty(key, value);
         } else {
-          datadogRum.removeRumGlobalContext(key);
+          datadogRum.removeGlobalContextProperty(key);
 
           // But this is valuable for logs ingested outside of the browser logger.
-          datadogLogs.removeLoggerGlobalContext(key);
+          datadogLogs.removeGlobalContextProperty(key);
         }
       }
     },
@@ -236,7 +324,7 @@ export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig
           name: user.name ?? user.email,
         });
       } else {
-        datadogRum.removeUser();
+        datadogRum.setUser({});
       }
     },
     setRouteName: function (routeName: string): void {