@crimson-education/browser-logger 5.0.0-beta.17 → 5.0.0-beta.19

package/src/reporters/datadogReporter.ts

@@ -1,359 +0,0 @@
-import {
-  IReporter,
-  ReporterBreadcrumb,
-  ReporterEvent,
-  Metadata,
-  ReportError,
-  ReportUser,
-  ServiceInfo,
-  ReporterConfigBase,
-  ReporterFlag,
-} from '../types';
-import { MatchOption } from '@datadog/browser-core';
-import { datadogLogs, HandlerType, LogsInitConfiguration } from '@datadog/browser-logs';
-import { datadogRum, DefaultPrivacyLevel, RumInitConfiguration } from '@datadog/browser-rum';
-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;
-  /** A Datadog client token (Generated in the RUM Page) */
-  clientToken: string;
-  /** The Datadog site parameter of your organization. */
-  site: string;
-  /** The Application's version (Overrides the browser logger version) */
-  version?: string;
-  /** Optional proxy URL */
-  proxyUrl?: string;
-
-  /**
-   * Controls the percentage of overall sessions being tracked. It defaults to 100, so every session is tracked by default.
-   *
-   * More specific sample rate options take priority over this option. For instance, if `logSampleRate` is 50 and `sampleRate`
-   * is 75, then the sample rate used for log messages will be `50`.
-   *
-   * @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;
-  /**
-   * 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.
-   *
-   * @see https://www.datadoghq.com/product/real-user-monitoring/
-   */
-  rumSampleRate?: number;
-  /**
-   * 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.
-   *
-   * These sessions end up with a session replay available in Datadog.
-   */
-  replaySampleRate?: number;
-
-  /**
-   * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
-   */
-  useSecureSessionCookie?: boolean;
-  /**
-   * 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;
-  /**
-   * Preserve the session across subdomains for the same site.
-   */
-  trackSessionAcrossSubdomains?: boolean;
-
-  /**
-   * Forward console.error logs, uncaught exceptions and network errors to Datadog.
-   * Defaults to false.
-   */
-  forwardConsoleLogs?: boolean;
-  /**
-   * Enables automatic collection of users actions.
-   */
-  trackInteractions?: boolean;
-  /**
-   * Enables automatic collection of user frustrations. Implies `trackInteractions`: true.
-   */
-  trackFrustrations?: boolean;
-  /**
-   * Allows you to control RUM views creation.
-   * You will need to call `Logger.setPageName()` to create a new view.
-   */
-  trackViewsManually?: boolean;
-  /**
-   * Specify your own attribute to be used to name actions.
-   * Defaults to `data-analytics-name` to coincide with analytics attributes used across reporters.
-   */
-  actionNameAttribute?: string;
-  /**
-   * Allows you to modify RUM events before they are sent to Datadog.
-   */
-  beforeSend?: RumInitConfiguration['beforeSend'];
-
-  /**
-   * Toggles/configures the Datadog Log Transport.
-   * Defaults to true.
-   */
-  logTransport?: boolean | DatadogLogTransportConfig;
-  /**
-   * Allows you to modify Log events before they are sent to Datadog (Can only be set at ).
-   */
-  beforeLogsSend?: LogsInitConfiguration['beforeSend'];
-
-  /**
-   * By enabling Session Replay, you can automatically mask sensitive elements from being recorded through the RUM Browser SDK.
-   *
-   * See https://docs.datadoghq.com/real_user_monitoring/session_replay/privacy_options
-   */
-  defaultPrivacyLevel?: DefaultPrivacyLevel;
-  /**
-   * 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)[];
-  /**
-   * Enables action tracking for user interactions. This enables the Heatmap tab within Datadog
-   */
-  trackUserInteractions?: boolean;
-
-  /**
-   * To improve the accuracy of activity determination
-   *
-   * See https://docs.datadoghq.com/real_user_monitoring/browser/monitoring_page_performance/#how-page-activity-is-calculated
-   */
-  excludedActivityUrls?: MatchOption[];
-}
-
-export function datadogReporter(info: ServiceInfo, config: DatadogReporterConfig): IReporter {
-  const isLocalhost = window.location.hostname === 'localhost';
-
-  // Don't forward error logs by default, do enable the log transport by default
-  // forwardErrorsToLogs incorrectly is called forwardConsoleLogs, this is for backwards compatibility
-  const forwardErrorsToLogs = config.forwardConsoleLogs ?? false;
-  const enableLogTransport = config.logTransport !== false;
-
-  // Only init datadog logs if something is using it.
-  if (forwardErrorsToLogs === true || enableLogTransport === true) {
-    datadogLogs.init({
-      site: config.site as any,
-      clientToken: config.clientToken,
-      service: info.service,
-      env: info.environment,
-      version: config.version ?? info.version,
-
-      beforeSend: config.beforeLogsSend,
-
-      useSecureSessionCookie: config.useSecureSessionCookie ?? !isLocalhost,
-      // Note: useCrossSiteSessionCookie is not available in newer Datadog versions
-      trackSessionAcrossSubdomains: config.trackSessionAcrossSubdomains,
-
-      forwardErrorsToLogs,
-      allowedTrackingOrigins: config.allowedTrackingOrigins,
-    });
-    datadogLogs.logger.setHandler(HandlerType.http);
-  }
-
-  // Add the datadog log transport
-  if (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,
-
-    // 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);
-
-  const reporter: IReporter = {
-    trackEvent: function (event: ReporterEvent): void {
-      datadogRum.addAction(event.message, {
-        level: event.level,
-        ...event.metadata,
-        ...event.tags,
-        ...event.metrics,
-      });
-    },
-    addBreadcrumb: function (breadcrumb: ReporterBreadcrumb): void {
-      datadogRum.addAction(breadcrumb.message, {
-        ...breadcrumb.metadata,
-        category: breadcrumb.category,
-      });
-    },
-    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);
-        } else {
-          datadogRum.removeGlobalContextProperty(key);
-
-          // But this is valuable for logs ingested outside of the browser logger.
-          datadogLogs.removeGlobalContextProperty(key);
-        }
-      }
-    },
-    setUser: function (user: ReportUser | null): void {
-      if (user) {
-        datadogRum.setUser({
-          ...user,
-          id: user.id,
-          email: user.email,
-          name: user.name ?? user.email,
-        });
-      } else {
-        datadogRum.setUser({});
-      }
-    },
-    setRouteName: function (routeName: string): void {
-      reporter.addMetadata({ routeName });
-    },
-    setPageName: function (pageName: string): void {
-      if (config.trackViewsManually) {
-        datadogRum.startView(pageName);
-      } else {
-        reporter.addMetadata({ pageName });
-      }
-    },
-    reportError: function (error: ReportError, metadata?: Metadata): void {
-      datadogRum.addError(error, metadata);
-    },
-    reportFeatureFlag: function (flag: ReporterFlag): void {
-      datadogRum.addFeatureFlagEvaluation(flag.name, flag.value);
-    },
-    recordSession: function (): void {
-      datadogRum.startSessionReplayRecording();
-    },
-    recordSessionStop: function (): void {
-      datadogRum.stopSessionReplayRecording();
-    },
-  };
-  return reporter;
-}

