meta(changelog): Update Changelog for 7.50.0

Author: mydea

CHANGELOG.md

@@ -4,6 +4,127 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 7.50.0
+
+### Important Changes
+
+- **doc(sveltekit): Promote the SDK to beta state (#7874)**
+
+The SvelteKit SDK (@sentry/sveltekit) is now officially in Beta.
+This means that we do not expect any breaking changes anymore.
+
+- **feat(replay): Allow to configure URLs to capture network bodies/headers (#7953)**
+
+You can now capture request/response bodies & headers of network requests in Replay.
+You have to define an allowlist of URLs you want to capture additional information for:
+
+```js
+new Replay({
+  networkDetailAllowUrls: ['https://sentry.io/api'],
+});
+```
+
+By default, we will capture request/response bodies, as well as the request/response headers `content-type`, `content-length` and `accept`.
+You can configure this with some additional configuration:
+
+```js
+new Replay({
+  networkDetailAllowUrls: ['https://sentry.io/api'],
+  // opt-out of capturing bodies
+  networkCaptureBodies: false,
+  // These headers are captured _in addition to_ the default headers
+  networkRequestHeaders: ['X-Custom-Header'],
+  networkResponseHeaders: ['X-Custom-Header', 'X-Custom-Header-2']
+});
+```
+
+Note that bodies will be truncated to a max length of ~150k characters.
+
+**- feat(replay): Extend session idle time until expire to 15min (#7955)**
+
+Replay Sessions will now only be refreshed when a user is idle for 15min or more.
+Previously, we would consider 5min of idle time as the threshold for this, which sometimes resulted in a lot of consequitive sessions.
+
+**- feat(replay): Change the behavior of error-based sampling (#7768)**
+
+We have changed the behavior of error-based sampling, as well as adding & adjusting APIs a bit to be more aligned with expectations.
+
+First, the `replaysOnErrorSampleRate` will now be applied per-error at error-time, not in advance at session creation time -
+so the sampling rate was not accurate if you had sessions with many errors.
+Now whenever an error happens, we'll check the error sample rate, and potentially flush the session.
+
+Related to this, we also reworked the public `start()` method and added a new `startBuffering()` method.
+
+When calling `start()`, it will now _always_ start a session-based Replay, ignoring sample rates.
+Note that it will throw an error if a session is already running.
+
+You can use the new `startBuffering()` method to start a new Replay in buffering-mode.
+This will either wait for an error (when `replaysOnErrorSampleRate > 0`), or until you manually call `replay.flush()`.
+
+Note that with this change, as soon as either `replaysSessionSampleRate` or `replaysOnErrorSampleRate` are `> 0`,
+we will _always_ start recording in the background, either in session mode or in buffering mode.
+When both sample rates are set to `0`, you can manually start the session with either `replay.start()` or `replay.startBuffering()`.
+
+
+**- Improved Replay `flush()` & `stop()` APIs**
+  - feat(replay): Change `flush()` API to record current event buffer (#7743)
+  - feat(replay): Change `stop()` to flush and remove current session (#7741)
+
+We have revamped some existing public API of Replay in order to be better aligned with expectations.
+
+`replay.flush()` now works differently when in error sampling mode:
+It will send the buffered replay data, then convert the session to a "regular" session and continue recording.
+With this, you can manually start capturing at any point.
+
+`replay.stop()` will now flush the event buffer before stopping, and remove the session from session storage.
+This also means that `stop()` now returns a promise.
+
+- **feat(core): Add multiplexed transport (#7926)**
+
+We added a new transport to support multiplexing.
+With this, you can configure Sentry to send events to different DSNs, depending of a logic of your choosing:
+
+```js
+import { makeMultiplexedTransport } from '@sentry/core';
+import { init, captureException, makeFetchTransport } from '@sentry/browser';
+
+function dsnFromFeature({ getEvent }) {
+  const event = getEvent();
+  switch(event?.tags?.feature) {
+    case 'cart':
+      return ['__CART_DSN__'];
+    case 'gallery':
+      return ['__GALLERY_DSN__'];
+  }
+  return []
+}
+
+init({
+  dsn: '__FALLBACK_DSN__',
+  transport: makeMultiplexedTransport(makeFetchTransport, dsnFromFeature)
+});
+```
+
+- **fix(core): fix(utils): default normalize() to a max. of 100 levels deep instead of Inifnity (#7957)**
+
+We used to default to normalize objects to a depth of `Infinity`.
+For most cases, this shouldn't matter, because objects aren't actually infinitely deep, and we handle circular dependencies reasonably well.
+However, we found out that there _are_ cases where we can still end up running into an infinitely deep recursion -
+for example, when using dynamicly generated proxies, which we cannot detect as "same instance", thus our circular dependency handling breaks down.
+
+In order to account for these cases, we now default `normalize()` to a max. depth of 100.
+This should avoid this crashing when, for whatever reason, circular dependencies are not properly detected.
+
+### Additional Features and Fixes
+
+- feat(nextjs): Add `disableLogger` option that automatically tree shakes logger statements (#7908)
+- feat(tracing): Add `db.system` span data to DB spans (#7952)
+- fix(core): Avoid crash when Function.prototype is frozen (#7899)
+- fix(nextjs): Fix inject logic for Next.js 13.3.1 canary (#7921)
+- fix(replay): Ensure console breadcrumb args are truncated (#7917)
+- fix(replay): Ensure we do not set replayId on dsc if replay is disabled (#7939)
+- fix(replay): Ensure we still truncate large bodies if they are failed JSON (#7923)
+
 ## 7.49.0
 
 ### Important Changes