✨ Add initial Salesforce support.

packages/core/src/domain/report/reportObservable.ts

@@ -60,11 +60,16 @@ function createReportObservable(reportTypes: ReportType[]) {
 
 function createCspViolationReportObservable(configuration: Configuration) {
   return new Observable<RawReportError>((observable) => {
-    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
-      observable.notify(buildRawReportErrorFromCspViolation(event))
-    })
+    // Salesforce does not allow to add a securitypolicyviolation event listener. https://developer.salesforce.com/tools/lws-distortion-viewer
+    try {
+      const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
+        observable.notify(buildRawReportErrorFromCspViolation(event))
+      })
 
-    return stop
+      return stop
+    } catch {
+      return
+    }
   })
 }
 

packages/core/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -8,6 +8,7 @@ import { toSessionString, toSessionState } from '../sessionState'
 import { Observable } from '../../../tools/observable'
 import { mockable } from '../../../tools/mockable'
 import { monitorError } from '../../../tools/monitor'
+import { noop } from '../../../tools/utils/functionUtils'
 import type { CookieAccess } from '../../../browser/cookieAccess'
 import {
   areCookiesAuthorized,
@@ -16,9 +17,8 @@ import {
 } from '../../../browser/cookieAccess'
 import { timeStampNow, dateNow } from '../../../tools/utils/timeUtils'
 import { addTelemetryError } from '../../telemetry'
-
-const LOCK_QUERY_TIMEOUT = 1000
 import type { CookieStoreWindow } from '../../../browser/browser.types'
+import { addEventListener, DOM_EVENT } from '../../../browser/addEventListener'
 import { getLifecycleContext } from '../../../browser/lifecycleTracker'
 import { clearTimeout, setTimeout } from '../../../tools/timer'
 import type { Context } from '../../../tools/serialisation/context'
@@ -32,6 +32,7 @@ import type {
 } from './sessionStoreStrategy'
 
 const SESSION_COOKIE_VERSION = 0
+const LOCK_QUERY_TIMEOUT = 1000
 
 export async function selectCookieStrategy(
   configuration: Configuration
@@ -42,7 +43,7 @@ export async function selectCookieStrategy(
   }
 
   if (
-    mockable((window as CookieStoreWindow).cookieStore) &&
+    canUseCookieStoreStrategy(configuration) &&
     (await areCookiesAuthorized(createCookieStoreAccess, cookieOptions, configuration))
   ) {
     return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.COOKIE_STORE }
@@ -119,6 +120,20 @@ export function initCookieStrategy(
   }
 }
 
+function canUseCookieStoreStrategy(configuration: Configuration): boolean {
+  const cookieStore = mockable((window as CookieStoreWindow).cookieStore)
+  if (!cookieStore) {
+    return false
+  }
+  try {
+    const { stop } = addEventListener(configuration, cookieStore, DOM_EVENT.CHANGE, noop)
+    stop()
+    return true
+  } catch {
+    return false
+  }
+}
+
 interface LockQuerySnapshot {
   heldByOthers: number
   pendingCount: number

packages/core/src/tools/instrumentMethod.ts

@@ -117,14 +117,23 @@ export function instrumentMethod<TARGET extends { [key: string]: any }, METHOD e
     return result
   }
 
-  targetPrototype[method] = instrumentation as TARGET[METHOD]
+  // Salesforce makes History.prototype.pushState and History.prototype.replaceState readonly. https://help.salesforce.com/s/articleView?id=release-notes.rn_lws_distortions_added.htm&release=238&type=5
+  try {
+    targetPrototype[method] = instrumentation as TARGET[METHOD]
+  } catch {
+    return { stop: noop }
+  }
 
   return {
     stop: () => {
       stopped = true
       // If the instrumentation has been removed by a third party, keep the last one
       if (targetPrototype[method] === instrumentation) {
-        targetPrototype[method] = original
+        try {
+          targetPrototype[method] = original
+        } catch {
+          // Restore can be rejected by sandboxed runtimes; the instrumentation is already stopped.
+        }
       }
     },
   }

packages/rum-core/src/browser/cookieObservable.ts

@@ -27,11 +27,14 @@ export function createCookieObservable(configuration: Configuration, cookieName:
 
 function listenToCookieStoreChange(configuration: Configuration) {
   return (cookieName: string, callback: (event: string | undefined) => void) => {
-    const listener = addEventListener(
-      configuration,
-      (window as CookieStoreWindow).cookieStore!,
-      DOM_EVENT.CHANGE,
-      (event) => {
+    // Lightning Web Security does not support the change event of CookieStore objects. https://developer.salesforce.com/tools/lws-distortion-viewer
+    const cookieStore = (window as CookieStoreWindow).cookieStore
+    if (!cookieStore) {
+      return watchCookieFallback(cookieName, callback)
+    }
+
+    try {
+      const listener = addEventListener(configuration, cookieStore, DOM_EVENT.CHANGE, (event) => {
         // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.
         // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226
         const changeEvent =
@@ -40,9 +43,11 @@ function listenToCookieStoreChange(configuration: Configuration) {
         if (changeEvent) {
           callback(changeEvent.value)
         }
-      }
-    )
-    return listener.stop
+      })
+      return listener.stop
+    } catch {
+      return watchCookieFallback(cookieName, callback)
+    }
   }
 }
 

packages/rum-core/src/domain/contexts/urlContexts.ts

@@ -41,8 +41,9 @@ export function startUrlContexts(
   let previousViewUrl: string | undefined
 
   lifeCycle.subscribe(LifeCycleEventType.BEFORE_VIEW_CREATED, ({ startClocks, url }) => {
-    const locationHref = mockable(location).href
+    const locationHref = getLocationHref()
     const viewUrl = url !== undefined ? buildUrl(url, locationHref).href : locationHref
+
     urlContextHistory.add(
       buildUrlContext({
         url: viewUrl,
@@ -103,3 +104,12 @@ export function startUrlContexts(
     },
   }
 }
+
+// Preserves existing global location behavior but in Salesforce access through explicit window as documented:  https://developer.salesforce.com/docs/platform/lightning-components-security/guide/lws-limitations.html#:~:text=The%20location%20property,window.location
+function getLocationHref() {
+  try {
+    return mockable(location).href
+  } catch {
+    return mockable(window.location).href
+  }
+}

packages/rum-slim/package.json

@@ -16,6 +16,7 @@
   "scripts": {
     "build": "node ../../scripts/build/build-package.ts --modules --bundle datadog-rum-slim.js",
     "build:bundle": "node ../../scripts/build/build-package.ts --bundle datadog-rum-slim.js",
+    "build:salesforce": "node ../../scripts/build/build-package.ts --bundle datadog-rum-salesforce.js --entry ./src/entries/salesforce.ts",
     "prepack": "yarn build"
   },
   "dependencies": {

packages/rum-slim/src/domain/salesforce/viewNameTracker.ts

@@ -0,0 +1,187 @@
+import { addEventListener, buildUrl, DOM_EVENT, instrumentMethod, noop, setTimeout } from '@datadog/browser-core'
+import type { RumPublicApi, ViewOptions } from '@datadog/browser-rum-core'
+
+export interface SalesforceLocation {
+  pathname?: string
+  href?: string
+}
+
+interface StartSalesforceViewNameTrackingOptions {
+  getRumPublicApi: () => Pick<RumPublicApi, 'setViewName' | 'startView'> | undefined
+  getLocation?: () => SalesforceLocation | undefined
+}
+
+interface SalesforceView {
+  key: string
+  url?: string
+}
+
+export function startSalesforceViewNameTracking(options: StartSalesforceViewNameTrackingOptions) {
+  const getLocation = options.getLocation ?? getNavigationLocation
+  const initialView = resolveCurrentView(getLocation())
+  let lastViewKey = initialView?.key
+  const eventListenerConfiguration = { allowUntrustedEvents: true }
+
+  if (initialView) {
+    setCurrentViewName(initialView)
+  }
+
+  const { stop: stopInstrumentingPushState } = instrumentMethod(
+    getHistoryInstrumentationTarget('pushState'),
+    'pushState',
+    ({ onPostCall }) => {
+      onPostCall(scheduleSetCurrentViewName)
+    }
+  )
+  const { stop: stopInstrumentingReplaceState } = instrumentMethod(
+    getHistoryInstrumentationTarget('replaceState'),
+    'replaceState',
+    ({ onPostCall }) => {
+      onPostCall(scheduleSetCurrentViewName)
+    }
+  )
+
+  const { stop: stopListeningPopState } = addEventListener(
+    eventListenerConfiguration,
+    window,
+    DOM_EVENT.POP_STATE,
+    scheduleSetCurrentViewName
+  )
+  const { stop: stopListeningHashChange } = addEventListener(
+    eventListenerConfiguration,
+    window,
+    DOM_EVENT.HASH_CHANGE,
+    scheduleSetCurrentViewName
+  )
+  const { stop: stopListeningClick } = addEventListener(
+    eventListenerConfiguration,
+    window,
+    DOM_EVENT.CLICK,
+    scheduleLocationCheckAfterClick,
+    { capture: true }
+  )
+
+  function scheduleLocationCheckAfterClick() {
+    setTimeout(trackCurrentView, 0)
+    setTimeout(trackCurrentView, 100)
+    setTimeout(trackCurrentView, 500)
+  }
+
+  function scheduleSetCurrentViewName() {
+    setTimeout(trackCurrentView, 0)
+  }
+
+  function trackCurrentView() {
+    const currentView = resolveCurrentView(getLocation())
+
+    if (!currentView) {
+      return
+    }
+
+    if (!lastViewKey || currentView.key === lastViewKey) {
+      setCurrentViewName(currentView)
+      lastViewKey = currentView.key
+      return
+    }
+
+    options.getRumPublicApi()?.startView(toViewOptions(currentView))
+    lastViewKey = currentView.key
+  }
+
+  function setCurrentViewName(view: SalesforceView) {
+    options.getRumPublicApi()?.setViewName(view.key)
+  }
+
+  return {
+    stop() {
+      stopInstrumentingPushState()
+      stopInstrumentingReplaceState()
+      stopListeningPopState()
+      stopListeningHashChange()
+      stopListeningClick()
+    },
+  }
+}
+
+function getNavigationLocation(): SalesforceLocation | undefined {
+  try {
+    return {
+      href: window.location.href,
+      pathname: window.location.pathname,
+    }
+  } catch {
+    return undefined
+  }
+}
+
+function resolveCurrentView(location: SalesforceLocation | undefined): SalesforceView | undefined {
+  if (!location) {
+    return undefined
+  }
+
+  const url = normalizeLocationHref(location.href)
+  const key = normalizePathname(location.pathname) ?? getPathnameFromHref(url)
+
+  if (!key) {
+    return undefined
+  }
+
+  return {
+    key,
+    url,
+  }
+}
+
+function toViewOptions(view: SalesforceView): ViewOptions {
+  return view.url ? { name: view.key, url: view.url } : { name: view.key }
+}
+
+function getPathnameFromHref(href: string | undefined) {
+  if (!href) {
+    return undefined
+  }
+
+  try {
+    return normalizePathname(buildUrl(href).pathname)
+  } catch {
+    return undefined
+  }
+}
+
+function normalizeLocationHref(href: unknown) {
+  if (typeof href !== 'string' || !href.trim()) {
+    return undefined
+  }
+
+  try {
+    return buildUrl(href).href
+  } catch {
+    return undefined
+  }
+}
+
+function normalizePathname(pathname: unknown) {
+  if (typeof pathname !== 'string' || !pathname.trim()) {
+    return undefined
+  }
+
+  let normalizedPathname = pathname.trim()
+
+  if (!normalizedPathname.startsWith('/')) {
+    normalizedPathname = `/${normalizedPathname}`
+  }
+
+  if (normalizedPathname.length > 1) {
+    normalizedPathname = normalizedPathname.replace(/\/+$/, '')
+  }
+
+  return normalizedPathname || '/'
+}
+
+function getHistoryInstrumentationTarget(methodName: 'pushState' | 'replaceState') {
+  if (typeof History === 'undefined') {
+    return { [methodName]: noop }
+  }
+
+  return Object.prototype.hasOwnProperty.call(history, methodName) ? history : History.prototype
+}