@sentry/replay 7.105.0 → 8.0.0-alpha.2

package/README.md

@@ -12,7 +12,7 @@
 
 ## Pre-requisites
 
-`@sentry/replay` requires Node 12+, and browsers newer than IE11.
+`@sentry/replay` requires Node 14+, and browsers newer than IE11.
 
 ## Installation
 

package/cjs/index.js

@@ -5714,10 +5714,6 @@ function isFeedbackEvent(event) {
  * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.
  */
 function handleAfterSendEvent(replay) {
-  // Custom transports may still be returning `Promise<void>`, which means we cannot expect the status code to be available there
-  // TODO (v8): remove this check as it will no longer be necessary
-  const enforceStatusCode = isBaseTransportSend();
-
   return (event, sendResponse) => {
     if (!replay.isEnabled() || (!isErrorEvent(event) && !isTransactionEvent(event))) {
       return;
@@ -5728,7 +5724,7 @@ function handleAfterSendEvent(replay) {
     // We only want to do stuff on successful error sending, otherwise you get error replays without errors attached
     // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)
     // If we do use the base transport, we skip if we encountered an non-OK status code
-    if (enforceStatusCode && (!statusCode || statusCode < 200 || statusCode >= 300)) {
+    if (!statusCode || statusCode < 200 || statusCode >= 300) {
       return;
     }
 
@@ -5784,22 +5780,6 @@ function handleErrorEvent(replay, event) {
   });
 }
 
-function isBaseTransportSend() {
-  const client = core.getClient();
-  if (!client) {
-    return false;
-  }
-
-  const transport = client.getTransport();
-  if (!transport) {
-    return false;
-  }
-
-  return (
-    (transport.send ).__sentry__baseTransport__ || false
-  );
-}
-
 /**
  * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.
  */
@@ -5835,6 +5815,112 @@ function handleHydrationError(replay, event) {
   }
 }
 
+/**
+ * Handle breadcrumbs that Sentry captures, and make sure to capture relevant breadcrumbs to Replay as well.
+ */
+function handleBreadcrumbs(replay) {
+  const client = core.getClient();
+
+  if (!client) {
+    return;
+  }
+
+  client.on('beforeAddBreadcrumb', breadcrumb => beforeAddBreadcrumb(replay, breadcrumb));
+}
+
+function beforeAddBreadcrumb(replay, breadcrumb) {
+  if (!replay.isEnabled() || !isBreadcrumbWithCategory(breadcrumb)) {
+    return;
+  }
+
+  const result = normalizeBreadcrumb(breadcrumb);
+  if (result) {
+    addBreadcrumbEvent(replay, result);
+  }
+}
+
+/** Exported only for tests. */
+function normalizeBreadcrumb(breadcrumb) {
+  if (
+    !isBreadcrumbWithCategory(breadcrumb) ||
+    [
+      // fetch & xhr are handled separately,in handleNetworkBreadcrumbs
+      'fetch',
+      'xhr',
+      // These two are breadcrumbs for emitted sentry events, we don't care about them
+      'sentry.event',
+      'sentry.transaction',
+    ].includes(breadcrumb.category) ||
+    // We capture UI breadcrumbs separately
+    breadcrumb.category.startsWith('ui.')
+  ) {
+    return null;
+  }
+
+  if (breadcrumb.category === 'console') {
+    return normalizeConsoleBreadcrumb(breadcrumb);
+  }
+
+  return createBreadcrumb(breadcrumb);
+}
+
+/** exported for tests only */
+function normalizeConsoleBreadcrumb(
+  breadcrumb,
+) {
+  const args = breadcrumb.data && breadcrumb.data.arguments;
+
+  if (!Array.isArray(args) || args.length === 0) {
+    return createBreadcrumb(breadcrumb);
+  }
+
+  let isTruncated = false;
+
+  // Avoid giant args captures
+  const normalizedArgs = args.map(arg => {
+    if (!arg) {
+      return arg;
+    }
+    if (typeof arg === 'string') {
+      if (arg.length > CONSOLE_ARG_MAX_SIZE) {
+        isTruncated = true;
+        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;
+      }
+
+      return arg;
+    }
+    if (typeof arg === 'object') {
+      try {
+        const normalizedArg = utils.normalize(arg, 7);
+        const stringified = JSON.stringify(normalizedArg);
+        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {
+          isTruncated = true;
+          // We use the pretty printed JSON string here as a base
+          return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;
+        }
+        return normalizedArg;
+      } catch (e) {
+        // fall back to default
+      }
+    }
+
+    return arg;
+  });
+
+  return createBreadcrumb({
+    ...breadcrumb,
+    data: {
+      ...breadcrumb.data,
+      arguments: normalizedArgs,
+      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),
+    },
+  });
+}
+
+function isBreadcrumbWithCategory(breadcrumb) {
+  return !!breadcrumb.category;
+}
+
 /**
  * Returns true if we think the given event is an error originating inside of rrweb.
  */
@@ -5912,12 +5998,7 @@ function shouldSampleForBufferEvent(replay, event) {
 /**
  * Returns a listener to be added to `addEventProcessor(listener)`.
  */
-function handleGlobalEventListener(
-  replay,
-  includeAfterSendEventHandling = false,
-) {
-  const afterSendHandler = includeAfterSendEventHandling ? handleAfterSendEvent(replay) : undefined;
-
+function handleGlobalEventListener(replay) {
   return Object.assign(
     (event, hint) => {
       // Do nothing if replay has been disabled
@@ -5973,13 +6054,6 @@ function handleGlobalEventListener(
         event.tags = { ...event.tags, replayId: replay.getSessionId() };
       }
 
-      // In cases where a custom client is used that does not support the new hooks (yet),
-      // we manually call this hook method here
-      if (afterSendHandler) {
-        // Pretend the error had a 200 response so we always capture it
-        afterSendHandler(event, { statusCode: 200 });
-      }
-
       return event;
     },
     { id: 'Replay' },
@@ -6096,97 +6170,14 @@ function addNetworkBreadcrumb(
   });
 }
 
-/** only exported for tests */
-function handleFetch(handlerData) {
-  const { startTimestamp, endTimestamp, fetchData, response } = handlerData;
-
-  if (!endTimestamp) {
-    return null;
-  }
-
-  // This is only used as a fallback, so we know the body sizes are never set here
-  const { method, url } = fetchData;
-
-  return {
-    type: 'resource.fetch',
-    start: startTimestamp / 1000,
-    end: endTimestamp / 1000,
-    name: url,
-    data: {
-      method,
-      statusCode: response ? (response ).status : undefined,
-    },
-  };
-}
-
-/**
- * Returns a listener to be added to `addFetchInstrumentationHandler(listener)`.
- */
-function handleFetchSpanListener(replay) {
-  return (handlerData) => {
-    if (!replay.isEnabled()) {
-      return;
-    }
-
-    const result = handleFetch(handlerData);
-
-    addNetworkBreadcrumb(replay, result);
-  };
-}
-
-/** only exported for tests */
-function handleXhr(handlerData) {
-  const { startTimestamp, endTimestamp, xhr } = handlerData;
-
-  const sentryXhrData = xhr[utils.SENTRY_XHR_DATA_KEY];
-
-  if (!startTimestamp || !endTimestamp || !sentryXhrData) {
-    return null;
-  }
-
-  // This is only used as a fallback, so we know the body sizes are never set here
-  const { method, url, status_code: statusCode } = sentryXhrData;
-
-  if (url === undefined) {
-    return null;
-  }
-
-  return {
-    type: 'resource.xhr',
-    name: url,
-    start: startTimestamp / 1000,
-    end: endTimestamp / 1000,
-    data: {
-      method,
-      statusCode,
-    },
-  };
-}
-
-/**
- * Returns a listener to be added to `addXhrInstrumentationHandler(listener)`.
- */
-function handleXhrSpanListener(replay) {
-  return (handlerData) => {
-    if (!replay.isEnabled()) {
-      return;
-    }
-
-    const result = handleXhr(handlerData);
-
-    addNetworkBreadcrumb(replay, result);
-  };
-}
-
 /** Get the size of a body. */
-function getBodySize(
-  body,
-  textEncoder,
-) {
+function getBodySize(body) {
   if (!body) {
     return undefined;
   }
 
+  const textEncoder = new TextEncoder();
+
   try {
     if (typeof body === 'string') {
       return textEncoder.encode(body).length;
@@ -6486,12 +6477,11 @@ async function captureFetchBreadcrumbToReplay(
 function enrichFetchBreadcrumb(
   breadcrumb,
   hint,
-  options,
 ) {
   const { input, response } = hint;
 
   const body = input ? _getFetchRequestArgBody(input) : undefined;
-  const reqSize = getBodySize(body, options.textEncoder);
+  const reqSize = getBodySize(body);
 
   const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;
 
@@ -6506,9 +6496,7 @@ function enrichFetchBreadcrumb(
 async function _prepareFetchData(
   breadcrumb,
   hint,
-  options
-
-,
+  options,
 ) {
   const now = Date.now();
   const { startTimestamp = now, endTimestamp = now } = hint;
@@ -6568,11 +6556,8 @@ async function _getResponseInfo(
   captureDetails,
   {
     networkCaptureBodies,
-    textEncoder,
     networkResponseHeaders,
-  }
-
-,
+  },
   response,
   responseBodySize,
 ) {
@@ -6589,7 +6574,7 @@ async function _getResponseInfo(
   const [bodyText, warning] = await _parseFetchResponseBody(response);
   const result = getResponseData(bodyText, {
     networkCaptureBodies,
-    textEncoder,
+
     responseBodySize,
     captureDetails,
     headers,
@@ -6606,7 +6591,6 @@ function getResponseData(
   bodyText,
   {
     networkCaptureBodies,
-    textEncoder,
     responseBodySize,
     captureDetails,
     headers,
@@ -6616,9 +6600,7 @@ function getResponseData(
 ) {
   try {
     const size =
-      bodyText && bodyText.length && responseBodySize === undefined
-        ? getBodySize(bodyText, textEncoder)
-        : responseBodySize;
+      bodyText && bodyText.length && responseBodySize === undefined ? getBodySize(bodyText) : responseBodySize;
 
     if (!captureDetails) {
       return buildSkippedNetworkRequestOrResponse(size);
@@ -6773,7 +6755,6 @@ async function captureXhrBreadcrumbToReplay(
 function enrichXhrBreadcrumb(
   breadcrumb,
   hint,
-  options,
 ) {
   const { xhr, input } = hint;
 
@@ -6781,10 +6762,10 @@ function enrichXhrBreadcrumb(
     return;
   }
 
-  const reqSize = getBodySize(input, options.textEncoder);
+  const reqSize = getBodySize(input);
   const resSize = xhr.getResponseHeader('content-length')
     ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))
-    : _getBodySize(xhr.response, xhr.responseType, options.textEncoder);
+    : _getBodySize(xhr.response, xhr.responseType);
 
   if (reqSize !== undefined) {
     breadcrumb.data.request_body_size = reqSize;
@@ -6931,11 +6912,10 @@ function _parseXhrResponse(
 function _getBodySize(
   body,
   responseType,
-  textEncoder,
 ) {
   try {
     const bodyStr = responseType === 'json' && body && typeof body === 'object' ? JSON.stringify(body) : body;
-    return getBodySize(bodyStr, textEncoder);
+    return getBodySize(bodyStr);
   } catch (e3) {
     return undefined;
   }
@@ -6951,8 +6931,6 @@ function handleNetworkBreadcrumbs(replay) {
   const client = core.getClient();
 
   try {
-    const textEncoder = new TextEncoder();
-
     const {
       networkDetailAllowUrls,
       networkDetailDenyUrls,
@@ -6963,7 +6941,6 @@ function handleNetworkBreadcrumbs(replay) {
 
     const options = {
       replay,
-      textEncoder,
       networkDetailAllowUrls,
       networkDetailDenyUrls,
       networkCaptureBodies,
@@ -6971,12 +6948,8 @@ function handleNetworkBreadcrumbs(replay) {
       networkResponseHeaders,
     };
 
-    if (client && client.on) {
+    if (client) {
       client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));
-    } else {
-      // Fallback behavior
-      utils.addFetchInstrumentationHandler(handleFetchSpanListener(replay));
-      utils.addXhrInstrumentationHandler(handleXhrSpanListener(replay));
     }
   } catch (e2) {
     // Do nothing
@@ -6998,7 +6971,7 @@ function beforeAddNetworkBreadcrumb(
       // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick
       // Because the hook runs synchronously, and the breadcrumb is afterwards passed on
       // So any async mutations to it will not be reflected in the final breadcrumb
-      enrichXhrBreadcrumb(breadcrumb, hint, options);
+      enrichXhrBreadcrumb(breadcrumb, hint);
 
       // This call should not reject
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -7009,7 +6982,7 @@ function beforeAddNetworkBreadcrumb(
       // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick
       // Because the hook runs synchronously, and the breadcrumb is afterwards passed on
       // So any async mutations to it will not be reflected in the final breadcrumb
-      enrichFetchBreadcrumb(breadcrumb, hint, options);
+      enrichFetchBreadcrumb(breadcrumb, hint);
 
       // This call should not reject
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -7036,138 +7009,25 @@ function _isFetchHint(hint) {
   return hint && hint.response;
 }
 
-let _LAST_BREADCRUMB = null;
-
-function isBreadcrumbWithCategory(breadcrumb) {
-  return !!breadcrumb.category;
-}
-
-const handleScopeListener =
-  (replay) =>
-  (scope) => {
-    if (!replay.isEnabled()) {
-      return;
-    }
-
-    const result = handleScope(scope);
-
-    if (!result) {
-      return;
-    }
-
-    addBreadcrumbEvent(replay, result);
-  };
-
-/**
- * An event handler to handle scope changes.
- */
-function handleScope(scope) {
-  // TODO (v8): Remove this guard. This was put in place because we introduced
-  // Scope.getLastBreadcrumb mid-v7 which caused incompatibilities with older SDKs.
-  // For now, we'll just return null if the method doesn't exist but we should eventually
-  // get rid of this guard.
-  const newBreadcrumb = scope.getLastBreadcrumb && scope.getLastBreadcrumb();
-
-  // Listener can be called when breadcrumbs have not changed, so we store the
-  // reference to the last crumb and only return a crumb if it has changed
-  if (_LAST_BREADCRUMB === newBreadcrumb || !newBreadcrumb) {
-    return null;
-  }
-
-  _LAST_BREADCRUMB = newBreadcrumb;
-
-  if (
-    !isBreadcrumbWithCategory(newBreadcrumb) ||
-    ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||
-    newBreadcrumb.category.startsWith('ui.')
-  ) {
-    return null;
-  }
-
-  if (newBreadcrumb.category === 'console') {
-    return normalizeConsoleBreadcrumb(newBreadcrumb);
-  }
-
-  return createBreadcrumb(newBreadcrumb);
-}
-
-/** exported for tests only */
-function normalizeConsoleBreadcrumb(
-  breadcrumb,
-) {
-  const args = breadcrumb.data && breadcrumb.data.arguments;
-
-  if (!Array.isArray(args) || args.length === 0) {
-    return createBreadcrumb(breadcrumb);
-  }
-
-  let isTruncated = false;
-
-  // Avoid giant args captures
-  const normalizedArgs = args.map(arg => {
-    if (!arg) {
-      return arg;
-    }
-    if (typeof arg === 'string') {
-      if (arg.length > CONSOLE_ARG_MAX_SIZE) {
-        isTruncated = true;
-        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;
-      }
-
-      return arg;
-    }
-    if (typeof arg === 'object') {
-      try {
-        const normalizedArg = utils.normalize(arg, 7);
-        const stringified = JSON.stringify(normalizedArg);
-        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {
-          isTruncated = true;
-          // We use the pretty printed JSON string here as a base
-          return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;
-        }
-        return normalizedArg;
-      } catch (e) {
-        // fall back to default
-      }
-    }
-
-    return arg;
-  });
-
-  return createBreadcrumb({
-    ...breadcrumb,
-    data: {
-      ...breadcrumb.data,
-      arguments: normalizedArgs,
-      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),
-    },
-  });
-}
-
 /**
  * Add global listeners that cannot be removed.
  */
 function addGlobalListeners(replay) {
   // Listeners from core SDK //
-  const scope = core.getCurrentScope();
   const client = core.getClient();
 
-  scope.addScopeListener(handleScopeListener(replay));
   utils.addClickKeypressInstrumentationHandler(handleDomListener(replay));
   utils.addHistoryInstrumentationHandler(handleHistorySpanListener(replay));
+  handleBreadcrumbs(replay);
   handleNetworkBreadcrumbs(replay);
 
   // Tag all (non replay) events that get sent to Sentry with the current
   // replay ID so that we can reference them later in the UI
-  const eventProcessor = handleGlobalEventListener(replay, !hasHooks(client));
-  if (client && client.addEventProcessor) {
-    client.addEventProcessor(eventProcessor);
-  } else {
-    core.addEventProcessor(eventProcessor);
-  }
+  const eventProcessor = handleGlobalEventListener(replay);
+  core.addEventProcessor(eventProcessor);
 
   // If a custom client has no hooks yet, we continue to use the "old" implementation
-  if (hasHooks(client)) {
+  if (client) {
     client.on('beforeSendEvent', handleBeforeSendEvent(replay));
     client.on('afterSendEvent', handleAfterSendEvent(replay));
     client.on('createDsc', (dsc) => {
@@ -7205,11 +7065,6 @@ function addGlobalListeners(replay) {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function hasHooks(client) {
-  return !!(client && client.on);
-}
-
 /**
  * Create a "span" for the total amount of memory being used by JS objects
  * (including v8 internal objects).
@@ -7531,9 +7386,7 @@ async function prepareReplayEvent({
 
   const eventHint = { event_id, integrations };
 
-  if (client.emit) {
-    client.emit('preprocessEvent', event, eventHint);
-  }
+  client.emit('preprocessEvent', event, eventHint);
 
   const preparedEvent = (await core.prepareEvent(
     client.getOptions(),
@@ -7555,7 +7408,7 @@ async function prepareReplayEvent({
   preparedEvent.platform = preparedEvent.platform || 'javascript';
 
   // extract the SDK name because `client._prepareEvent` doesn't add it to the event
-  const metadata = client.getSdkMetadata && client.getSdkMetadata();
+  const metadata = client.getSdkMetadata();
   const { name, version } = (metadata && metadata.sdk) || {};
 
   preparedEvent.sdk = {
@@ -7593,7 +7446,7 @@ async function sendReplayRequest({
   const dsn = client && client.getDsn();
 
   if (!client || !transport || !dsn || !session.sampled) {
-    return;
+    return utils.resolvedSyncPromise({});
   }
 
   const baseEvent = {
@@ -7614,7 +7467,7 @@ async function sendReplayRequest({
     // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
     client.recordDroppedEvent('event_processor', 'replay', baseEvent);
     logInfo('An event processor returned `null`, will not send event.');
-    return;
+    return utils.resolvedSyncPromise({});
   }
 
   /*
@@ -7676,11 +7529,6 @@ async function sendReplayRequest({
     throw error;
   }
 
-  // TODO (v8): we can remove this guard once transport.send's type signature doesn't include void anymore
-  if (!response) {
-    return response;
-  }
-
   // If the status code is invalid, we want to immediately stop & not retry
   if (typeof response.statusCode === 'number' && (response.statusCode < 200 || response.statusCode >= 300)) {
     throw new TransportStatusCodeError(response.statusCode);
@@ -9539,12 +9387,9 @@ function _getMergedNetworkHeaders(headers) {
 /**
  * This is a small utility to get a type-safe instance of the Replay integration.
  */
-// eslint-disable-next-line deprecation/deprecation
 function getReplay() {
   const client = core.getClient();
-  return (
-    client && client.getIntegrationByName && client.getIntegrationByName('Replay')
-  );
+  return client && client.getIntegrationByName('Replay');
 }
 
 exports.Replay = Replay;