@sentry/profiling-node 8.0.0-alpha.2 → 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,153 @@ 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.
+ *
+ * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+ * function and added to the `__SENTRY__` object.
+ *
+ * @param name name of the global singleton on __SENTRY__
+ * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+ * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+ * @returns the singleton
+ */
+function getGlobalSingleton(name, creator, obj) {
+  const gbl = (obj || GLOBAL_OBJ) ;
+  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
+  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  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.
  *
@@ -202,21 +424,97 @@ function makeLogger() {
 
 const logger = makeLogger();
 
+const defaultFunctionName = '<anonymous>';
+
 /**
- * Renders the string representation of this Dsn.
+ * 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;
+  }
+}
+
+/**
+ * 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 {};
+  }
 }
 
 /**
@@ -304,28 +602,693 @@ function uuid4() {
     if (crypto && crypto.randomUUID) {
       return crypto.randomUUID().replace(/-/g, '');
     }
-    if (crypto && crypto.getRandomValues) {
-      getRandomByte = () => {
-        // crypto.getRandomValues might return undefined instead of the typed array
-        // in old Chromium versions (e.g. 23.0.1235.0 (151422))
-        // However, `typedArray` is still filled in-place.
-        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray
-        const typedArray = new Uint8Array(1);
-        crypto.getRandomValues(typedArray);
-        return typedArray[0];
+    if (crypto && crypto.getRandomValues) {
+      getRandomByte = () => {
+        // crypto.getRandomValues might return undefined instead of the typed array
+        // in old Chromium versions (e.g. 23.0.1235.0 (151422))
+        // However, `typedArray` is still filled in-place.
+        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray
+        const typedArray = new Uint8Array(1);
+        crypto.getRandomValues(typedArray);
+        return typedArray[0];
+      };
+    }
+  } catch (_) {
+    // some runtimes can crash invoking crypto
+    // https://github.com/getsentry/sentry-javascript/issues/8935
+  }
+
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
+  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
+    // eslint-disable-next-line no-bitwise
+    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
+  );
+}
+
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Helper to decycle json objects
+ */
+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;
+  }
+
+  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];
+}
+
+/**
+ * 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})` };
+  }
+}
+
+/**
+ * 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;
+
+  // 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 ;
+  }
+
+  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;
+  }
+
+  // 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 ;
+  }
+
+  // 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 ', '');
+  }
+
+  // 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 ~]';
+  }
+
+  // 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)
+    }
+  }
+
+  // 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++;
+  }
+
+  // Once we've visited all the branches, remove the parent from memo storage
+  unmemoize(value);
+
+  // Return accumulated values
+  return normalized;
+}
+
+/* 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 (key === 'domainEmitter') {
+      return '[DomainEmitter]';
+    }
+
+    // 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.
+
+    if (typeof global !== 'undefined' && value === global) {
+      return '[Global]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof window !== 'undefined' && value === window) {
+      return '[Window]';
+    }
+
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof document !== 'undefined' && value === document) {
+      return '[Document]';
+    }
+
+    if (isVueViewModel(value)) {
+      return '[VueViewModel]';
+    }
+
+    // React's SyntheticEvent thingy
+    if (isSyntheticEvent(value)) {
+      return '[SyntheticEvent]';
+    }
+
+    if (typeof value === 'number' && value !== value) {
+      return '[NaN]';
+    }
+
+    if (typeof value === 'function') {
+      return `[Function: ${getFunctionName(value)}]`;
+    }
+
+    if (typeof value === 'symbol') {
+      return `[${String(value)}]`;
+    }
+
+    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+    if (typeof value === 'bigint') {
+      return `[BigInt: ${String(value)}]`;
+    }
+
+    // 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 */
+
+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,
       };
     }
-  } catch (_) {
-    // some runtimes can crash invoking crypto
-    // https://github.com/getsentry/sentry-javascript/issues/8935
   }
 
-  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
-  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'
-  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>
-    // eslint-disable-next-line no-bitwise
-    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),
-  );
+  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;
@@ -433,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)
@@ -466,6 +1420,13 @@ function forEachEnvelopeItem(
   return false;
 }
 
+/**
+ * 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.
+ */
+const DEBUG_BUILD$1 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
+
 /**
  * @private Private API with no semver guarantees!
  *
@@ -495,13 +1456,6 @@ function getSentryCarrier(carrier) {
   return carrier.__SENTRY__;
 }
 
-/**
- * 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.
- */
-const DEBUG_BUILD$1 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
-
 const DEFAULT_ENVIRONMENT = 'production';
 
 /**
@@ -700,6 +1654,9 @@ class Scope  {
 
   /**
    * 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 */
