@sentry/profiling-node 7.107.0 → 8.0.0-alpha.3

package/lib/index.js

@@ -7,33 +7,26 @@ const nodeAbi = require('node-abi');
 const process$1 = require('process');
 const worker_threads = require('worker_threads');
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 // eslint-disable-next-line @typescript-eslint/unbound-method
 const objectToString = Object.prototype.toString;
+
+/**
+ * Checks whether given value's type is one of a few Error or Error-like
+ * {@link isError}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isError(wat) {
+  switch (objectToString.call(wat)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return isInstanceOf(wat, Error);
+  }
+}
 /**
  * Checks whether given value is an instance of the given built-in class.
  *
@@ -45,6 +38,17 @@ function isBuiltin(wat, className) {
   return objectToString.call(wat) === `[object ${className}]`;
 }
 
+/**
+ * Checks whether given value's type is a string
+ * {@link isString}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isString(wat) {
+  return isBuiltin(wat, 'String');
+}
+
 /**
  * Checks whether given value's type is an object literal, or a class instance.
  * {@link isPlainObject}.
@@ -56,6 +60,28 @@ function isPlainObject(wat) {
   return isBuiltin(wat, 'Object');
 }
 
+/**
+ * Checks whether given value's type is an Event instance
+ * {@link isEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isEvent(wat) {
+  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);
+}
+
+/**
+ * Checks whether given value's type is an Element instance
+ * {@link isElement}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isElement(wat) {
+  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);
+}
+
 /**
  * Checks whether given value has a then function.
  * @param wat A value to be checked.
@@ -65,6 +91,55 @@ function isThenable(wat) {
   return Boolean(wat && wat.then && typeof wat.then === 'function');
 }
 
+/**
+ * Checks whether given value's type is a SyntheticEvent
+ * {@link isSyntheticEvent}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isSyntheticEvent(wat) {
+  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
+}
+
+/**
+ * Checks whether given value is NaN
+ * {@link isNaN}.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isNaN$1(wat) {
+  return typeof wat === 'number' && wat !== wat;
+}
+
+/**
+ * Checks whether given value's type is an instance of provided constructor.
+ * {@link isInstanceOf}.
+ *
+ * @param wat A value to be checked.
+ * @param base A constructor to be used in a check.
+ * @returns A boolean representing the result.
+ */
+function isInstanceOf(wat, base) {
+  try {
+    return wat instanceof base;
+  } catch (_e) {
+    return false;
+  }
+}
+
+/**
+ * Checks whether given value's type is a Vue ViewModel.
+ *
+ * @param wat A value to be checked.
+ * @returns A boolean representing the result.
+ */
+function isVueViewModel(wat) {
+  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.
+  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));
+}
+
 /** Internal global with common properties and Sentry extensions  */
 
 // The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification
@@ -108,6 +183,13 @@ const GLOBAL_OBJ =
   })() ||
   {};
 
+/**
+ * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8
+ */
+function getGlobalObject() {
+  return GLOBAL_OBJ ;
+}
+
 /**
  * Returns a global singleton contained in the global `__SENTRY__` object.
  *
@@ -126,6 +208,128 @@ function getGlobalSingleton(name, creator, obj) {
   return singleton;
 }
 
+// eslint-disable-next-line deprecation/deprecation
+const WINDOW$5 = getGlobalObject();
+
+const DEFAULT_MAX_STRING_LENGTH = 80;
+
+/**
+ * Given a child DOM element, returns a query-selector statement describing that
+ * and its ancestors
+ * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function htmlTreeAsString(
+  elem,
+  options = {},
+) {
+  if (!elem) {
+    return '<unknown>';
+  }
+
+  // try/catch both:
+  // - accessing event.target (see getsentry/raven-js#838, #768)
+  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
+  // - can throw an exception in some circumstances.
+  try {
+    let currentElem = elem ;
+    const MAX_TRAVERSE_HEIGHT = 5;
+    const out = [];
+    let height = 0;
+    let len = 0;
+    const separator = ' > ';
+    const sepLength = separator.length;
+    let nextStr;
+    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;
+    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;
+
+    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+      nextStr = _htmlElementAsString(currentElem, keyAttrs);
+      // bail out if
+      // - nextStr is the 'html' element
+      // - the length of the string that would be created exceeds maxStringLength
+      //   (ignore this limit if we are on the first iteration)
+      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {
+        break;
+      }
+
+      out.push(nextStr);
+
+      len += nextStr.length;
+      currentElem = currentElem.parentNode;
+    }
+
+    return out.reverse().join(separator);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/**
+ * Returns a simple, query-selector representation of a DOM element
+ * e.g. [HTMLElement] => input#foo.btn[name=baz]
+ * @returns generated DOM path
+ */
+function _htmlElementAsString(el, keyAttrs) {
+  const elem = el
+
+;
+
+  const out = [];
+  let className;
+  let classes;
+  let key;
+  let attr;
+  let i;
+
+  if (!elem || !elem.tagName) {
+    return '';
+  }
+
+  // @ts-expect-error WINDOW has HTMLElement
+  if (WINDOW$5.HTMLElement) {
+    // If using the component name annotation plugin, this value may be available on the DOM node
+    if (elem instanceof HTMLElement && elem.dataset && elem.dataset['sentryComponent']) {
+      return elem.dataset['sentryComponent'];
+    }
+  }
+
+  out.push(elem.tagName.toLowerCase());
+
+  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+  const keyAttrPairs =
+    keyAttrs && keyAttrs.length
+      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+      : null;
+
+  if (keyAttrPairs && keyAttrPairs.length) {
+    keyAttrPairs.forEach(keyAttrPair => {
+      out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+    });
+  } else {
+    if (elem.id) {
+      out.push(`#${elem.id}`);
+    }
+
+    className = elem.className;
+    if (className && isString(className)) {
+      classes = className.split(/\s+/);
+      for (i = 0; i < classes.length; i++) {
+        out.push(`.${classes[i]}`);
+      }
+    }
+  }
+  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];
+  for (i = 0; i < allowedAttrs.length; i++) {
+    key = allowedAttrs[i];
+    attr = elem.getAttribute(key);
+    if (attr) {
+      out.push(`[${key}="${attr}"]`);
+    }
+  }
+  return out.join('');
+}
+
 /**
  * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
  *
@@ -220,21 +424,97 @@ function makeLogger() {
 
 const logger = makeLogger();
 
+const defaultFunctionName = '<anonymous>';
+
+/**
+ * Safely extract function name from itself
+ */
+function getFunctionName(fn) {
+  try {
+    if (!fn || typeof fn !== 'function') {
+      return defaultFunctionName;
+    }
+    return fn.name || defaultFunctionName;
+  } catch (e) {
+    // Just accessing custom props in some Selenium environments
+    // can cause a "Permission denied" exception (see raven-js#495).
+    return defaultFunctionName;
+  }
+}
+
 /**
- * Renders the string representation of this Dsn.
+ * This extracts the original function if available.  See
+ * `markFunctionWrapped` for more information.
  *
- * By default, this will render the public representation without the password
- * component. To get the deprecated private representation, set `withPassword`
- * to true.
+ * @param func the function to unwrap
+ * @returns the unwrapped version of the function if available.
+ */
+function getOriginalFunction(func) {
+  return func.__sentry_original__;
+}
+
+/**
+ * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+ * non-enumerable properties attached.
  *
- * @param withPassword When set to true, the password will be included.
+ * @param value Initial source that we have to transform in order for it to be usable by the serializer
+ * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor
+ *  an Error.
  */