package/src/reporters/gtmReporter.ts

@@ -1,74 +0,0 @@
-import {
-  IReporter,
-  ReporterBreadcrumb,
-  ReporterEvent,
-  Metadata,
-  ReportUser,
-  ServiceInfo,
-  ReporterConfigBase,
-} from '../types';
-
-export type GTMReporterConfig = ReporterConfigBase;
-
-declare global {
-  interface Window {
-    dataLayer?: Record<string, any>[];
-  }
-}
-
-export function gtmReporter(info: ServiceInfo, config: GTMReporterConfig): IReporter {
-  let loadedDataLayer = !!window.dataLayer;
-  const baseMetadata = {
-    service: info.service,
-    domain: window.location.host,
-    environment: info.environment,
-    version: info.version,
-  };
-
-  const reporter: IReporter = {
-    ...config,
-    addMetadata: function (metadata: Metadata): void {
-      if (window.dataLayer) {
-        // Lazy load base metadata, e.g. if GTM isn't ready yet.
-        if (!loadedDataLayer) {
-          window.dataLayer.push(baseMetadata);
-          loadedDataLayer = true;
-        }
-
-        window.dataLayer.push(metadata);
-      }
-    },
-    trackEvent: function (event: ReporterEvent): void {
-      reporter.addMetadata({
-        ...event.metadata,
-        ...event.tags,
-        ...event.metrics,
-        event: event.message,
-        level: event.level,
-      });
-    },
-    addBreadcrumb: function (breadcrumb: ReporterBreadcrumb): void {
-      reporter.addMetadata({
-        ...breadcrumb.metadata,
-        event: breadcrumb.message,
-      });
-    },
-    setUser: function (user: ReportUser | null): void {
-      if (user) {
-        reporter.addMetadata({ user });
-      }
-    },
-    setRouteName: function (routeName: string): void {
-      reporter.addMetadata({ routeName });
-    },
-    setPageName: function (pageName: string): void {
-      reporter.addMetadata({ pageName });
-    },
-  };
-
-  if (loadedDataLayer) {
-    reporter.addMetadata(baseMetadata);
-  }
-
-  return reporter;
-}