@@ -735,7 +1692,7 @@ class Scope  {
   }
 
   /**
-   * Clone this scope instance.
+   * @inheritDoc
    */
    clone() {
     const newScope = new Scope();
@@ -759,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 ;
   }
 
   /**
-   * Add internal on change listener. Used for sub SDKs that need to store the scope.
-   * @hidden
+   * @inheritDoc
    */
    addScopeListener(callback) {
     this._scopeListeners.push(callback);
@@ -893,8 +1849,7 @@ class Scope  {
   }
 
   /**
-   * Sets the transaction name on the scope for future events.
-   * @deprecated Use extra or tags instead.
+   * @inheritDoc
    */
    setTransactionName(name) {
     this._transactionName = name;
@@ -1156,7 +2111,7 @@ class Scope  {
   }
 
   /**
-   * Add data which will be accessible during event processing but won't get sent to Sentry
+   * @inheritDoc
    */
    setSDKProcessingMetadata(newData) {
     this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };
@@ -1180,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();
@@ -1211,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();
@@ -1244,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();
@@ -1287,7 +2229,7 @@ function generatePropagationContext() {
   };
 }
 
-const SDK_VERSION = '8.0.0-alpha.2';
+const SDK_VERSION = '8.0.0-alpha.3';
 
 /**
  * API compatibility version of this hub.
@@ -1303,7 +2245,7 @@ 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.
@@ -1599,7 +2541,7 @@ class Hub  {
 
     if (!client) return;
 
-    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =
+    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS$1 } =
       (client.getOptions && client.getOptions()) || {};
 
     if (maxBreadcrumbs <= 0) return;
@@ -1690,46 +2632,6 @@ class Hub  {
     }
   }
 
-  /**
-   * 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$1 && !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
    *
@@ -1857,128 +2759,635 @@ function getCurrentHub() {
   return acs.getCurrentHub() || getGlobalHub();
 }
 
-let defaultCurrentScope;
-let defaultIsolationScope;
+/** 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();
 
-/** Get the default current scope. */
-function getDefaultCurrentScope() {
-  if (!defaultCurrentScope) {
-    defaultCurrentScope = new Scope();
+function ensureMetadataStacksAreParsed(parser) {
+  if (!GLOBAL_OBJ._sentryModuleMetadata) {
+    return;
   }
 
-  return defaultCurrentScope;
-}
+  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {
+    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];
 
-/** Get the default isolation scope. */
-function getDefaultIsolationScope() {
-  if (!defaultIsolationScope) {
-    defaultIsolationScope = new Scope();
+    if (parsedStacks.has(stack)) {
+      continue;
+    }
+
+    // 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;
+      }
+    }
   }
+}
 
-  return defaultIsolationScope;
+/**
+ * Retrieve metadata for a specific JavaScript file URL.
+ *
+ * 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);
 }
 
 /**
- * Get the global hub.
- * This will be removed during the v8 cycle and is only here to make migration easier.
+ * Adds metadata to stack frames.
+ *
+ * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
  */
-function getGlobalHub() {
-  const registry = getMainCarrier();
-  const sentry = getSentryCarrier(registry) ;
+function addMetadataToStackFrames(parser, event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
 
-  // If there's no hub, or its an old API, assign a new one
-  if (sentry.hub) {
-    return sentry.hub;
-  }
+      for (const frame of exception.stacktrace.frames || []) {
+        if (!frame.filename) {
+          continue;
+        }
 
-  // eslint-disable-next-line deprecation/deprecation
-  sentry.hub = new Hub(undefined, getDefaultCurrentScope(), getDefaultIsolationScope());
-  return sentry.hub;
+        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.
+  }
 }
 
 /**
- * Get the current async context strategy.
- * If none has been setup, the default will be used.
+ * Strips metadata from stack frames.
  */
-function getAsyncContextStrategy(carrier) {
-  const sentry = getSentryCarrier(carrier);
+function stripMetadataFromStackFrames(event) {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    event.exception.values.forEach(exception => {
+      if (!exception.stacktrace) {
+        return;
+      }
 
-  if (sentry.acs) {
-    return sentry.acs;
+      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.
   }
-
-  // Otherwise, use the default one
-  return getHubStackAsyncContextStrategy();
 }
 
-function withScope(callback) {
-  // eslint-disable-next-line deprecation/deprecation
-  return getGlobalHub().withScope(callback);
-}
+const INTEGRATION_NAME$a = 'ModuleMetadata';
 
-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);
-  });
-}
+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;
+            }
+          }
+        });
+      });
+    },
 