-function dsnToString(dsn, withPassword = false) {
-  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
-  return (
-    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
-    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`
-  );
+function convertToPlainObject(
+  value,
+)
+
+ {
+  if (isError(value)) {
+    return {
+      message: value.message,
+      name: value.name,
+      stack: value.stack,
+      ...getOwnProperties(value),
+    };
+  } else if (isEvent(value)) {
+    const newObj
+
+ = {
+      type: value.type,
+      target: serializeEventTarget(value.target),
+      currentTarget: serializeEventTarget(value.currentTarget),
+      ...getOwnProperties(value),
+    };
+
+    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
+      newObj.detail = value.detail;
+    }
+
+    return newObj;
+  } else {
+    return value;
+  }
+}
+
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+  try {
+    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+  } catch (_oO) {
+    return '<unknown>';
+  }
+}
+
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+  if (typeof obj === 'object' && obj !== null) {
+    const extractedProps = {};
+    for (const property in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, property)) {
+        extractedProps[property] = (obj )[property];
+      }
+    }
+    return extractedProps;
+  } else {
+    return {};
+  }
 }
 
 /**
@@ -346,200 +626,693 @@ function uuid4() {
   );
 }
 
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 /**
- * Checks whether the given input is already an array, and if it isn't, wraps it in one.
- *
- * @param maybeArray Input to turn into an array, if necessary
- * @returns The input, if already an array, or an array with the input as the only element, if not
+ * Helper to decycle json objects
  */
-function arrayify(maybeArray) {
-  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
-}
+function memoBuilder() {
+  const hasWeakSet = typeof WeakSet === 'function';
+  const inner = hasWeakSet ? new WeakSet() : [];
+  function memoize(obj) {
+    if (hasWeakSet) {
+      if (inner.has(obj)) {
+        return true;
+      }
+      inner.add(obj);
+      return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < inner.length; i++) {
+      const value = inner[i];
+      if (value === obj) {
+        return true;
+      }
+    }
+    inner.push(obj);
+    return false;
+  }
 
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
+  function unmemoize(obj) {
+    if (hasWeakSet) {
+      inner.delete(obj);
+    } else {
+      for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === obj) {
+          inner.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
+  return [memoize, unmemoize];
+}
 
-/** SyncPromise internal states */
-var States; (function (States) {
-  /** Pending */
-  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
-  /** Resolved / OK */
-  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
-  /** Rejected / Error */
-  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
-})(States || (States = {}));
+/**
+ * Recursively normalizes the given object.
+ *
+ * - Creates a copy to prevent original input mutation
+ * - Skips non-enumerable properties
+ * - When stringifying, calls `toJSON` if implemented
+ * - Removes circular references
+ * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+ * - Translates known global objects/classes to a string representations
+ * - Takes care of `Error` object serialization
+ * - Optionally limits depth of final output
+ * - Optionally limits number of properties/elements included in any single object/array
+ *
+ * @param input The object to be normalized.
+ * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+ * @param maxProperties The max number of elements or properties to be included in any single array or
+ * object in the normallized output.
+ * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalize(input, depth = 100, maxProperties = +Infinity) {
+  try {
+    // since we're at the outermost level, we don't provide a key
+    return visit('', input, depth, maxProperties);
+  } catch (err) {
+    return { ERROR: `**non-serializable** (${err})` };
+  }
+}
 
 /**
- * Thenable class that behaves like a Promise and follows it's interface
- * but is not async internally
- */
-class SyncPromise {
+ * Visits a node to perform normalization on it
+ *
+ * @param key The key corresponding to the given node
+ * @param value The node to be visited
+ * @param depth Optional number indicating the maximum recursion depth
+ * @param maxProperties Optional maximum number of properties/elements included in any single object/array
+ * @param memo Optional Memo class handling decycling
+ */
+function visit(
+  key,
+  value,
+  depth = +Infinity,
+  maxProperties = +Infinity,
+  memo = memoBuilder(),
+) {
+  const [memoize, unmemoize] = memo;
 
-   constructor(
-    executor,
-  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);
-    this._state = States.PENDING;
-    this._handlers = [];
+  // Get the simple cases out of the way first
+  if (
+    value == null || // this matches null and undefined -> eqeq not eqeqeq
+    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN$1(value))
+  ) {
+    return value ;
+  }
 
-    try {
-      executor(this._resolve, this._reject);
-    } catch (e) {
-      this._reject(e);
-    }
+  const stringified = stringifyValue(key, value);
+
+  // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+  // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+  if (!stringified.startsWith('[object ')) {
+    return stringified;
   }
 
-  /** JSDoc */
-   then(
-    onfulfilled,
-    onrejected,
-  ) {
-    return new SyncPromise((resolve, reject) => {
-      this._handlers.push([
-        false,
-        result => {
-          if (!onfulfilled) {
-            // TODO: ¯\_(ツ)_/¯
-            // TODO: FIXME
-            resolve(result );
-          } else {
-            try {
-              resolve(onfulfilled(result));
-            } catch (e) {
-              reject(e);
-            }
-          }
-        },
-        reason => {
-          if (!onrejected) {
-            reject(reason);
-          } else {
-            try {
-              resolve(onrejected(reason));
-            } catch (e) {
-              reject(e);
-            }
-          }
-        },
-      ]);
-      this._executeHandlers();
-    });
+  // From here on, we can assert that `value` is either an object or an array.
+
+  // Do not normalize objects that we know have already been normalized. As a general rule, the
+  // "__sentry_skip_normalization__" property should only be used sparingly and only should only be set on objects that
+  // have already been normalized.
+  if ((value )['__sentry_skip_normalization__']) {
+    return value ;
   }
 
-  /** JSDoc */
-   catch(
-    onrejected,
-  ) {
-    return this.then(val => val, onrejected);
+  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there
+  // We keep a certain amount of depth.
+  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.
+  const remainingDepth =
+    typeof (value )['__sentry_override_normalization_depth__'] === 'number'
+      ? ((value )['__sentry_override_normalization_depth__'] )
+      : depth;
+
+  // We're also done if we've reached the max depth
+  if (remainingDepth === 0) {
+    // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+    return stringified.replace('object ', '');
   }
 
-  /** JSDoc */
-   finally(onfinally) {
-    return new SyncPromise((resolve, reject) => {
-      let val;
-      let isRejected;
+  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
+  if (memoize(value)) {
+    return '[Circular ~]';
+  }
 
-      return this.then(
-        value => {
-          isRejected = false;
-          val = value;
-          if (onfinally) {
-            onfinally();
-          }
-        },
-        reason => {
-          isRejected = true;
-          val = reason;
-          if (onfinally) {
-            onfinally();
-          }
-        },
-      ).then(() => {
-        if (isRejected) {
-          reject(val);
-          return;
-        }
+  // If the value has a `toJSON` method, we call it to extract more information
+  const valueWithToJSON = value ;
+  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+    try {
+      const jsonValue = valueWithToJSON.toJSON();
+      // We need to normalize the return value of `.toJSON()` in case it has circular references
+      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);
+    } catch (err) {
+      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+    }
+  }
 
-        resolve(val );
-      });
-    });
+  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+  // property/entry, and keep track of the number of items we add to it.
+  const normalized = (Array.isArray(value) ? [] : {}) ;
+  let numAdded = 0;
+
+  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+  // properties are non-enumerable and otherwise would get missed.
+  const visitable = convertToPlainObject(value );
+
+  for (const visitKey in visitable) {
+    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
+    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
+      continue;
+    }
+
+    if (numAdded >= maxProperties) {
+      normalized[visitKey] = '[MaxProperties ~]';
+      break;
+    }
+
+    // Recursively visit all the child nodes
+    const visitValue = visitable[visitKey];
+    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
+
+    numAdded++;
   }
 
-  /** JSDoc */
-    __init() {this._resolve = (value) => {
-    this._setResult(States.RESOLVED, value);
-  };}
+  // Once we've visited all the branches, remove the parent from memo storage
+  unmemoize(value);
 
-  /** JSDoc */
-    __init2() {this._reject = (reason) => {
-    this._setResult(States.REJECTED, reason);
-  };}
+  // Return accumulated values
+  return normalized;
+}
 
-  /** JSDoc */
-    __init3() {this._setResult = (state, value) => {
-    if (this._state !== States.PENDING) {
-      return;
+/* eslint-disable complexity */
+/**
+ * Stringify the given value. Handles various known special values and types.
+ *
+ * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+ * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
+ *
+ * @param value The value to stringify
+ * @returns A stringified representation of the given value
+ */
+function stringifyValue(
+  key,
+  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+  // our internal use, it'll do
+  value,
+) {
+  try {
+    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {
+      return '[Domain]';
     }
 
-    if (isThenable(value)) {
-      void (value ).then(this._resolve, this._reject);
-      return;
+    if (key === 'domainEmitter') {
+      return '[DomainEmitter]';
     }
 
-    this._state = state;
-    this._value = value;
+    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+    // which won't throw if they are not present.
 
-    this._executeHandlers();
-  };}
+    if (typeof global !== 'undefined' && value === global) {
+      return '[Global]';
+    }
 
-  /** JSDoc */
-    __init4() {this._executeHandlers = () => {
-    if (this._state === States.PENDING) {
-      return;
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof window !== 'undefined' && value === window) {
+      return '[Window]';
     }
 
-    const cachedHandlers = this._handlers.slice();
-    this._handlers = [];
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof document !== 'undefined' && value === document) {
+      return '[Document]';
+    }
 
-    cachedHandlers.forEach(handler => {
-      if (handler[0]) {
-        return;
-      }
+    if (isVueViewModel(value)) {
+      return '[VueViewModel]';
+    }
 
-      if (this._state === States.RESOLVED) {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        handler[1](this._value );
-      }
+    // React's SyntheticEvent thingy
+    if (isSyntheticEvent(value)) {
+      return '[SyntheticEvent]';
+    }
 
-      if (this._state === States.REJECTED) {
-        handler[2](this._value);
-      }
+    if (typeof value === 'number' && value !== value) {
+      return '[NaN]';
+    }
 
-      handler[0] = true;
-    });
-  };}
-}
+    if (typeof value === 'function') {
+      return `[Function: ${getFunctionName(value)}]`;
+    }
 
-const ONE_SECOND_IN_MS = 1000;
+    if (typeof value === 'symbol') {
+      return `[${String(value)}]`;
+    }
 
-/**
- * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
- * for accessing a high-resolution monotonic clock.
- */
+    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+    if (typeof value === 'bigint') {
+      return `[BigInt: ${String(value)}]`;
+    }
 
-/**
- * Returns a timestamp in seconds since the UNIX epoch using the Date API.
- *
- * TODO(v8): Return type should be rounded.
- */
-function dateTimestampInSeconds() {
-  return Date.now() / ONE_SECOND_IN_MS;
+    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+    // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+    // we can make sure that only plain objects come out that way.
+    const objName = getConstructorName(value);
+
+    // Handle HTML Elements
+    if (/^HTML(\w*)Element$/.test(objName)) {
+      return `[HTMLElement: ${objName}]`;
+    }
+
+    return `[object ${objName}]`;
+  } catch (err) {
+    return `**non-serializable** (${err})`;
+  }
 }
+/* eslint-enable complexity */
 
-/**
- * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
- * support the API.
- *
- * Wrapping the native API works around differences in behavior from different browsers.
- */
+function getConstructorName(value) {
+  const prototype = Object.getPrototypeOf(value);
+
+  return prototype ? prototype.constructor.name : 'null prototype';
+}
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** SyncPromise internal states */
+var States; (function (States) {
+  /** Pending */
+  const PENDING = 0; States[States["PENDING"] = PENDING] = "PENDING";
+  /** Resolved / OK */
+  const RESOLVED = 1; States[States["RESOLVED"] = RESOLVED] = "RESOLVED";
+  /** Rejected / Error */
+  const REJECTED = 2; States[States["REJECTED"] = REJECTED] = "REJECTED";
+})(States || (States = {}));
+
+/**
+ * This code was originally copied from the 'cookie` module at v0.5.0 and was simplified for our use case.
+ * https://github.com/jshttp/cookie/blob/a0c84147aab6266bdb3996cf4062e93907c0b0fc/index.js
+ * It had the following license:
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2012-2014 Roman Shtylman <shtylman@gmail.com>
+ * Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * Parses a cookie string
+ */
+function parseCookie(str) {
+  const obj = {};
+  let index = 0;
+
+  while (index < str.length) {
+    const eqIdx = str.indexOf('=', index);
+
+    // no more cookie pairs
+    if (eqIdx === -1) {
+      break;
+    }
+
+    let endIdx = str.indexOf(';', index);
+
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      // backtrack on prior semicolon
+      index = str.lastIndexOf(';', eqIdx - 1) + 1;
+      continue;
+    }
+
+    const key = str.slice(index, eqIdx).trim();
+
+    // only assign once
+    if (undefined === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+
+      // quoted values
+      if (val.charCodeAt(0) === 0x22) {
+        val = val.slice(1, -1);
+      }
+
+      try {
+        obj[key] = val.indexOf('%') !== -1 ? decodeURIComponent(val) : val;
+      } catch (e) {
+        obj[key] = val;
+      }
+    }
+
+    index = endIdx + 1;
+  }
+
+  return obj;
+}
+
+/**
+ * Strip the query string and fragment off of a given URL or path (if present)
+ *
+ * @param urlPath Full URL or path, including possible query string and/or fragment
+ * @returns URL or path without query string or fragment
+ */
+function stripUrlQueryAndFragment(urlPath) {
+  // eslint-disable-next-line no-useless-escape
+  return urlPath.split(/[\?#]/, 1)[0];
+}
+
+const DEFAULT_INCLUDES = {
+  ip: false,
+  request: true,
+  transaction: true,
+  user: true,
+};
+const DEFAULT_REQUEST_INCLUDES = ['cookies', 'data', 'headers', 'method', 'query_string', 'url'];
+const DEFAULT_USER_INCLUDES = ['id', 'username', 'email'];
+
+/**
+ * Extracts a complete and parameterized path from the request object and uses it to construct transaction name.
+ * If the parameterized transaction name cannot be extracted, we fall back to the raw URL.
+ *
+ * Additionally, this function determines and returns the transaction name source
+ *
+ * eg. GET /mountpoint/user/:id
+ *
+ * @param req A request object
+ * @param options What to include in the transaction name (method, path, or a custom route name to be
+ *                used instead of the request's route)
+ *
+ * @returns A tuple of the fully constructed transaction name [0] and its source [1] (can be either 'route' or 'url')
+ */
+function extractPathForTransaction(
+  req,
+  options = {},
+) {
+  const method = req.method && req.method.toUpperCase();
+
+  let path = '';
+  let source = 'url';
+
+  // Check to see if there's a parameterized route we can use (as there is in Express)
+  if (options.customRoute || req.route) {
+    path = options.customRoute || `${req.baseUrl || ''}${req.route && req.route.path}`;
+    source = 'route';
+  }
+
+  // Otherwise, just take the original URL
+  else if (req.originalUrl || req.url) {
+    path = stripUrlQueryAndFragment(req.originalUrl || req.url || '');
+  }
+
+  let name = '';
+  if (options.method && method) {
+    name += method;
+  }
+  if (options.method && options.path) {
+    name += ' ';
+  }
+  if (options.path && path) {
+    name += path;
+  }
+
+  return [name, source];
+}
+
+/** JSDoc */
+function extractTransaction(req, type) {
+  switch (type) {
+    case 'path': {
+      return extractPathForTransaction(req, { path: true })[0];
+    }
+    case 'handler': {
+      return (req.route && req.route.stack && req.route.stack[0] && req.route.stack[0].name) || '<anonymous>';
+    }
+    case 'methodPath':
+    default: {
+      // if exist _reconstructedRoute return that path instead of route.path
+      const customRoute = req._reconstructedRoute ? req._reconstructedRoute : undefined;
+      return extractPathForTransaction(req, { path: true, method: true, customRoute })[0];
+    }
+  }
+}
+
+/** JSDoc */
+function extractUserData(
+  user
+
+,
+  keys,
+) {
+  const extractedUser = {};
+  const attributes = Array.isArray(keys) ? keys : DEFAULT_USER_INCLUDES;
+
+  attributes.forEach(key => {
+    if (user && key in user) {
+      extractedUser[key] = user[key];
+    }
+  });
+
+  return extractedUser;
+}
+
+/**
+ * Normalize data from the request object, accounting for framework differences.
+ *
+ * @param req The request object from which to extract data
+ * @param options.include An optional array of keys to include in the normalized data. Defaults to
+ * DEFAULT_REQUEST_INCLUDES if not provided.
+ * @param options.deps Injected, platform-specific dependencies
+ * @returns An object containing normalized request data
+ */
+function extractRequestData(
+  req,
+  options
+
+,
+) {
+  const { include = DEFAULT_REQUEST_INCLUDES } = options || {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const requestData = {};
+
+  // headers:
+  //   node, express, koa, nextjs: req.headers
+  const headers = (req.headers || {})
+
+;
+  // method:
+  //   node, express, koa, nextjs: req.method
+  const method = req.method;
+  // host:
+  //   express: req.hostname in > 4 and req.host in < 4
+  //   koa: req.host
+  //   node, nextjs: req.headers.host
+  // Express 4 mistakenly strips off port number from req.host / req.hostname so we can't rely on them
+  // See: https://github.com/expressjs/express/issues/3047#issuecomment-236653223
+  // Also: https://github.com/getsentry/sentry-javascript/issues/1917
+  const host = headers.host || req.hostname || req.host || '<no host>';
+  // protocol:
+  //   node, nextjs: <n/a>
+  //   express, koa: req.protocol
+  const protocol = req.protocol === 'https' || (req.socket && req.socket.encrypted) ? 'https' : 'http';
+  // url (including path and query string):
+  //   node, express: req.originalUrl
+  //   koa, nextjs: req.url
+  const originalUrl = req.originalUrl || req.url || '';
+  // absolute url
+  const absoluteUrl = originalUrl.startsWith(protocol) ? originalUrl : `${protocol}://${host}${originalUrl}`;
+  include.forEach(key => {
+    switch (key) {
+      case 'headers': {
+        requestData.headers = headers;
+
+        // Remove the Cookie header in case cookie data should not be included in the event
+        if (!include.includes('cookies')) {
+          delete (requestData.headers ).cookie;
+        }
+
+        break;
+      }
+      case 'method': {
+        requestData.method = method;
+        break;
+      }
+      case 'url': {
+        requestData.url = absoluteUrl;
+        break;
+      }
+      case 'cookies': {
+        // cookies:
+        //   node, express, koa: req.headers.cookie
+        //   vercel, sails.js, express (w/ cookie middleware), nextjs: req.cookies
+        requestData.cookies =
+          // TODO (v8 / #5257): We're only sending the empty object for backwards compatibility, so the last bit can
+          // come off in v8
+          req.cookies || (headers.cookie && parseCookie(headers.cookie)) || {};
+        break;
+      }
+      case 'query_string': {
+        // query string:
+        //   node: req.url (raw)
+        //   express, koa, nextjs: req.query
+        requestData.query_string = extractQueryParams(req);
+        break;
+      }
+      case 'data': {
+        if (method === 'GET' || method === 'HEAD') {
+          break;
+        }
+        // body data:
+        //   express, koa, nextjs: req.body
+        //
+        //   when using node by itself, you have to read the incoming stream(see
+        //   https://nodejs.dev/learn/get-http-request-body-data-using-nodejs); if a user is doing that, we can't know
+        //   where they're going to store the final result, so they'll have to capture this data themselves
+        if (req.body !== undefined) {
+          requestData.data = isString(req.body) ? req.body : JSON.stringify(normalize(req.body));
+        }
+        break;
+      }
+      default: {
+        if ({}.hasOwnProperty.call(req, key)) {
+          requestData[key] = (req )[key];
+        }
+      }
+    }
+  });
+
+  return requestData;
+}
+
+/**
+ * Add data from the given request to the given event
+ *
+ * @param event The event to which the request data will be added
+ * @param req Request object
+ * @param options.include Flags to control what data is included
+ * @param options.deps Injected platform-specific dependencies
+ * @returns The mutated `Event` object
+ */
+function addRequestDataToEvent(
+  event,
+  req,
+  options,
+) {
+  const include = {
+    ...DEFAULT_INCLUDES,
+    ...(options && options.include),
+  };
+
+  if (include.request) {
+    const extractedRequestData = Array.isArray(include.request)
+      ? extractRequestData(req, { include: include.request })
+      : extractRequestData(req);
+
+    event.request = {
+      ...event.request,
+      ...extractedRequestData,
+    };
+  }
+
+  if (include.user) {
+    const extractedUser = req.user && isPlainObject(req.user) ? extractUserData(req.user, include.user) : {};
+
+    if (Object.keys(extractedUser).length) {
+      event.user = {
+        ...event.user,
+        ...extractedUser,
+      };
+    }
+  }
+
+  // client ip:
+  //   node, nextjs: req.socket.remoteAddress
+  //   express, koa: req.ip
+  if (include.ip) {
+    const ip = req.ip || (req.socket && req.socket.remoteAddress);
+    if (ip) {
+      event.user = {
+        ...event.user,
+        ip_address: ip,
+      };
+    }
+  }
+
+  if (include.transaction && !event.transaction) {
+    // TODO do we even need this anymore?
+    // TODO make this work for nextjs
+    event.transaction = extractTransaction(req, include.transaction);
+  }
+
+  return event;
+}
+
+function extractQueryParams(req) {
+  // url (including path and query string):
+  //   node, express: req.originalUrl
+  //   koa, nextjs: req.url
+  let originalUrl = req.originalUrl || req.url || '';
+
+  if (!originalUrl) {
+    return;
+  }
+
+  // The `URL` constructor can't handle internal URLs of the form `/some/path/here`, so stick a dummy protocol and
+  // hostname on the beginning. Since the point here is just to grab the query string, it doesn't matter what we use.
+  if (originalUrl.startsWith('/')) {
+    originalUrl = `http://dogs.are.great${originalUrl}`;
+  }
+
+  try {
+    const queryParams = req.query || new URL(originalUrl).search.slice(1);
+    return queryParams.length ? queryParams : undefined;
+  } catch (e2) {
+    return undefined;
+  }
+}
+
+const ONE_SECOND_IN_MS = 1000;
+
+/**
+ * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+ * for accessing a high-resolution monotonic clock.
+ */
+
+/**
+ * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+ *
+ * TODO(v8): Return type should be rounded.
+ */
+function dateTimestampInSeconds() {
+  return Date.now() / ONE_SECOND_IN_MS;
+}
+
+/**
+ * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+ * support the API.
+ *
+ * Wrapping the native API works around differences in behavior from different browsers.
+ */
 function createUnixTimestampInSecondsFunc() {
   const { performance } = GLOBAL_OBJ ;
   if (!performance || !performance.now) {
@@ -623,15 +1396,6 @@ const timestampInSeconds = createUnixTimestampInSecondsFunc();
   return dateNow;
 })();
 
-/**
- * Creates an envelope.
- * Make sure to always explicitly provide the generic to this function
- * so that the envelope types resolve correctly.
- */
-function createEnvelope(headers, items = []) {
-  return [headers, items] ;
-}
-
 /**
  * Convenience function to loop through the items and item types of an envelope.
  * (This function was mostly created because working with envelope types is painful at the moment)
@@ -664,53 +1428,36 @@ function forEachEnvelopeItem(
 const DEBUG_BUILD$1 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
 
 /**
- * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ * @private Private API with no semver guarantees!
  *
- * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ * Strategy used to track async context.
  */
-const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
-
-const DEFAULT_ENVIRONMENT = 'production';
 
 /**
- * Returns the global event processors.
- * @deprecated Global event processors will be removed in v8.
- */
-function getGlobalEventProcessors() {
-  return getGlobalSingleton('globalEventProcessors', () => []);
+ * Returns the global shim registry.
+ *
+ * FIXME: This function is problematic, because despite always returning a valid Carrier,
+ * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
+ * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
+ **/
+function getMainCarrier() {
+  // This ensures a Sentry carrier exists
+  getSentryCarrier(GLOBAL_OBJ);
+  return GLOBAL_OBJ;
 }
 
-/**
- * Process an array of event processors, returning the processed event (or `null` if the event was dropped).
- */
-function notifyEventProcessors(
-  processors,
-  event,
-  hint,
-  index = 0,
-) {
-  return new SyncPromise((resolve, reject) => {
-    const processor = processors[index];
-    if (event === null || typeof processor !== 'function') {
-      resolve(event);
-    } else {
-      const result = processor({ ...event }, hint) ;
-
-      DEBUG_BUILD && processor.id && result === null && logger.log(`Event processor "${processor.id}" dropped event`);
-
-      if (isThenable(result)) {
-        void result
-          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))
-          .then(null, reject);
-      } else {
-        void notifyEventProcessors(processors, result, hint, index + 1)
-          .then(resolve)
-          .then(null, reject);
-      }
-    }
-  });
+/** Will either get the existing sentry carrier, or create a new one. */
+function getSentryCarrier(carrier) {
+  if (!carrier.__SENTRY__) {
+    carrier.__SENTRY__ = {
+      extensions: {},
+    };
+  }
+  return carrier.__SENTRY__;
 }
 
+const DEFAULT_ENVIRONMENT = 'production';
+
 /**
  * Creates a new `Session` object by setting certain default parameters. If optional @param context
  * is passed, the passed properties are applied to the session object.
@@ -867,320 +1614,28 @@ function sessionToJSON(session) {
   });
 }
 
-const TRACE_FLAG_SAMPLED = 0x1;
-
 /**
- * Convert a span to a trace context, which can be sent as the `trace` context in an event.
+ * Default value for maximum number of breadcrumbs added to an event.
  */
-function spanToTraceContext(span) {
-  const { spanId: span_id, traceId: trace_id } = span.spanContext();
-  const { data, op, parent_span_id, status, tags, origin } = spanToJSON(span);
-
-  return dropUndefinedKeys({
-    data,
-    op,
-    parent_span_id,
-    span_id,
-    status,
-    tags,
-    trace_id,
-    origin,
-  });
-}
+const DEFAULT_MAX_BREADCRUMBS = 100;
 
 /**
- * Convert a span to a JSON representation.
- * Note that all fields returned here are optional and need to be guarded against.
- *
- * Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).
- * This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.
- * And `spanToJSON` needs the Span class from `span.ts` to check here.
- * TODO v8: When we remove the deprecated stuff from `span.ts`, we can remove the circular dependency again.
+ * Holds additional event information.
  */
-function spanToJSON(span) {
-  if (spanIsSpanClass(span)) {
-    return span.getSpanJSON();
-  }
+class Scope  {
+  /** Flag if notifying is happening. */
 
-  // Fallback: We also check for `.toJSON()` here...
-  // eslint-disable-next-line deprecation/deprecation
-  if (typeof span.toJSON === 'function') {
-    // eslint-disable-next-line deprecation/deprecation
-    return span.toJSON();
-  }
+  /** Callback for client to receive scope changes. */
 
-  return {};
-}
+  /** Callback list that will be called during event processing. */
 
-/**
- * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.
- * :( So instead we approximate this by checking if it has the `getSpanJSON` method.
- */
-function spanIsSpanClass(span) {
-  return typeof (span ).getSpanJSON === 'function';
-}
+  /** Array of breadcrumbs. */
 
-/**
- * Returns true if a span is sampled.
- * In most cases, you should just use `span.isRecording()` instead.
- * However, this has a slightly different semantic, as it also returns false if the span is finished.
- * So in the case where this distinction is important, use this method.
- */
-function spanIsSampled(span) {
-  // We align our trace flags with the ones OpenTelemetry use
-  // So we also check for sampled the same way they do.
-  const { traceFlags } = span.spanContext();
-  // eslint-disable-next-line no-bitwise
-  return Boolean(traceFlags & TRACE_FLAG_SAMPLED);
-}
+  /** User */
 
-/**
- * Get the currently active client.
- */
-function getClient() {
-  // eslint-disable-next-line deprecation/deprecation
-  return getCurrentHub().getClient();
-}
+  /** Tags */
 
-/**
- * Get the currently active scope.
- */
-function getCurrentScope() {
-  // eslint-disable-next-line deprecation/deprecation
-  return getCurrentHub().getScope();
-}
-
-/**
- * Returns the root span of a given span.
- *
- * As long as we use `Transaction`s internally, the returned root span
- * will be a `Transaction` but be aware that this might change in the future.
- *
- * If the given span has no root span or transaction, `undefined` is returned.
- */
-function getRootSpan(span) {
-  // TODO (v8): Remove this check and just return span
-  // eslint-disable-next-line deprecation/deprecation
-  return span.transaction;
-}
-
-/**
- * Creates a dynamic sampling context from a client.
- *
- * Dispatches the `createDsc` lifecycle hook as a side effect.
- */
-function getDynamicSamplingContextFromClient(
-  trace_id,
-  client,
-  scope,
-) {
-  const options = client.getOptions();
-
-  const { publicKey: public_key } = client.getDsn() || {};
-  // TODO(v8): Remove segment from User
-  // eslint-disable-next-line deprecation/deprecation
-  const { segment: user_segment } = (scope && scope.getUser()) || {};
-
-  const dsc = dropUndefinedKeys({
-    environment: options.environment || DEFAULT_ENVIRONMENT,
-    release: options.release,
-    user_segment,
-    public_key,
-    trace_id,
-  }) ;
-
-  client.emit && client.emit('createDsc', dsc);
-
-  return dsc;
-}
-
-/**
- * A Span with a frozen dynamic sampling context.
- */
-
-/**
- * Creates a dynamic sampling context from a span (and client and scope)
- *
- * @param span the span from which a few values like the root span name and sample rate are extracted.
- *
- * @returns a dynamic sampling context
- */
-function getDynamicSamplingContextFromSpan(span) {
-  const client = getClient();
-  if (!client) {
-    return {};
-  }
-
-  // passing emit=false here to only emit later once the DSC is actually populated
-  const dsc = getDynamicSamplingContextFromClient(spanToJSON(span).trace_id || '', client, getCurrentScope());
-
-  // TODO (v8): Remove v7FrozenDsc as a Transaction will no longer have _frozenDynamicSamplingContext
-  const txn = getRootSpan(span) ;
-  if (!txn) {
-    return dsc;
-  }
-
-  // TODO (v8): Remove v7FrozenDsc as a Transaction will no longer have _frozenDynamicSamplingContext
-  // For now we need to avoid breaking users who directly created a txn with a DSC, where this field is still set.
-  // @see Transaction class constructor
-  const v7FrozenDsc = txn && txn._frozenDynamicSamplingContext;
-  if (v7FrozenDsc) {
-    return v7FrozenDsc;
-  }
-
-  // TODO (v8): Replace txn.metadata with txn.attributes[]
-  // We can't do this yet because attributes aren't always set yet.
-  // eslint-disable-next-line deprecation/deprecation
-  const { sampleRate: maybeSampleRate, source } = txn.metadata;
-  if (maybeSampleRate != null) {
-    dsc.sample_rate = `${maybeSampleRate}`;
-  }
-
-  // We don't want to have a transaction name in the DSC if the source is "url" because URLs might contain PII
-  const jsonSpan = spanToJSON(txn);
-
-  // after JSON conversion, txn.name becomes jsonSpan.description
-  if (source && source !== 'url') {
-    dsc.transaction = jsonSpan.description;
-  }
-
-  dsc.sampled = String(spanIsSampled(txn));
-
-  client.emit && client.emit('createDsc', dsc);
-
-  return dsc;
-}
-
-/**
- * Applies data from the scope to the event and runs all event processors on it.
- */
-function applyScopeDataToEvent(event, data) {
-  const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;
-
-  // Apply general data
-  applyDataToEvent(event, data);
-
-  // We want to set the trace context for normal events only if there isn't already
-  // a trace context on the event. There is a product feature in place where we link
-  // errors with transaction and it relies on that.
-  if (span) {
-    applySpanToEvent(event, span);
-  }
-
-  applyFingerprintToEvent(event, fingerprint);
-  applyBreadcrumbsToEvent(event, breadcrumbs);
-  applySdkMetadataToEvent(event, sdkProcessingMetadata);
-}
-
-function applyDataToEvent(event, data) {
-  const {
-    extra,
-    tags,
-    user,
-    contexts,
-    level,
-    // eslint-disable-next-line deprecation/deprecation
-    transactionName,
-  } = data;
-
-  const cleanedExtra = dropUndefinedKeys(extra);
-  if (cleanedExtra && Object.keys(cleanedExtra).length) {
-    event.extra = { ...cleanedExtra, ...event.extra };
-  }
-
-  const cleanedTags = dropUndefinedKeys(tags);
-  if (cleanedTags && Object.keys(cleanedTags).length) {
-    event.tags = { ...cleanedTags, ...event.tags };
-  }
-
-  const cleanedUser = dropUndefinedKeys(user);
-  if (cleanedUser && Object.keys(cleanedUser).length) {
-    event.user = { ...cleanedUser, ...event.user };
-  }
-
-  const cleanedContexts = dropUndefinedKeys(contexts);
-  if (cleanedContexts && Object.keys(cleanedContexts).length) {
-    event.contexts = { ...cleanedContexts, ...event.contexts };
-  }
-
-  if (level) {
-    event.level = level;
-  }
-
-  if (transactionName) {
-    event.transaction = transactionName;
-  }
-}
-
-function applyBreadcrumbsToEvent(event, breadcrumbs) {
-  const mergedBreadcrumbs = [...(event.breadcrumbs || []), ...breadcrumbs];
-  event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;
-}
-
-function applySdkMetadataToEvent(event, sdkProcessingMetadata) {
-  event.sdkProcessingMetadata = {
-    ...event.sdkProcessingMetadata,
-    ...sdkProcessingMetadata,
-  };
-}
-
-function applySpanToEvent(event, span) {
-  event.contexts = { trace: spanToTraceContext(span), ...event.contexts };
-  const rootSpan = getRootSpan(span);
-  if (rootSpan) {
-    event.sdkProcessingMetadata = {
-      dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),
-      ...event.sdkProcessingMetadata,
-    };
-    const transactionName = spanToJSON(rootSpan).description;
-    if (transactionName) {
-      event.tags = { transaction: transactionName, ...event.tags };
-    }
-  }
-}
-
-/**
- * Applies fingerprint from the scope to the event if there's one,
- * uses message if there's one instead or get rid of empty fingerprint
- */
-function applyFingerprintToEvent(event, fingerprint) {
-  // Make sure it's an array first and we actually have something in place
-  event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];
-
-  // If we have something on the scope, then merge it with event
-  if (fingerprint) {
-    event.fingerprint = event.fingerprint.concat(fingerprint);
-  }
-
-  // If we have no data at all, remove empty array default
-  if (event.fingerprint && !event.fingerprint.length) {
-    delete event.fingerprint;
-  }
-}
-
-/**
- * Default value for maximum number of breadcrumbs added to an event.
- */
-const DEFAULT_MAX_BREADCRUMBS = 100;
-
-/**
- * Holds additional event information. {@link Scope.applyToEvent} will be
- * called by the client before an event will be sent.
- */
-class Scope  {
-  /** Flag if notifying is happening. */
-
-  /** Callback for client to receive scope changes. */
-
-  /** Callback list that will be called after {@link applyToEvent}. */
-
-  /** Array of breadcrumbs. */
-
-  /** User */
-
-  /** Tags */
-
-  /** Extra */
+  /** Extra */
 
   /** Contexts */
 
@@ -1196,10 +1651,12 @@ class Scope  {
   /** Fingerprint */
 
   /** Severity */
-  // eslint-disable-next-line deprecation/deprecation
 
   /**
    * Transaction Name
+   *
+   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
    */
 
   /** Span */
@@ -1235,7 +1692,7 @@ class Scope  {
   }
 
   /**
-   * Clone this scope instance.
+   * @inheritDoc
    */
    clone() {
     const newScope = new Scope();
@@ -1259,23 +1716,22 @@ class Scope  {
     return newScope;
   }
 
-  /** Update the client on the scope. */
+  /**
+   * @inheritDoc
+   */
    setClient(client) {
     this._client = client;
   }
 
   /**
-   * Get the client assigned to this scope.
-   *
-   * It is generally recommended to use the global function `Sentry.getClient()` instead, unless you know what you are doing.
+   * @inheritDoc
    */
    getClient() {
-    return this._client;
+    return this._client ;
   }
 
   /**
-   * Add internal on change listener. Used for sub SDKs that need to store the scope.
-   * @hidden
+   * @inheritDoc
    */
    addScopeListener(callback) {
     this._scopeListeners.push(callback);
@@ -1299,7 +1755,6 @@ class Scope  {
       email: undefined,
       id: undefined,
       ip_address: undefined,
-      segment: undefined,
       username: undefined,
     };
 
@@ -1387,17 +1842,14 @@ class Scope  {
   /**
    * @inheritDoc
    */
-   setLevel(
-    // eslint-disable-next-line deprecation/deprecation
-    level,
-  ) {
+   setLevel(level) {
     this._level = level;
     this._notifyScopeListeners();
     return this;
   }
 
   /**
-   * Sets the transaction name on the scope for future events.
+   * @inheritDoc
    */
    setTransactionName(name) {
     this._transactionName = name;
@@ -1447,10 +1899,15 @@ class Scope  {
     // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will
     // have a pointer to the currently-active transaction.
     const span = this._span;
+
     // Cannot replace with getRootSpan because getRootSpan returns a span, not a transaction
     // Also, this method will be removed anyway.
     // eslint-disable-next-line deprecation/deprecation
-    return span && span.transaction;
+    if (span && (span ).transaction) {
+      // eslint-disable-next-line deprecation/deprecation
+      return (span ).transaction;
+    }
+    return undefined;
   }
 
   /**
@@ -1533,6 +1990,7 @@ class Scope  {
    * @inheritDoc
    */
    clear() {
+    // client is not cleared here on purpose!
     this._breadcrumbs = [];
     this._tags = {};
     this._extra = {};
@@ -1653,33 +2111,7 @@ class Scope  {
   }
 
   /**
-   * Applies data from the scope to the event and runs all event processors on it.
-   *
-   * @param event Event
-   * @param hint Object containing additional information about the original exception, for use by the event processors.
-   * @hidden
-   * @deprecated Use `applyScopeDataToEvent()` directly
-   */
-   applyToEvent(
-    event,
-    hint = {},
-    additionalEventProcessors = [],
-  ) {
-    applyScopeDataToEvent(event, this.getScopeData());
-
-    // TODO (v8): Update this order to be: Global > Client > Scope
-    const eventProcessors = [
-      ...additionalEventProcessors,
-      // eslint-disable-next-line deprecation/deprecation
-      ...getGlobalEventProcessors(),
-      ...this._eventProcessors,
-    ];
-
-    return notifyEventProcessors(eventProcessors, event, hint);
-  }
-
-  /**
-   * Add data which will be accessible during event processing but won't get sent to Sentry
+   * @inheritDoc
    */
    setSDKProcessingMetadata(newData) {
     this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
@@ -1703,11 +2135,7 @@ class Scope  {
   }
 
   /**
-   * Capture an exception for this scope.
-   *
-   * @param exception The exception to capture.
-   * @param hint Optinal additional data to attach to the Sentry event.
-   * @returns the id of the captured Sentry event.
+   * @inheritDoc
    */
    captureException(exception, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
@@ -1734,12 +2162,7 @@ class Scope  {
   }
 
   /**
-   * Capture a message for this scope.
-   *
-   * @param message The message to capture.
-   * @param level An optional severity level to report the message with.
-   * @param hint Optional additional data to attach to the Sentry event.
-   * @returns the id of the captured message.
+   * @inheritDoc
    */
    captureMessage(message, level, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
@@ -1767,11 +2190,7 @@ class Scope  {
   }
 
   /**
-   * Captures a manually created event for this scope and sends it to Sentry.
-   *
-   * @param exception The event to capture.
-   * @param hint Optional additional data to attach to the Sentry event.
-   * @returns the id of the captured event.
+   * @inheritDoc
    */
    captureEvent(event, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
@@ -1810,7 +2229,7 @@ function generatePropagationContext() {
   };
 }
 
-const SDK_VERSION = '7.107.0';
+const SDK_VERSION = '8.0.0-alpha.3';
 
 /**
  * API compatibility version of this hub.
@@ -1826,7 +2245,12 @@ const API_VERSION = parseFloat(SDK_VERSION);
  * Default maximum number of breadcrumbs added to an event. Can be overwritten
  * with {@link Options.maxBreadcrumbs}.
  */
-const DEFAULT_BREADCRUMBS = 100;
+const DEFAULT_BREADCRUMBS$1 = 100;
+
+/**
+ * A layer in the process stack.
+ * @hidden
+ */
 
 /**
  * @inheritDoc
@@ -1834,8 +2258,6 @@ const DEFAULT_BREADCRUMBS = 100;
 class Hub  {
   /** Is a {@link Layer}[] containing the client and scope */
 
-  /** Contains the last event id of a captured event.  */
-
   /**
    * Creates a new instance of the hub, will push one {@link Layer} into the
    * internal stack on creation.
@@ -2064,7 +2486,7 @@ class Hub  {
    * @deprecated Use `Sentry.captureException()` instead.
    */
    captureException(exception, hint) {
-    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());
+    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
     const syntheticException = new Error('Sentry syntheticException');
     // eslint-disable-next-line deprecation/deprecation
     this.getScope().captureException(exception, {
@@ -2082,13 +2504,8 @@ class Hub  {
    *
    * @deprecated Use  `Sentry.captureMessage()` instead.
    */
-   captureMessage(
-    message,
-    // eslint-disable-next-line deprecation/deprecation
-    level,
-    hint,
-  ) {
-    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());
+   captureMessage(message, level, hint) {
+    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
     const syntheticException = new Error(message);
     // eslint-disable-next-line deprecation/deprecation
     this.getScope().captureMessage(message, level, {
@@ -2108,23 +2525,11 @@ class Hub  {
    */
    captureEvent(event, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
-    if (!event.type) {
-      this._lastEventId = eventId;
-    }
     // eslint-disable-next-line deprecation/deprecation
     this.getScope().captureEvent(event, { ...hint, event_id: eventId });
     return eventId;
   }
 
-  /**
-   * @inheritDoc
-   *
-   * @deprecated This will be removed in v8.
-   */
-   lastEventId() {
-    return this._lastEventId;
-  }
-
   /**
    * @inheritDoc
    *
@@ -2132,11 +2537,11 @@ class Hub  {
    */
    addBreadcrumb(breadcrumb, hint) {
     // eslint-disable-next-line deprecation/deprecation
-    const { scope, client } = this.getStackTop();
+    const { client } = this.getStackTop();
 
     if (!client) return;
 
-    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =
+    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS$1 } =
       (client.getOptions && client.getOptions()) || {};
 
     if (maxBreadcrumbs <= 0) return;
@@ -2149,19 +2554,10 @@ class Hub  {
 
     if (finalBreadcrumb === null) return;
 
-    if (client.emit) {
-      client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);
-    }
-
-    // TODO(v8): I know this comment doesn't make much sense because the hub will be deprecated but I still wanted to
-    // write it down. In theory, we would have to add the breadcrumbs to the isolation scope here, however, that would
-    // duplicate all of the breadcrumbs. There was the possibility of adding breadcrumbs to both, the isolation scope
-    // and the normal scope, and deduplicating it down the line in the event processing pipeline. However, that would
-    // have been very fragile, because the breadcrumb objects would have needed to keep their identity all throughout
-    // the event processing pipeline.
-    // In the new implementation, the top level `Sentry.addBreadcrumb()` should ONLY write to the isolation scope.
+    client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);
 
-    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
+    // eslint-disable-next-line deprecation/deprecation
+    this.getIsolationScope().addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
   }
 
   /**
@@ -2169,9 +2565,6 @@ class Hub  {
    * @deprecated Use `Sentry.setUser()` instead.
    */
    setUser(user) {
-    // TODO(v8): The top level `Sentry.setUser()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setUser(user);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setUser(user);
   }
@@ -2181,9 +2574,6 @@ class Hub  {
    * @deprecated Use `Sentry.setTags()` instead.
    */
    setTags(tags) {
-    // TODO(v8): The top level `Sentry.setTags()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setTags(tags);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setTags(tags);
   }
@@ -2193,9 +2583,6 @@ class Hub  {
    * @deprecated Use `Sentry.setExtras()` instead.
    */
    setExtras(extras) {
-    // TODO(v8): The top level `Sentry.setExtras()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setExtras(extras);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setExtras(extras);
   }
@@ -2205,9 +2592,6 @@ class Hub  {
    * @deprecated Use `Sentry.setTag()` instead.
    */
    setTag(key, value) {
-    // TODO(v8): The top level `Sentry.setTag()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setTag(key, value);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setTag(key, value);
   }
@@ -2217,9 +2601,6 @@ class Hub  {
    * @deprecated Use `Sentry.setExtra()` instead.
    */
    setExtra(key, extra) {
-    // TODO(v8): The top level `Sentry.setExtra()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setExtra(key, extra);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setExtra(key, extra);
   }
@@ -2230,40 +2611,10 @@ class Hub  {
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
    setContext(name, context) {
-    // TODO(v8): The top level `Sentry.setContext()` function should write ONLY to the isolation scope.
-    // eslint-disable-next-line deprecation/deprecation
-    this.getScope().setContext(name, context);
     // eslint-disable-next-line deprecation/deprecation
     this.getIsolationScope().setContext(name, context);
   }
 
-  /**
-   * @inheritDoc
-   *
-   * @deprecated Use `getScope()` directly.
-   */
-   configureScope(callback) {
-    // eslint-disable-next-line deprecation/deprecation
-    const { scope, client } = this.getStackTop();
-    if (client) {
-      callback(scope);
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-   run(callback) {
-    // eslint-disable-next-line deprecation/deprecation
-    const oldHub = makeMain(this);
-    try {
-      callback(this);
-    } finally {
-      // eslint-disable-next-line deprecation/deprecation
-      makeMain(oldHub);
-    }
-  }
-
   /**
    * @inheritDoc
    * @deprecated Use `Sentry.getClient().getIntegrationByName()` instead.
@@ -2276,59 +2627,11 @@ class Hub  {
       // eslint-disable-next-line deprecation/deprecation
       return client.getIntegration(integration);
     } catch (_oO) {
-      DEBUG_BUILD && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
+      DEBUG_BUILD$1 && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
       return null;
     }
   }
 
-  /**
-   * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.
-   *
-   * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a
-   * new child span within the transaction or any span, call the respective `.startChild()` method.
-   *
-   * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.
-   *
-   * The transaction must be finished with a call to its `.end()` method, at which point the transaction with all its
-   * finished child spans will be sent to Sentry.
-   *
-   * @param context Properties of the new `Transaction`.
-   * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent
-   * default values). See {@link Options.tracesSampler}.
-   *
-   * @returns The transaction which was just started
-   *
-   * @deprecated Use `startSpan()`, `startSpanManual()` or `startInactiveSpan()` instead.
-   */
-   startTransaction(context, customSamplingContext) {
-    const result = this._callExtensionMethod('startTransaction', context, customSamplingContext);
-
-    if (DEBUG_BUILD && !result) {
-      // eslint-disable-next-line deprecation/deprecation
-      const client = this.getClient();
-      if (!client) {
-        logger.warn(
-          "Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'",
-        );
-      } else {
-        logger.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':
-Sentry.addTracingExtensions();
-Sentry.init({...});
-`);
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * @inheritDoc
-   * @deprecated Use `spanToTraceHeader()` instead.
-   */
-   traceHeaders() {
-    return this._callExtensionMethod('traceHeaders');
-  }
-
   /**
    * @inheritDoc
    *
@@ -2394,152 +2697,704 @@ Sentry.init({...});
     // Afterwards we set the new session on the scope
     scope.setSession(session);
 
-    return session;
-  }
+    return session;
+  }
+
+  /**
+   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
+   * when Tracing is used.
+   *
+   * @deprecated Use top-level `getClient().getOptions().sendDefaultPii` instead. This function
+   * only unnecessarily increased API surface but only wrapped accessing the option.
+   */
+   shouldSendDefaultPii() {
+    // eslint-disable-next-line deprecation/deprecation
+    const client = this.getClient();
+    const options = client && client.getOptions();
+    return Boolean(options && options.sendDefaultPii);
+  }
+
+  /**
+   * Sends the current Session on the scope
+   */
+   _sendSessionUpdate() {
+    // eslint-disable-next-line deprecation/deprecation
+    const { scope, client } = this.getStackTop();
+
+    const session = scope.getSession();
+    if (session && client && client.captureSession) {
+      client.captureSession(session);
+    }
+  }
+
+  /**
+   * Calls global extension method and binding current instance to the function call
+   */
+  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+   _callExtensionMethod(method, ...args) {
+    const carrier = getMainCarrier();
+    const sentry = getSentryCarrier(carrier);
+    if (sentry.extensions && typeof sentry.extensions[method] === 'function') {
+      return sentry.extensions[method].apply(this, args);
+    }
+    DEBUG_BUILD$1 && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
+  }
+}
+
+/**
+ * Returns the default hub instance.
+ *
+ * If a hub is already registered in the global carrier but this module
+ * contains a more recent version, it replaces the registered version.
+ * Otherwise, the currently registered hub will be returned.
+ *
+ * @deprecated Use the respective replacement method directly instead.
+ */
+function getCurrentHub() {
+  // Get main carrier (global for every environment)
+  const carrier = getMainCarrier();
+
+  const acs = getAsyncContextStrategy(carrier);
+  return acs.getCurrentHub() || getGlobalHub();
+}
+
+/** Get the default current scope. */
+function getDefaultCurrentScope() {
+  return getGlobalSingleton('defaultCurrentScope', () => new Scope());
+}
+
+/** Get the default isolation scope. */
+function getDefaultIsolationScope() {
+  return getGlobalSingleton('defaultIsolationScope', () => new Scope());
+}
+
+/**
+ * Get the global hub.
+ * This will be removed during the v8 cycle and is only here to make migration easier.
+ */
+function getGlobalHub() {
+  const registry = getMainCarrier();
+  const sentry = getSentryCarrier(registry) ;
+
+  // If there's no hub, or its an old API, assign a new one
+  if (sentry.hub) {
+    return sentry.hub;
+  }
+
+  // eslint-disable-next-line deprecation/deprecation
+  sentry.hub = new Hub(undefined, getDefaultCurrentScope(), getDefaultIsolationScope());
+  return sentry.hub;
+}
+
+/**
+ * Get the current async context strategy.
+ * If none has been setup, the default will be used.
+ */
+function getAsyncContextStrategy(carrier) {
+  const sentry = getSentryCarrier(carrier);
+
+  if (sentry.acs) {
+    return sentry.acs;
+  }
+
+  // Otherwise, use the default one
+  return getHubStackAsyncContextStrategy();
+}
+
+function withScope$1(callback) {
+  // eslint-disable-next-line deprecation/deprecation
+  return getGlobalHub().withScope(callback);
+}
+
+function withSetScope(scope, callback) {
+  const hub = getGlobalHub() ;
+  // eslint-disable-next-line deprecation/deprecation
+  return hub.withScope(() => {
+    // eslint-disable-next-line deprecation/deprecation
+    hub.getStackTop().scope = scope ;
+    return callback(scope);
+  });
+}
+
+function withIsolationScope$1(callback) {
+  // eslint-disable-next-line deprecation/deprecation
+  return getGlobalHub().withScope(() => {
+    // eslint-disable-next-line deprecation/deprecation
+    return callback(getGlobalHub().getIsolationScope());
+  });
+}
+
+/* eslint-disable deprecation/deprecation */
+function getHubStackAsyncContextStrategy() {
+  return {
+    getCurrentHub: getGlobalHub,
+    withIsolationScope: withIsolationScope$1,
+    withScope: withScope$1,
+    withSetScope,
+    withSetIsolationScope: (_isolationScope, callback) => {
+      return withIsolationScope$1(callback);
+    },
+    getCurrentScope: () => getGlobalHub().getScope(),
+    getIsolationScope: () => getGlobalHub().getIsolationScope(),
+  };
+}
+/* eslint-enable deprecation/deprecation */
+
+/**
+ * Get the currently active scope.
+ */
+function getCurrentScope() {
+  const carrier = getMainCarrier();
+  const acs = getAsyncContextStrategy(carrier);
+  return acs.getCurrentScope();
+}
+
+/**
+ * Get the currently active client.
+ */
+function getClient() {
+  return getCurrentScope().getClient();
+}
+
+/**
+ * Fetches the metric summary if it exists for the passed span
+ */
+function getMetricSummaryJsonForSpan(span) {
+
+  {
+    return undefined;
+  }
+}
+
+/**
+ * Use this attribute to represent the operation of a span.
+ */
+const SEMANTIC_ATTRIBUTE_SENTRY_OP = 'sentry.op';
+
+/**
+ * Use this attribute to represent the origin of a span.
+ */
+const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = 'sentry.origin';
+
+const SPAN_STATUS_UNSET = 0;
+const SPAN_STATUS_OK = 1;
+const TRACE_FLAG_SAMPLED = 0x1;
+
+/**
+ * Convert a span time input intp a timestamp in seconds.
+ */
+function spanTimeInputToSeconds(input) {
+  if (typeof input === 'number') {
+    return ensureTimestampInSeconds(input);
+  }
+
+  if (Array.isArray(input)) {
+    // See {@link HrTime} for the array-based time format
+    return input[0] + input[1] / 1e9;
+  }
+
+  if (input instanceof Date) {
+    return ensureTimestampInSeconds(input.getTime());
+  }
+
+  return timestampInSeconds();
+}
+
+/**
+ * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.
+ */
+function ensureTimestampInSeconds(timestamp) {
+  const isMs = timestamp > 9999999999;
+  return isMs ? timestamp / 1000 : timestamp;
+}
+
+/**
+ * Convert a span to a JSON representation.
+ * Note that all fields returned here are optional and need to be guarded against.
+ *
+ * Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).
+ * This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.
+ * And `spanToJSON` needs the Span class from `span.ts` to check here.
+ */
+function spanToJSON(span) {
+  if (spanIsSentrySpan(span)) {
+    return span.getSpanJSON();
+  }
+
+  try {
+    const { spanId: span_id, traceId: trace_id } = span.spanContext();
+
+    // Handle a span from @opentelemetry/sdk-base-trace's `Span` class
+    if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
+      const { attributes, startTime, name, endTime, parentSpanId, status } = span;
+
+      return dropUndefinedKeys({
+        span_id,
+        trace_id,
+        data: attributes,
+        description: name,
+        parent_span_id: parentSpanId,
+        start_timestamp: spanTimeInputToSeconds(startTime),
+        // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+        timestamp: spanTimeInputToSeconds(endTime) || undefined,
+        status: getStatusMessage(status),
+        op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
+        origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] ,
+        _metrics_summary: getMetricSummaryJsonForSpan(span),
+      });
+    }
+
+    // Finally, at least we have `spanContext()`....
+    return {
+      span_id,
+      trace_id,
+    };
+  } catch (e) {
+    return {};
+  }
+}
+
+function spanIsOpenTelemetrySdkTraceBaseSpan(span) {
+  const castSpan = span ;
+  return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;
+}
+
+/** Exported only for tests. */
+
+/**
+ * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.
+ * :( So instead we approximate this by checking if it has the `getSpanJSON` method.
+ */
+function spanIsSentrySpan(span) {
+  return typeof (span ).getSpanJSON === 'function';
+}
+
+/**
+ * Returns true if a span is sampled.
+ * In most cases, you should just use `span.isRecording()` instead.
+ * However, this has a slightly different semantic, as it also returns false if the span is finished.
+ * So in the case where this distinction is important, use this method.
+ */
+function spanIsSampled(span) {
+  // We align our trace flags with the ones OpenTelemetry use
+  // So we also check for sampled the same way they do.
+  const { traceFlags } = span.spanContext();
+  return traceFlags === TRACE_FLAG_SAMPLED;
+}
+
+/** Get the status message to use for a JSON representation of a span. */
+function getStatusMessage(status) {
+  if (!status || status.code === SPAN_STATUS_UNSET) {
+    return undefined;
+  }
+
+  if (status.code === SPAN_STATUS_OK) {
+    return 'ok';
+  }
+
+  return status.message || 'unknown_error';
+}
+const ROOT_SPAN_FIELD = '_sentryRootSpan';
+
+/**
+ * Returns the root span of a given span.
+ */
+function getRootSpan(span) {
+  return span[ROOT_SPAN_FIELD] || span;
+}
+
+/**
+ * Convert a new integration function to the legacy class syntax.
+ * In v8, we can remove this and instead export the integration functions directly.
+ *
+ * @deprecated This will be removed in v8!
+ */
+function convertIntegrationFnToClass(
+  name,
+  fn,
+) {
+  return Object.assign(
+    function ConvertedIntegration(...args) {
+      return fn(...args);
+    },
+    { id: name },
+  ) ;
+}
+
+/**
+ * Define an integration function that can be used to create an integration instance.
+ * Note that this by design hides the implementation details of the integration, as they are considered internal.
+ */
+function defineIntegration(fn) {
+  return fn;
+}
+
+/** Keys are source filename/url, values are metadata objects. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const filenameMetadataMap = new Map();
+/** Set of stack strings that have already been parsed. */
+const parsedStacks = new Set();
 
-  /**
-   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests
-   * when Tracing is used.
-   *
-   * @deprecated Use top-level `getClient().getOptions().sendDefaultPii` instead. This function
-   * only unnecessarily increased API surface but only wrapped accessing the option.
-   */
-   shouldSendDefaultPii() {
-    // eslint-disable-next-line deprecation/deprecation
-    const client = this.getClient();
-    const options = client && client.getOptions();
-    return Boolean(options && options.sendDefaultPii);
+function ensureMetadataStacksAreParsed(parser) {
+  if (!GLOBAL_OBJ._sentryModuleMetadata) {
+    return;
   }
 
-  /**
-   * Sends the current Session on the scope
-   */
-   _sendSessionUpdate() {
-    // eslint-disable-next-line deprecation/deprecation
-    const { scope, client } = this.getStackTop();
+  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {
+    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];
 
-    const session = scope.getSession();
-    if (session && client && client.captureSession) {
-      client.captureSession(session);
+    if (parsedStacks.has(stack)) {
+      continue;
     }
-  }
 
-  /**
-   * Calls global extension method and binding current instance to the function call
-   */
-  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-   _callExtensionMethod(method, ...args) {
-    const carrier = getMainCarrier();
-    const sentry = carrier.__SENTRY__;
-    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {
-      return sentry.extensions[method].apply(this, args);
+    // Ensure this stack doesn't get parsed again
+    parsedStacks.add(stack);
+
+    const frames = parser(stack);
+
+    // Go through the frames starting from the top of the stack and find the first one with a filename
+    for (const frame of frames.reverse()) {
+      if (frame.filename) {
+        // Save the metadata for this filename
+        filenameMetadataMap.set(frame.filename, metadata);
+        break;
+      }
     }
-    DEBUG_BUILD && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
   }
 }
 
 /**
- * Returns the global shim registry.
+ * Retrieve metadata for a specific JavaScript file URL.
  *
- * FIXME: This function is problematic, because despite always returning a valid Carrier,
- * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
- * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
- **/
-function getMainCarrier() {
-  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {
-    extensions: {},
-    hub: undefined,
-  };
-  return GLOBAL_OBJ;
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getMetadataForUrl(parser, filename) {
+  ensureMetadataStacksAreParsed(parser);
+  return filenameMetadataMap.get(filename);
 }
 
 /**
- * Replaces the current main hub with the passed one on the global object
+ * Adds metadata to stack frames.
  *
- * @returns The old replaced hub
- *
- * @deprecated Use `setCurrentClient()` instead.
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
  */
-function makeMain(hub) {
-  const registry = getMainCarrier();
-  const oldHub = getHubFromCarrier(registry);
-  setHubOnCarrier(registry, hub);
-  return oldHub;
+function addMetadataToStackFrames(parser, event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
+
+      for (const frame of exception.stacktrace.frames || []) {
+        if (!frame.filename) {
+          continue;
+        }
+
+        const metadata = getMetadataForUrl(parser, frame.filename);
+
+        if (metadata) {
+          frame.module_metadata = metadata;
+        }
+      }
+    });
+  } catch (_) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
 }
 
 /**
- * Returns the default hub instance.
+ * Strips metadata from stack frames.
+ */
+function stripMetadataFromStackFrames(event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
+
+      for (const frame of exception.stacktrace.frames || []) {
+        delete frame.module_metadata;
+      }
+    });
+  } catch (_) {
+    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.
+  }
+}
+
+const INTEGRATION_NAME$a = 'ModuleMetadata';
+
+const _moduleMetadataIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME$a,
+    setup(client) {
+      // We need to strip metadata from stack frames before sending them to Sentry since these are client side only.
+      client.on('beforeEnvelope', envelope => {
+        forEachEnvelopeItem(envelope, (item, type) => {
+          if (type === 'event') {
+            const event = Array.isArray(item) ? (item )[1] : undefined;
+
+            if (event) {
+              stripMetadataFromStackFrames(event);
+              item[1] = event;
+            }
+          }
+        });
+      });
+    },
+
+    processEvent(event, _hint, client) {
+      const stackParser = client.getOptions().stackParser;
+      addMetadataToStackFrames(stackParser, event);
+      return event;
+    },
+  };
+}) ;
+
+const moduleMetadataIntegration = defineIntegration(_moduleMetadataIntegration);
+
+/**
+ * Adds module metadata to stack frames.
  *
- * If a hub is already registered in the global carrier but this module
- * contains a more recent version, it replaces the registered version.
- * Otherwise, the currently registered hub will be returned.
+ * Metadata can be injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
  *
- * @deprecated Use the respective replacement method directly instead.
+ * When this integration is added, the metadata passed to the bundler plugin is added to the stack frames of all events
+ * under the `module_metadata` property. This can be used to help in tagging or routing of events from different teams
+ * our sources
+ *
+ * @deprecated Use `moduleMetadataIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+convertIntegrationFnToClass(
+  INTEGRATION_NAME$a,
+  moduleMetadataIntegration,
+)
+
+;
+
+const DEFAULT_OPTIONS = {
+  include: {
+    cookies: true,
+    data: true,
+    headers: true,
+    ip: false,
+    query_string: true,
+    url: true,
+    user: {
+      id: true,
+      username: true,
+      email: true,
+    },
+  },
+  transactionNamingScheme: 'methodPath' ,
+};
+
+const INTEGRATION_NAME$9 = 'RequestData';
+
+const _requestDataIntegration = ((options = {}) => {
+  const _options = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    include: {
+      ...DEFAULT_OPTIONS.include,
+      ...options.include,
+      user:
+        options.include && typeof options.include.user === 'boolean'
+          ? options.include.user
+          : {
+              ...DEFAULT_OPTIONS.include.user,
+              // Unclear why TS still thinks `options.include.user` could be a boolean at this point
+              ...((options.include || {}).user ),
+            },
+    },
+  };
+
+  return {
+    name: INTEGRATION_NAME$9,
+    processEvent(event, _hint, client) {
+      // Note: In the long run, most of the logic here should probably move into the request data utility functions. For
+      // the moment it lives here, though, until https://github.com/getsentry/sentry-javascript/issues/5718 is addressed.
+      // (TL;DR: Those functions touch many parts of the repo in many different ways, and need to be clened up. Once
+      // that's happened, it will be easier to add this logic in without worrying about unexpected side effects.)
+      const { transactionNamingScheme } = _options;
+
+      const { sdkProcessingMetadata = {} } = event;
+      const req = sdkProcessingMetadata.request;
+
+      if (!req) {
+        return event;
+      }
+
+      const addRequestDataOptions = convertReqDataIntegrationOptsToAddReqDataOpts(_options);
+
+      const processedEvent = addRequestDataToEvent(event, req, addRequestDataOptions);
+
+      // Transaction events already have the right `transaction` value
+      if (event.type === 'transaction' || transactionNamingScheme === 'handler') {
+        return processedEvent;
+      }
+
+      // In all other cases, use the request's associated transaction (if any) to overwrite the event's `transaction`
+      // value with a high-quality one
+      const reqWithTransaction = req ;
+      const transaction = reqWithTransaction._sentryTransaction;
+      if (transaction) {
+        const name = spanToJSON(transaction).description || '';
+
+        // TODO (v8): Remove the nextjs check and just base it on `transactionNamingScheme` for all SDKs. (We have to
+        // keep it the way it is for the moment, because changing the names of transactions in Sentry has the potential
+        // to break things like alert rules.)
+        const shouldIncludeMethodInTransactionName =
+          getSDKName(client) === 'sentry.javascript.nextjs'
+            ? name.startsWith('/api')
+            : transactionNamingScheme !== 'path';
+
+        const [transactionValue] = extractPathForTransaction(req, {
+          path: true,
+          method: shouldIncludeMethodInTransactionName,
+          customRoute: name,
+        });
+
+        processedEvent.transaction = transactionValue;
+      }
+
+      return processedEvent;
+    },
+  };
+}) ;
+
+const requestDataIntegration = defineIntegration(_requestDataIntegration);
+
+/**
+ * Add data about a request to an event. Primarily for use in Node-based SDKs, but included in `@sentry/core`
+ * so it can be used in cross-platform SDKs like `@sentry/nextjs`.
+ * @deprecated Use `requestDataIntegration()` instead.
  */
-function getCurrentHub() {
-  // Get main carrier (global for every environment)
-  const registry = getMainCarrier();
+// eslint-disable-next-line deprecation/deprecation
+convertIntegrationFnToClass(INTEGRATION_NAME$9, requestDataIntegration)
+
+;
 
-  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {
-    const hub = registry.__SENTRY__.acs.getCurrentHub();
+/** Convert this integration's options to match what `addRequestDataToEvent` expects */
+/** TODO: Can possibly be deleted once https://github.com/getsentry/sentry-javascript/issues/5718 is fixed */
+function convertReqDataIntegrationOptsToAddReqDataOpts(
+  integrationOptions,
+) {
+  const {
+    transactionNamingScheme,
+    include: { ip, user, ...requestOptions },
+  } = integrationOptions;
 
-    if (hub) {
-      return hub;
+  const requestIncludeKeys = ['method'];
+  for (const [key, value] of Object.entries(requestOptions)) {
+    if (value) {
+      requestIncludeKeys.push(key);
     }
   }
 
-  // Return hub that lives on a global object
-  return getGlobalHub(registry);
-}
+  let addReqDataUserOpt;
+  if (user === undefined) {
+    addReqDataUserOpt = true;
+  } else if (typeof user === 'boolean') {
+    addReqDataUserOpt = user;
+  } else {
+    const userIncludeKeys = [];
+    for (const [key, value] of Object.entries(user)) {
+      if (value) {
+        userIncludeKeys.push(key);
+      }
+    }
+    addReqDataUserOpt = userIncludeKeys;
+  }
 
-function getGlobalHub(registry = getMainCarrier()) {
-  // If there's no hub, or its an old API, assign a new one
+  return {
+    include: {
+      ip,
+      user: addReqDataUserOpt,
+      request: requestIncludeKeys.length !== 0 ? requestIncludeKeys : undefined,
+      transaction: transactionNamingScheme,
+    },
+  };
+}
 
-  if (
-    !hasHubOnCarrier(registry) ||
-    // eslint-disable-next-line deprecation/deprecation
-    getHubFromCarrier(registry).isOlderThan(API_VERSION)
-  ) {
-    // eslint-disable-next-line deprecation/deprecation
-    setHubOnCarrier(registry, new Hub());
+function getSDKName(client) {
+  try {
+    // For a long chain like this, it's fewer bytes to combine a try-catch with assuming everything is there than to
+    // write out a long chain of `a && a.b && a.b.c && ...`
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return client.getOptions()._metadata.sdk.name;
+  } catch (err) {
+    // In theory we should never get here
+    return undefined;
   }
-
-  // Return hub that lives on a global object
-  return getHubFromCarrier(registry);
 }
 
+let originalFunctionToString;
+
+const INTEGRATION_NAME$8 = 'FunctionToString';
+
+const SETUP_CLIENTS = new WeakMap();
+
+const _functionToStringIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME$8,
+    setupOnce() {
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      originalFunctionToString = Function.prototype.toString;
+
+      // intrinsics (like Function.prototype) might be immutable in some environments
+      // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Function.prototype.toString = function ( ...args) {
+          const originalFunction = getOriginalFunction(this);
+          const context =
+            SETUP_CLIENTS.has(getClient() ) && originalFunction !== undefined ? originalFunction : this;
+          return originalFunctionToString.apply(context, args);
+        };
+      } catch (e) {
+        // ignore errors here, just don't patch this
+      }
+    },
+    setup(client) {
+      SETUP_CLIENTS.set(client, true);
+    },
+  };
+}) ;
+
 /**
- * This will tell whether a carrier has a hub on it or not
- * @param carrier object
+ * Patch toString calls to return proper name for wrapped functions.
+ *
+ * ```js
+ * Sentry.init({
+ *   integrations: [
+ *     functionToStringIntegration(),
+ *   ],
+ * });
+ * ```
  */
-function hasHubOnCarrier(carrier) {
-  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);
-}
+const functionToStringIntegration = defineIntegration(_functionToStringIntegration);
 
 /**
- * This will create a new {@link Hub} and add to the passed object on
- * __SENTRY__.hub.
- * @param carrier object
- * @hidden
+ * Patch toString calls to return proper name for wrapped functions.
+ *
+ * @deprecated Use `functionToStringIntegration()` instead.
  */
-function getHubFromCarrier(carrier) {
-  // eslint-disable-next-line deprecation/deprecation
-  return getGlobalSingleton('hub', () => new Hub(), carrier);
-}
+// eslint-disable-next-line deprecation/deprecation
+convertIntegrationFnToClass(
+  INTEGRATION_NAME$8,
+  functionToStringIntegration,
+) ;
 
 /**
- * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute
- * @param carrier object
- * @param hub Hub
- * @returns A boolean indicating success or failure
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
  */
-function setHubOnCarrier(carrier, hub) {
-  if (!carrier) return false;
-  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});
-  __SENTRY__.hub = hub;
-  return true;
-}
+const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
 
 const stdlib = detectLibc.familySync();
 const platform = process.env['BUILD_PLATFORM'] || os.platform();
@@ -2562,7 +3417,6 @@ function importCppBindingsModule() {
         const binaryPath = path.join(path.resolve(process$1.env['SENTRY_PROFILER_BINARY_DIR']), `sentry_cpu_profiler-${identifier}`);
         return require(`${binaryPath}.node`);
     }
-    /* eslint-disable no-fallthrough */
     // We need the fallthrough so that in the end, we can fallback to the require dynamice require.
     // This is for cases where precompiled binaries were not provided, but may have been compiled from source.
     if (platform === 'darwin') {
@@ -2658,14 +3512,14 @@ const PrivateCpuProfilerBindings = importCppBindingsModule();
 const CpuProfilerBindings = {
     startProfiling(name) {
         if (!PrivateCpuProfilerBindings) {
-            DEBUG_BUILD$1 && logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
+            DEBUG_BUILD && logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
             return;
         }
         return PrivateCpuProfilerBindings.startProfiling(name);
     },
     stopProfiling(name) {
         if (!PrivateCpuProfilerBindings) {
-            DEBUG_BUILD$1 &&
+            DEBUG_BUILD &&
                 logger.log('[Profiling] Bindings not loaded or profile was never started, ignoring call to stopProfiling.');
             return null;
         }
@@ -2673,10 +3527,8 @@ const CpuProfilerBindings = {
     },
 };
 
-/* eslint-disable max-lines */
 // We require the file because if we import it, it will be included in the bundle.
 // I guess tsc does not check file contents when it's imported.
-// eslint-disable-next-line
 const THREAD_ID_STRING = String(worker_threads.threadId);
 const THREAD_NAME = worker_threads.isMainThread ? 'main' : 'worker';
 const FORMAT_VERSION = '1';
@@ -2720,84 +3572,6 @@ function enrichWithThreadInformation(profile) {
         },
     };
 }
-/**
- * Extract sdk info from from the API metadata
- * @param {SdkMetadata | undefined} metadata
- * @returns {SdkInfo | undefined}
- */
-function getSdkMetadataForEnvelopeHeader(metadata) {
-    if (!metadata || !metadata.sdk) {
-        return undefined;
-    }
-    return { name: metadata.sdk.name, version: metadata.sdk.version };
-}
-/**
- * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
- * Merge with existing data if any.
- *
- * @param {Event} event
- * @param {SdkInfo | undefined} sdkInfo
- * @returns {Event}
- */
-function enhanceEventWithSdkInfo(event, sdkInfo) {
-    if (!sdkInfo) {
-        return event;
-    }
-    event.sdk = event.sdk || {};
-    event.sdk.name = event.sdk.name || sdkInfo.name || 'unknown sdk';
-    event.sdk.version = event.sdk.version || sdkInfo.version || 'unknown sdk version';
-    event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];
-    event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];
-    return event;
-}
-/**
- *
- * @param {Event} event
- * @param {SdkInfo | undefined} sdkInfo
- * @param {string | undefined} tunnel
- * @param {DsnComponents} dsn
- * @returns {EventEnvelopeHeaders}
- */
-function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {
-    const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata['dynamicSamplingContext'];
-    return Object.assign(Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!tunnel && { dsn: dsnToString(dsn) })), (event.type === 'transaction' &&
-        dynamicSamplingContext && {
-        trace: dropUndefinedKeys(Object.assign({}, dynamicSamplingContext)),
-    }));
-}
-/**
- * Creates a profiling event envelope from a Sentry event. If profile does not pass
- * validation, returns null.
- * @param {Event}
- * @returns {Profile | null}
- */
-function createProfilingEventFromTransaction(event) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    if (event.type !== 'transaction') {
-        // createProfilingEventEnvelope should only be called for transactions,
-        // we type guard this behavior with isProfiledTransactionEvent.
-        throw new TypeError('Profiling events may only be attached to transactions, this should never occur.');
-    }
-    const rawProfile = event.sdkProcessingMetadata['profile'];
-    if (rawProfile === undefined || rawProfile === null) {
-        throw new TypeError(`Cannot construct profiling event envelope without a valid profile. Got ${rawProfile} instead.`);
-    }
-    if (!rawProfile.profile_id) {
-        throw new TypeError(`Cannot construct profiling event envelope without a valid profile id. Got ${rawProfile.profile_id} instead.`);
-    }
-    if (!isValidProfile(rawProfile)) {
-        return null;
-    }
-    return createProfilePayload(rawProfile, {
-        release: (_a = event.release) !== null && _a !== void 0 ? _a : '',
-        environment: (_b = event.environment) !== null && _b !== void 0 ? _b : '',
-        event_id: (_c = event.event_id) !== null && _c !== void 0 ? _c : '',
-        transaction: (_d = event.transaction) !== null && _d !== void 0 ? _d : '',
-        start_timestamp: event.start_timestamp ? event.start_timestamp * 1000 : Date.now(),
-        trace_id: (_g = (_f = (_e = event.contexts) === null || _e === void 0 ? void 0 : _e['trace']) === null || _f === void 0 ? void 0 : _f['trace_id']) !== null && _g !== void 0 ? _g : '',
-        profile_id: rawProfile.profile_id,
-    });
-}
 /**
  * Creates a profiling envelope item, if the profile does not pass validation, returns null.
  * @param {RawThreadCpuProfile}
@@ -2830,7 +3604,7 @@ function createProfilePayload(cpuProfile, { release, environment, event_id, tran
     // All profiles and transactions are rejected if this is the case and we want to
     // warn users that this is happening if they enable debug flag
     if (trace_id && trace_id.length !== 32) {
-        DEBUG_BUILD$1 && logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
+        DEBUG_BUILD && logger.log(`[Profiling] Invalid traceId: ${trace_id} on profiled event`);
     }
     const enrichedThreadProfile = enrichWithThreadInformation(cpuProfile);
     const profile = {
@@ -2870,54 +3644,6 @@ function createProfilePayload(cpuProfile, { release, environment, event_id, tran
     };
     return profile;
 }
-/**
- * Creates an envelope from a profiling event.
- * @param {Event} Profile
- * @param {DsnComponents} dsn
- * @param {SdkMetadata} metadata
- * @param {string|undefined} tunnel
- * @returns {Envelope|null}
- */
-function createProfilingEventEnvelope(event, dsn, metadata, tunnel) {
-    const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
-    enhanceEventWithSdkInfo(event, metadata && metadata.sdk);
-    const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);
-    const profile = createProfilingEventFromTransaction(event);
-    if (!profile) {
-        return null;
-    }
-    const envelopeItem = [
-        {
-            type: 'profile',
-        },
-        // @ts-expect-error profile is not part of EventItem yet
-        profile,
-    ];
-    return createEnvelope(envelopeHeaders, [envelopeItem]);
-}
-/**
- * Check if event metadata contains profile information
- * @param {Event}
- * @returns {boolean}
- */
-function isProfiledTransactionEvent(event) {
-    return !!(event.sdkProcessingMetadata && event.sdkProcessingMetadata['profile']);
-}
-/**
- * Due to how profiles are attached to event metadata, we may sometimes want to remove them to ensure
- * they are not processed by other Sentry integrations. This can be the case when we cannot construct a valid
- * profile from the data we have or some of the mechanisms to send the event (Hub, Transport etc) are not available to us.
- *
- * @param {Event | ProfiledEvent} event
- * @returns {Event}
- */
-function maybeRemoveProfileFromSdkMetadata(event) {
-    if (!isProfiledTransactionEvent(event)) {
-        return event;
-    }
-    delete event.sdkProcessingMetadata.profile;
-    return event;
-}
 /**
  * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
  * @param {unknown} rate
@@ -2926,7 +3652,7 @@ function maybeRemoveProfileFromSdkMetadata(event) {
 function isValidSampleRate(rate) {
     // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck
     if ((typeof rate !== 'number' && typeof rate !== 'boolean') || (typeof rate === 'number' && isNaN(rate))) {
-        DEBUG_BUILD$1 &&
+        DEBUG_BUILD &&
             logger.warn(`[Profiling] Invalid sample rate. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(rate)} of type ${JSON.stringify(typeof rate)}.`);
         return false;
     }
@@ -2936,7 +3662,7 @@ function isValidSampleRate(rate) {
     }
     // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false
     if (rate < 0 || rate > 1) {
-        DEBUG_BUILD$1 && logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
+        DEBUG_BUILD && logger.warn(`[Profiling] Invalid sample rate. Sample rate must be between 0 and 1. Got ${rate}.`);
         return false;
     }
     return true;
@@ -2948,7 +3674,7 @@ function isValidSampleRate(rate) {
  */
 function isValidProfile(profile) {
     if (profile.samples.length <= 1) {
-        DEBUG_BUILD$1 &&
+        DEBUG_BUILD &&
             // Log a warning if the profile has less than 2 samples so users can know why
             // they are not seeing any profiling data and we cant avoid the back and forth
             // of asking them to provide us with a dump of the profile data.
@@ -3071,40 +3797,44 @@ const MAX_PROFILE_DURATION_MS = 30 * 1000;
  * Takes a transaction and determines if it should be profiled or not. If it should be profiled, it returns the
  * profile_id, otherwise returns undefined. Takes care of setting profile context on transaction as well
  */
-function maybeProfileTransaction(client, transaction, customSamplingContext) {
+function maybeProfileSpan(client, span, customSamplingContext) {
     // profilesSampleRate is multiplied with tracesSampleRate to get the final sampling rate. We dont perform
-    // the actual multiplication to get the final rate, but we discard the profile if the transaction was sampled,
-    // so anything after this block from here is based on the transaction sampling.
-    // eslint-disable-next-line deprecation/deprecation
-    if (!transaction.sampled) {
+    // the actual multiplication to get the final rate, but we discard the profile if the span was sampled,
+    // so anything after this block from here is based on the span sampling.
+    if (!spanIsSampled(span)) {
         return;
     }
     // Client and options are required for profiling
     if (!client) {
-        DEBUG_BUILD$1 && logger.log('[Profiling] Profiling disabled, no client found.');
+        DEBUG_BUILD && logger.log('[Profiling] Profiling disabled, no client found.');
         return;
     }
     const options = client.getOptions();
     if (!options) {
-        DEBUG_BUILD$1 && logger.log('[Profiling] Profiling disabled, no options found.');
+        DEBUG_BUILD && logger.log('[Profiling] Profiling disabled, no options found.');
         return;
     }
     const profilesSampler = options.profilesSampler;
     let profilesSampleRate = options.profilesSampleRate;
     // Prefer sampler to sample rate if both are provided.
     if (typeof profilesSampler === 'function') {
-        // eslint-disable-next-line deprecation/deprecation
-        profilesSampleRate = profilesSampler(Object.assign({ transactionContext: transaction.toContext() }, customSamplingContext));
+        const { description: spanName = '<unknown>', data } = spanToJSON(span);
+        // We bail out early if that is not the case
+        const parentSampled = true;
+        profilesSampleRate = profilesSampler(Object.assign({ name: spanName, attributes: data, transactionContext: {
+                name: spanName,
+                parentSampled,
+            }, parentSampled }, customSamplingContext));
     }
     // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The
     // only valid values are booleans or numbers between 0 and 1.)
     if (!isValidSampleRate(profilesSampleRate)) {
-        DEBUG_BUILD$1 && logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
+        DEBUG_BUILD && logger.warn('[Profiling] Discarding profile because of invalid sample rate.');
         return;
     }
     // if the function returned 0 (or false), or if `profileSampleRate` is 0, it's a sign the profile should be dropped
     if (!profilesSampleRate) {
-        DEBUG_BUILD$1 &&
+        DEBUG_BUILD &&
             logger.log(`[Profiling] Discarding profile because ${typeof profilesSampler === 'function'
                 ? 'profileSampler returned 0 or false'
                 : 'a negative sampling decision was inherited or profileSampleRate is set to 0'}`);
@@ -3115,15 +3845,13 @@ function maybeProfileTransaction(client, transaction, customSamplingContext) {
     const sampled = profilesSampleRate === true ? true : Math.random() < profilesSampleRate;
     // Check if we should sample this profile
     if (!sampled) {
-        DEBUG_BUILD$1 &&
+        DEBUG_BUILD &&
             logger.log(`[Profiling] Discarding profile because it's not included in the random sample (sampling rate = ${Number(profilesSampleRate)})`);
         return;
     }
     const profile_id = uuid4();
     CpuProfilerBindings.startProfiling(profile_id);
-    DEBUG_BUILD$1 &&
-        // eslint-disable-next-line deprecation/deprecation
-        logger.log(`[Profiling] started profiling transaction: ${transaction.name}`);
+    DEBUG_BUILD && logger.log(`[Profiling] started profiling transaction: ${spanToJSON(span).description}`);
     // set transaction context - do this regardless if profiling fails down the line
     // so that we can still see the profile_id in the transaction context
     return profile_id;
@@ -3134,120 +3862,23 @@ function maybeProfileTransaction(client, transaction, customSamplingContext) {
  * @param profile_id
  * @returns
  */
-function stopTransactionProfile(transaction, profile_id) {
+function stopSpanProfile(span, profile_id) {
     // Should not happen, but satisfy the type checker and be safe regardless.
     if (!profile_id) {
         return null;
     }
     const profile = CpuProfilerBindings.stopProfiling(profile_id);
-    DEBUG_BUILD$1 &&
-        // eslint-disable-next-line deprecation/deprecation
-        logger.log(`[Profiling] stopped profiling of transaction: ${transaction.name}`);
-    // In case of an overlapping transaction, stopProfiling may return null and silently ignore the overlapping profile.
+    DEBUG_BUILD && logger.log(`[Profiling] stopped profiling of transaction: ${spanToJSON(span).description}`);
+    // In case of an overlapping span, stopProfiling may return null and silently ignore the overlapping profile.
     if (!profile) {
-        DEBUG_BUILD$1 &&
-            logger.log(
-            // eslint-disable-next-line deprecation/deprecation
-            `[Profiling] profiler returned null profile for: ${transaction.name}`, 'this may indicate an overlapping transaction or a call to stopProfiling with a profile title that was never started');
+        DEBUG_BUILD &&
+            logger.log(`[Profiling] profiler returned null profile for: ${spanToJSON(span).description}`, 'this may indicate an overlapping span or a call to stopProfiling with a profile title that was never started');
         return null;
     }
     // Assign profile_id to the profile
     profile.profile_id = profile_id;
     return profile;
 }
-/**
- * Wraps startTransaction and stopTransaction with profiling related logic.
- * startProfiling is called after the call to startTransaction in order to avoid our own code from
- * being profiled. Because of that same reason, stopProfiling is called before the call to stopTransaction.
- */
-function __PRIVATE__wrapStartTransactionWithProfiling(startTransaction) {
-    return function wrappedStartTransaction(transactionContext, customSamplingContext) {
-        const transaction = startTransaction.call(this, transactionContext, customSamplingContext);
-        // Client is required if we want to profile
-        // eslint-disable-next-line deprecation/deprecation
-        const client = this.getClient();
-        if (!client) {
-            return transaction;
-        }
-        // Check if we should profile this transaction. If a profile_id is returned, then profiling has been started.
-        const profile_id = maybeProfileTransaction(client, transaction, customSamplingContext);
-        if (!profile_id) {
-            return transaction;
-        }
-        // A couple of important things to note here:
-        // `CpuProfilerBindings.stopProfiling` will be scheduled to run in 30seconds in order to exceed max profile duration.
-        // Whichever of the two (transaction.finish/timeout) is first to run, the profiling will be stopped and the gathered profile
-        // will be processed when the original transaction is finished. Since onProfileHandler can be invoked multiple times in the
-        // event of an error or user mistake (calling transaction.finish multiple times), it is important that the behavior of onProfileHandler
-        // is idempotent as we do not want any timings or profiles to be overriden by the last call to onProfileHandler.
-        // After the original finish method is called, the event will be reported through the integration and delegated to transport.
-        let profile = null;
-        const options = client.getOptions();
-        // Not intended for external use, hence missing types, but we want to profile a couple of things at Sentry that
-        // currently exceed the default timeout set by the SDKs.
-        const maxProfileDurationMs = (options._experiments && options._experiments['maxProfileDurationMs']) || MAX_PROFILE_DURATION_MS;
-        // Enqueue a timeout to prevent profiles from running over max duration.
-        let maxDurationTimeoutID = global.setTimeout(() => {
-            DEBUG_BUILD$1 &&
-                // eslint-disable-next-line deprecation/deprecation
-                logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', transaction.name);
-            profile = stopTransactionProfile(transaction, profile_id);
-        }, maxProfileDurationMs);
-        // We need to reference the original finish call to avoid creating an infinite loop
-        // eslint-disable-next-line deprecation/deprecation
-        const originalFinish = transaction.finish.bind(transaction);
-        // Wrap the transaction finish method to stop profiling and set the profile on the transaction.
-        function profilingWrappedTransactionFinish() {
-            if (!profile_id) {
-                return originalFinish();
-            }
-            // We stop the handler first to ensure that the timeout is cleared and the profile is stopped.
-            if (maxDurationTimeoutID) {
-                global.clearTimeout(maxDurationTimeoutID);
-                maxDurationTimeoutID = undefined;
-            }
-            // onProfileHandler should always return the same profile even if this is called multiple times.
-            // Always call onProfileHandler to ensure stopProfiling is called and the timeout is cleared.
-            if (!profile) {
-                profile = stopTransactionProfile(transaction, profile_id);
-            }
-            // @ts-expect-error profile is not part of metadata
-            // eslint-disable-next-line deprecation/deprecation
-            transaction.setMetadata({ profile });
-            return originalFinish();
-        }
-        // eslint-disable-next-line deprecation/deprecation
-        transaction.finish = profilingWrappedTransactionFinish;
-        return transaction;
-    };
-}
-/**
- * Patches startTransaction and stopTransaction with profiling logic.
- * This is used by the SDK's that do not support event hooks.
- * @private
- */
-function _addProfilingExtensionMethods() {
-    const carrier = getMainCarrier();
-    if (!carrier.__SENTRY__) {
-        DEBUG_BUILD$1 && logger.log("[Profiling] Can't find main carrier, profiling won't work.");
-        return;
-    }
-    carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};
-    if (!carrier.__SENTRY__.extensions['startTransaction']) {
-        DEBUG_BUILD$1 && logger.log('[Profiling] startTransaction does not exists, profiling will not work.');
-        return;
-    }
-    DEBUG_BUILD$1 && logger.log('[Profiling] startTransaction exists, patching it with profiling functionality...');
-    carrier.__SENTRY__.extensions['startTransaction'] = __PRIVATE__wrapStartTransactionWithProfiling(
-    // This is patched by sentry/tracing, we are going to re-patch it...
-    carrier.__SENTRY__.extensions['startTransaction']);
-}
-/**
- * This patches the global object and injects the Profiling extensions methods
- */
-function addProfilingExtensionMethods() {
-    _addProfilingExtensionMethods();
-}
 
 const MAX_PROFILE_QUEUE_LENGTH = 50;
 const PROFILE_QUEUE = [];
@@ -3259,28 +3890,17 @@ function addToProfileQueue(profile) {
         PROFILE_QUEUE.shift();
     }
 }
-/**
- * We need this integration in order to send data to Sentry. We hook into the event processor
- * and inspect each event to see if it is a transaction event and if that transaction event
- * contains a profile on it's metadata. If that is the case, we create a profiling event envelope
- * and delete the profile from the transaction metadata.
- *
- * @deprecated Use `nodeProfilingIntegration` instead.
- */
-class ProfilingIntegration {
-    constructor() {
-        this.name = 'ProfilingIntegration';
-    }
-    /**
-     * @inheritDoc
-     */
-    setupOnce(addGlobalEventProcessor, getCurrentHub) {
-        this.getCurrentHub = getCurrentHub;
-        // eslint-disable-next-line deprecation/deprecation
-        const client = this.getCurrentHub().getClient();
-        if (client && typeof client.on === 'function') {
-            client.on('startTransaction', (transaction) => {
-                const profile_id = maybeProfileTransaction(client, transaction, undefined);
+/** Exported only for tests. */
+const _nodeProfilingIntegration = (() => {
+    return {
+        name: 'ProfilingIntegration',
+        setup(client) {
+            const spanToProfileIdMap = new WeakMap();
+            client.on('spanStart', span => {
+                if (span !== getRootSpan(span)) {
+                    return;
+                }
+                const profile_id = maybeProfileSpan(client, span, undefined);
                 if (profile_id) {
                     const options = client.getOptions();
                     // Not intended for external use, hence missing types, but we want to profile a couple of things at Sentry that
@@ -3293,32 +3913,26 @@ class ProfilingIntegration {
                     }
                     // Enqueue a timeout to prevent profiles from running over max duration.
                     PROFILE_TIMEOUTS[profile_id] = global.setTimeout(() => {
-                        DEBUG_BUILD$1 &&
-                            // eslint-disable-next-line deprecation/deprecation
-                            logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', transaction.name);
-                        const profile = stopTransactionProfile(transaction, profile_id);
+                        DEBUG_BUILD &&
+                            logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', spanToJSON(span).description);
+                        const profile = stopSpanProfile(span, profile_id);
                         if (profile) {
                             addToProfileQueue(profile);
                         }
                     }, maxProfileDurationMs);
-                    // eslint-disable-next-line deprecation/deprecation
-                    transaction.setContext('profile', { profile_id });
-                    // @ts-expect-error profile_id is not part of the metadata type
-                    // eslint-disable-next-line deprecation/deprecation
-                    transaction.setMetadata({ profile_id: profile_id });
+                    getCurrentScope().setContext('profile', { profile_id });
+                    spanToProfileIdMap.set(span, profile_id);
                 }
             });
-            client.on('finishTransaction', transaction => {
-                // @ts-expect-error profile_id is not part of the metadata type
-                // eslint-disable-next-line deprecation/deprecation
-                const profile_id = transaction.metadata.profile_id;
-                if (profile_id && typeof profile_id === 'string') {
+            client.on('spanEnd', span => {
+                const profile_id = spanToProfileIdMap.get(span);
+                if (profile_id) {
                     if (PROFILE_TIMEOUTS[profile_id]) {
                         global.clearTimeout(PROFILE_TIMEOUTS[profile_id]);
                         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                         delete PROFILE_TIMEOUTS[profile_id];
                     }
-                    const profile = stopTransactionProfile(transaction, profile_id);
+                    const profile = stopSpanProfile(span, profile_id);
                     if (profile) {
                         addToProfileQueue(profile);
                     }
@@ -3343,18 +3957,17 @@ class ProfilingIntegration {
                     }
                     // Remove the profile from the transaction context before sending, relay will take care of the rest.
                     if (profileContext) {
-                        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                         (_b = profiledTransaction.contexts) === null || _b === void 0 ? true : delete _b['profile'];
                     }
                     // We need to find both a profile and a transaction event for the same profile_id.
                     const profileIndex = PROFILE_QUEUE.findIndex(p => p.profile_id === profile_id);
                     if (profileIndex === -1) {
-                        DEBUG_BUILD$1 && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+                        DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
                         continue;
                     }
                     const cpuProfile = PROFILE_QUEUE[profileIndex];
                     if (!cpuProfile) {
-                        DEBUG_BUILD$1 && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
+                        DEBUG_BUILD && logger.log(`[Profiling] Could not retrieve profile for transaction: ${profile_id}`);
                         continue;
                     }
                     // Remove the profile from the queue.
@@ -3376,70 +3989,16 @@ class ProfilingIntegration {
                 }
                 addProfilesToEnvelope(envelope, profilesToAddToEnvelope);
             });
-        }
-        else {
-            // Patch the carrier methods and add the event processor.
-            addProfilingExtensionMethods();
-            addGlobalEventProcessor(this.handleGlobalEvent.bind(this));
-        }
-    }
-    /**
-     * @inheritDoc
-     */
-    handleGlobalEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.getCurrentHub === undefined) {
-                return maybeRemoveProfileFromSdkMetadata(event);
-            }
-            if (isProfiledTransactionEvent(event)) {
-                // Client, Dsn and Transport are all required to be able to send the profiling event to Sentry.
-                // If either of them is not available, we remove the profile from the transaction event.
-                // and forward it to the next event processor.
-                const hub = this.getCurrentHub();
-                // eslint-disable-next-line deprecation/deprecation
-                const client = hub.getClient();
-                if (!client) {
-                    DEBUG_BUILD$1 &&
-                        logger.log('[Profiling] getClient did not return a Client, removing profile from event and forwarding to next event processors.');
-                    return maybeRemoveProfileFromSdkMetadata(event);
-                }
-                const dsn = client.getDsn();
-                if (!dsn) {
-                    DEBUG_BUILD$1 &&
-                        logger.log('[Profiling] getDsn did not return a Dsn, removing profile from event and forwarding to next event processors.');
-                    return maybeRemoveProfileFromSdkMetadata(event);
-                }
-                const transport = client.getTransport();
-                if (!transport) {
-                    DEBUG_BUILD$1 &&
-                        logger.log('[Profiling] getTransport did not return a Transport, removing profile from event and forwarding to next event processors.');
-                    return maybeRemoveProfileFromSdkMetadata(event);
-                }
-                // If all required components are available, we construct a profiling event envelope and send it to Sentry.
-                DEBUG_BUILD$1 && logger.log('[Profiling] Preparing envelope and sending a profiling event');
-                const envelope = createProfilingEventEnvelope(event, dsn);
-                if (envelope) {
-                    // Fire and forget, we don't want to block the main event processing flow.
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    transport.send(envelope);
-                }
-            }
-            // Ensure sdkProcessingMetadata["profile"] is removed from the event before forwarding it to the next event processor.
-            return maybeRemoveProfileFromSdkMetadata(event);
-        });
-    }
-}
+        },
+    };
+});
 /**
  * We need this integration in order to send data to Sentry. We hook into the event processor
  * and inspect each event to see if it is a transaction event and if that transaction event
  * contains a profile on it's metadata. If that is the case, we create a profiling event envelope
  * and delete the profile from the transaction metadata.
  */
-const nodeProfilingIntegration = (() => {
-    // eslint-disable-next-line deprecation/deprecation
-    return new ProfilingIntegration();
-});
+const nodeProfilingIntegration = defineIntegration(_nodeProfilingIntegration);
 
-exports.ProfilingIntegration = ProfilingIntegration;
 exports.nodeProfilingIntegration = nodeProfilingIntegration;
 //# sourceMappingURL=index.js.map