package/src/reporters/index.ts

@@ -1,232 +0,0 @@
-import { isAboveLevel } from '../logger/utils';
-import {
-  IReporter,
-  LogLevel,
-  Metadata,
-  ReporterBreadcrumb,
-  ReporterEvent,
-  ReporterFilters,
-  ReporterFlag,
-  ReportError,
-  ReporterType,
-  ReportUser,
-  TrackedReporterEvent,
-} from '../types';
-import { filterReporterMetadata } from '../utils';
-
-export const reporters: Partial<Record<ReporterType, IReporter>> = {};
-
-export let globalEventLevel: LogLevel | undefined;
-/**
- * Sets the global event level.
- */
-export function setEventLevel(level: LogLevel | null): void {
-  globalEventLevel = level ?? undefined;
-}
-
-/**
- * Gets reporters, optionally with filters.
- * @param filters Filters to remove or specify specific reporters.
- * @returns Selected reporters, or all registered reporters.
- */
-function getReporters(filters?: ReporterFilters) {
-  let result = Object.entries(reporters);
-  if (filters?.excludeReporters) {
-    result = result.filter(([key]) => !filters?.excludeReporters?.includes(key as ReporterType));
-  }
-  if (filters?.toReporters) {
-    result = result.filter(([key]) => filters?.toReporters?.includes(key as ReporterType));
-  }
-  return result.map(([, reporter]) => reporter);
-}
-
-/**
- * Tracks an Analytics event.
- */
-export function trackEvent(event: ReporterEvent): void {
-  if (globalEventLevel && event.level && !isAboveLevel(event.level, globalEventLevel)) {
-    return;
-  }
-
-  for (const reporter of getReporters(event)) {
-    if (reporter.endpoints?.trackEvent === false) {
-      continue;
-    } else if (reporter.eventLevel && event.level && !isAboveLevel(event.level, reporter.eventLevel)) {
-      return;
-    }
-
-    const reporterEvent = { ...event };
-    reporterEvent.metadata = filterReporterMetadata(event.metadata, reporter);
-    reporterEvent.metrics = filterReporterMetadata(event.metrics, reporter);
-    reporterEvent.tags = filterReporterMetadata(event.tags, reporter);
-    reporter.trackEvent(reporterEvent);
-  }
-}
-
-/**
- * Tracks an Analytics event, recording the time since the last event, if available.
- */
-export function trackEventSinceLastAction(event: ReporterEvent): void {
-  if (globalEventLevel && event.level && !isAboveLevel(event.level, globalEventLevel)) {
-    return;
-  }
-
-  const lastEvent = getLastTrackedEvent();
-  if (lastEvent) {
-    const duration = new Date().getTime() - lastEvent.occurred.getTime();
-    trackEvent({
-      ...event,
-      metadata: {
-        ...event.metadata,
-        lastEventName: lastEvent.message,
-        timeSinceLastEvent: duration,
-      },
-    });
-  } else {
-    trackEvent(event);
-  }
-  sessionStorage.setItem('loggerLastEvent', JSON.stringify({ ...event, occurred: new Date() }));
-}
-
-/**
- * Gets the last tracked event, if available.
- */
-export function getLastTrackedEvent(): TrackedReporterEvent | null {
-  const eventStr = sessionStorage.getItem('loggerLastEvent');
-  if (!eventStr) return null;
-
-  const event: TrackedReporterEvent = JSON.parse(eventStr);
-  event.occurred = new Date(event.occurred);
-  return event;
-}
-
-/**
- * Breadcrumbs to create a trail of events that happened prior to an issue.
- * These events are very similar to traditional logs, but can record more rich structured data.
- */
-export function addBreadcrumb(breadcrumb: ReporterBreadcrumb): void {
-  for (const reporter of getReporters(breadcrumb)) {
-    if (reporter.endpoints?.addBreadcrumb === false) {
-      continue;
-    } else if (breadcrumb.category && reporter.ignoreBreadcrumbCategories?.includes(breadcrumb.category)) {
-      continue;
-    }
-
-    const reporterBreadcrumb = { ...breadcrumb };
-    reporterBreadcrumb.metadata = filterReporterMetadata(breadcrumb.metadata, reporter);
-    reporter.addBreadcrumb(reporterBreadcrumb);
-  }
-}
-
-/**
- * Adds global metadata to all events and logs.
- * @param metadata Metadata to add.
- * @param filters Optional filters to specify which reporters to add metadata to.
- */
-export function addMetadata(metadata: Metadata, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.addMetadata === false) {
-      continue;
-    }
-    reporter.addMetadata(filterReporterMetadata(metadata, reporter));
-  }
-}
-
-/**
- * Sets the user information in Analytics.
- * @param user User information, or null to clear.
- * @param filters Optional filters to specify which reporters to set the user for.
- */
-export function setUser(user: ReportUser | null, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.setUser === false) {
-      continue;
-    }
-    reporter.setUser(user);
-  }
-}
-
-/**
- * Sets the route name in Analytics.
- * Some Analytics services use this differentiate SPA Route vs Page changes.
- * @param routeName Name of the Route.
- * @param filters Optional filters to specify which reporters to set the route name for.
- */
-export function setRouteName(routeName: string, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.setRouteName === false) {
-      continue;
-    }
-    reporter.setRouteName(routeName);
-  }
-}
-
-/**
- * Sets the page name in Analytics.
- * @param pageName Name of the Page.
- * @param filters Optional filters to specify which reporters to set the page name for.
- */
-export function setPageName(pageName: string, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.setPageName === false) {
-      continue;
-    }
-    reporter.setPageName(pageName);
-  }
-}
-
-/**
- * Reports an Error in Reporters that support error tracking.
- * @param error Error data.
- * @param metadata Metadata to add to the error.
- * @param filters Optional filters to specify which reporters to report the error to.
- */
-export function reportError(error: ReportError, metadata?: Metadata, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.reportError === false) {
-      continue;
-    }
-    reporter.reportError?.(error, filterReporterMetadata(metadata, reporter));
-  }
-}
-
-/**
- * Report a feature flag evaluation, e.g. for surfacing in Datadog RUM.
- *
- * @param flag    Details about the feature flag evaluation
- * @param filters Filters to specify which reporters to start a session recording for.
- */
-export function reportFeatureFlag(flag: ReporterFlag, filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.reportFeatureFlag === false) {
-      continue;
-    }
-    reporter.reportFeatureFlag?.(flag);
-  }
-}
-
-/**
- * Starts a session recording in Analytics, e.g. RUM Session Replay
- * @param filters Optional filters to specify which reporters to start a session recording for.
- */
-export function recordSession(filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.recordSession === false) {
-      continue;
-    }
-    reporter.recordSession?.();
-  }
-}
-
-/**
- * Stops a session recording in Analytics, e.g. RUM Session Replay
- * @param filters Optional filters to specify which reporters to stop a session recording for.
- */
-export function recordSessionStop(filters?: ReporterFilters): void {
-  for (const reporter of getReporters(filters)) {
-    if (reporter.endpoints?.recordSessionStop === false) {
-      continue;
-    }
-    reporter.recordSessionStop?.();
-  }
-}