-function withIsolationScope(callback) {
-  // eslint-disable-next-line deprecation/deprecation
-  return getGlobalHub().withScope(() => {
-    // eslint-disable-next-line deprecation/deprecation
-    return callback(getGlobalHub().getIsolationScope());
-  });
-}
+    processEvent(event, _hint, client) {
+      const stackParser = client.getOptions().stackParser;
+      addMetadataToStackFrames(stackParser, event);
+      return event;
+    },
+  };
+}) ;
+
+const moduleMetadataIntegration = defineIntegration(_moduleMetadataIntegration);
+
+/**
+ * Adds module metadata to stack frames.
+ *
+ * Metadata can be injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
+ *
+ * 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 ),
+            },
+    },
+  };
 
-/* eslint-disable deprecation/deprecation */
-function getHubStackAsyncContextStrategy() {
   return {
-    getCurrentHub: getGlobalHub,
-    withIsolationScope,
-    withScope,
-    withSetScope,
-    withSetIsolationScope: (_isolationScope, callback) => {
-      return withIsolationScope(callback);
+    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;
     },
-    getCurrentScope: () => getGlobalHub().getScope(),
-    getIsolationScope: () => getGlobalHub().getIsolationScope(),
   };
-}
+}) ;
+
+const requestDataIntegration = defineIntegration(_requestDataIntegration);
 
 /**
- * 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.
+ * 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 spanToJSON(span) {
-  if (spanIsSentrySpan(span)) {
-    return span.getSpanJSON();
+// eslint-disable-next-line deprecation/deprecation
+convertIntegrationFnToClass(INTEGRATION_NAME$9, requestDataIntegration)
+
+;
+
+/** 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;
+
+  const requestIncludeKeys = ['method'];
+  for (const [key, value] of Object.entries(requestOptions)) {
+    if (value) {
+      requestIncludeKeys.push(key);
+    }
   }
 
-  // Fallback: We also check for `.toJSON()` here...
-  if (typeof (span ).toJSON === 'function') {
-    return (span ).toJSON();
+  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;
   }
 
-  // TODO: Also handle OTEL spans here!
+  return {
+    include: {
+      ip,
+      user: addReqDataUserOpt,
+      request: requestIncludeKeys.length !== 0 ? requestIncludeKeys : undefined,
+      transaction: transactionNamingScheme,
+    },
+  };
+}
 
-  return {};
+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;
+  }
 }
 
+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);
+    },
+  };
+}) ;
+
 /**
- * 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.
+ * Patch toString calls to return proper name for wrapped functions.
+ *
+ * ```js
+ * Sentry.init({
+ *   integrations: [
+ *     functionToStringIntegration(),
+ *   ],
+ * });
+ * ```
  */
-function spanIsSentrySpan(span) {
-  return typeof (span ).getSpanJSON === 'function';
-}
+const functionToStringIntegration = defineIntegration(_functionToStringIntegration);
+
+/**
+ * Patch toString calls to return proper name for wrapped functions.
+ *
+ * @deprecated Use `functionToStringIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+convertIntegrationFnToClass(
+  INTEGRATION_NAME$8,
+  functionToStringIntegration,
+) ;
 
 /**
  * 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.
@@ -2118,7 +3527,6 @@ 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.
 const THREAD_ID_STRING = String(worker_threads.threadId);
@@ -2164,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}
@@ -2314,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
@@ -2515,12 +3797,11 @@ 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
@@ -2537,8 +3818,13 @@ function maybeProfileTransaction(client, transaction, customSamplingContext) {
     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.)
@@ -2565,7 +3851,7 @@ function maybeProfileTransaction(client, transaction, customSamplingContext) {
     }
     const profile_id = uuid4();
     CpuProfilerBindings.startProfiling(profile_id);
-    DEBUG_BUILD && logger.log(`[Profiling] started profiling transaction: ${spanToJSON(transaction).description}`);
+    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;
@@ -2576,113 +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 && logger.log(`[Profiling] stopped profiling of transaction: ${spanToJSON(transaction).description}`);
-    // 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 &&
-            logger.log(`[Profiling] profiler returned null profile for: ${spanToJSON(transaction).description}`, 'this may indicate an overlapping transaction or a call to stopProfiling with a profile title that was never started');
+            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 &&
-                logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', spanToJSON(transaction).description);
-            profile = stopTransactionProfile(transaction, profile_id);
-        }, maxProfileDurationMs);
-        // We need to reference the original finish call to avoid creating an infinite loop
-        const originalEnd = transaction.end.bind(transaction);
-        // Wrap the transaction finish method to stop profiling and set the profile on the transaction.
-        function profilingWrappedTransactionEnd() {
-            if (!profile_id) {
-                return originalEnd();
-            }
-            // 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 originalEnd();
-        }
-        transaction.end = profilingWrappedTransactionEnd;
-        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 && 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 && logger.log('[Profiling] startTransaction does not exists, profiling will not work.');
-        return;
-    }
-    DEBUG_BUILD && 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 = [];
@@ -2694,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
@@ -2729,30 +3914,25 @@ class ProfilingIntegration {
                     // Enqueue a timeout to prevent profiles from running over max duration.
                     PROFILE_TIMEOUTS[profile_id] = global.setTimeout(() => {
                         DEBUG_BUILD &&
-                            logger.log('[Profiling] max profile duration elapsed, stopping profiling for:', spanToJSON(transaction).description);
-                        const profile = stopTransactionProfile(transaction, profile_id);
+                            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);
                     }
@@ -2809,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 &&
-                        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 &&
-                        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 &&
-                        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 && 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