@sentry/node 8.0.0-alpha.2 → 8.0.0-alpha.3

package/cjs/index.js

@@ -1,84 +1,3619 @@
+var {
+  _optionalChainDelete,
+  _nullishCoalesce,
+  _optionalChain
+} = require('@sentry/utils');
+
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const http = require('./integrations/http.js');
-const nodeFetch = require('./integrations/node-fetch.js');
-const console = require('./integrations/console.js');
-const context = require('./integrations/context.js');
-const contextlines = require('./integrations/contextlines.js');
-const index = require('./integrations/local-variables/index.js');
-const modules = require('./integrations/modules.js');
-const onuncaughtexception = require('./integrations/onuncaughtexception.js');
-const onunhandledrejection = require('./integrations/onunhandledrejection.js');
-const index$1 = require('./integrations/anr/index.js');
-const express = require('./integrations/tracing/express.js');
-const fastify = require('./integrations/tracing/fastify.js');
-const graphql = require('./integrations/tracing/graphql.js');
-const mongo = require('./integrations/tracing/mongo.js');
-const mongoose = require('./integrations/tracing/mongoose.js');
-const mysql = require('./integrations/tracing/mysql.js');
-const mysql2 = require('./integrations/tracing/mysql2.js');
-const nest = require('./integrations/tracing/nest.js');
-const postgres = require('./integrations/tracing/postgres.js');
-const prisma = require('./integrations/tracing/prisma.js');
-const index$2 = require('./integrations/tracing/hapi/index.js');
-const init = require('./sdk/init.js');
-const index$3 = require('./integrations/tracing/index.js');
-const api = require('./sdk/api.js');
-const module$1 = require('./utils/module.js');
-const http$1 = require('./transports/http.js');
-const client = require('./sdk/client.js');
-const hub = require('./sdk/hub.js');
-const index$4 = require('./cron/index.js');
-const opentelemetry = require('@sentry/opentelemetry');
-const utils = require('@sentry/utils');
-const core = require('@sentry/core');
+const api = require('@opentelemetry/api');
+const instrumentation = require('@opentelemetry/instrumentation');
+const instrumentationHttp = require('@opentelemetry/instrumentation-http');
+const core = require('@sentry/core');
+const opentelemetry = require('@sentry/opentelemetry');
+const utils = require('@sentry/utils');
+const util = require('util');
+const child_process = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const inspector = require('inspector');
+const worker_threads = require('worker_threads');
+const instrumentationExpress = require('@opentelemetry/instrumentation-express');
+const instrumentationFastify = require('@opentelemetry/instrumentation-fastify');
+const instrumentationGraphql = require('@opentelemetry/instrumentation-graphql');
+const instrumentationMongodb = require('@opentelemetry/instrumentation-mongodb');
+const instrumentationMongoose = require('@opentelemetry/instrumentation-mongoose');
+const instrumentationMysql = require('@opentelemetry/instrumentation-mysql');
+const instrumentationMysql2 = require('@opentelemetry/instrumentation-mysql2');
+const instrumentationNestjsCore = require('@opentelemetry/instrumentation-nestjs-core');
+const instrumentationPg = require('@opentelemetry/instrumentation-pg');
+const prismaInstrumentation = require('@prisma/instrumentation');
+const instrumentationHapi = require('@opentelemetry/instrumentation-hapi');
+const http = require('http');
+const instrumentationKoa = require('@opentelemetry/instrumentation-koa');
+const http$1 = require('node:http');
+const https = require('node:https');
+const stream = require('stream');
+const zlib = require('zlib');
+const net = require('net');
+const tls = require('tls');
+const resources = require('@opentelemetry/resources');
+const sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+const semanticConventions = require('@opentelemetry/semantic-conventions');
+const contextAsyncHooks = require('@opentelemetry/context-async-hooks');
+
+/**
+ * Update the active isolation scope.
+ * Should be used with caution!
+ */
+function setIsolationScope(isolationScope) {
+  const scopes = opentelemetry.getScopesFromContext(api.context.active());
+  if (scopes) {
+    scopes.isolationScope = isolationScope;
+  }
+}
+
+/** Adds an origin to an OTEL Span. */
+function addOriginToSpan(span, origin) {
+  span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, origin);
+}
+
+/** Build a full URL from request options. */
+function getRequestUrl(requestOptions) {
+  const protocol = requestOptions.protocol || '';
+  const hostname = requestOptions.hostname || requestOptions.host || '';
+  // Don't log standard :80 (http) and :443 (https) ports to reduce the noise
+  // Also don't add port if the hostname already includes a port
+  const port =
+    !requestOptions.port || requestOptions.port === 80 || requestOptions.port === 443 || /^(.*):(\d+)$/.test(hostname)
+      ? ''
+      : `:${requestOptions.port}`;
+  const path = requestOptions.path ? requestOptions.path : '/';
+  return `${protocol}//${hostname}${port}${path}`;
+}
+
+function _optionalChain$8(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+const _httpIntegration = ((options = {}) => {
+  const _breadcrumbs = typeof options.breadcrumbs === 'undefined' ? true : options.breadcrumbs;
+  const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;
+  const _ignoreIncomingRequests = options.ignoreIncomingRequests;
+
+  return {
+    name: 'Http',
+    setupOnce() {
+      const instrumentations = [
+        new instrumentationHttp.HttpInstrumentation({
+          ignoreOutgoingRequestHook: request => {
+            const url = getRequestUrl(request);
+
+            if (!url) {
+              return false;
+            }
+
+            if (core.isSentryRequestUrl(url, opentelemetry.getClient())) {
+              return true;
+            }
+
+            if (_ignoreOutgoingRequests && _ignoreOutgoingRequests(url)) {
+              return true;
+            }
+
+            return false;
+          },
+
+          ignoreIncomingRequestHook: request => {
+            const url = getRequestUrl(request);
+
+            const method = _optionalChain$8([request, 'access', _ => _.method, 'optionalAccess', _2 => _2.toUpperCase, 'call', _3 => _3()]);
+            // We do not capture OPTIONS/HEAD requests as transactions
+            if (method === 'OPTIONS' || method === 'HEAD') {
+              return true;
+            }
+
+            if (_ignoreIncomingRequests && _ignoreIncomingRequests(url)) {
+              return true;
+            }
+
+            return false;
+          },
+
+          requireParentforOutgoingSpans: true,
+          requireParentforIncomingSpans: false,
+          requestHook: (span, req) => {
+            _updateSpan$1(span);
+
+            // Update the isolation scope, isolate this request
+            if (opentelemetry.getSpanKind(span) === api.SpanKind.SERVER) {
+              const isolationScope = core.getIsolationScope().clone();
+              isolationScope.setSDKProcessingMetadata({ request: req });
+
+              const client = opentelemetry.getClient();
+              if (client && client.getOptions().autoSessionTracking) {
+                isolationScope.setRequestSession({ status: 'ok' });
+              }
+              setIsolationScope(isolationScope);
+            }
+          },
+          responseHook: (span, res) => {
+            if (_breadcrumbs) {
+              _addRequestBreadcrumb$1(span, res);
+            }
+
+            const client = opentelemetry.getClient();
+            if (client && client.getOptions().autoSessionTracking) {
+              setImmediate(() => {
+                client['_captureRequestSession']();
+              });
+            }
+          },
+        }),
+      ];
+
+      instrumentation.registerInstrumentations({
+        instrumentations,
+      });
+    },
+  };
+}) ;
+
+/**
+ * The http integration instruments Node's internal http and https modules.
+ * It creates breadcrumbs and spans for outgoing HTTP requests which will be attached to the currently active span.
+ */
+const httpIntegration = core.defineIntegration(_httpIntegration);
+
+/** Update the span with data we need. */
+function _updateSpan$1(span) {
+  addOriginToSpan(span, 'auto.http.otel.http');
+}
+
+/** Add a breadcrumb for outgoing requests. */
+function _addRequestBreadcrumb$1(span, response) {
+  if (opentelemetry.getSpanKind(span) !== api.SpanKind.CLIENT) {
+    return;
+  }
+
+  const data = opentelemetry._INTERNAL.getRequestSpanData(span);
+  core.addBreadcrumb(
+    {
+      category: 'http',
+      data: {
+        status_code: response.statusCode,
+        ...data,
+      },
+      type: 'http',
+    },
+    {
+      event: 'response',
+      // TODO FN: Do we need access to `request` here?
+      // If we do, we'll have to use the `applyCustomAttributesOnSpan` hook instead,
+      // but this has worse context semantics than request/responseHook.
+      response,
+    },
+  );
+}
+
+const NODE_VERSION = utils.parseSemver(process.versions.node)
+
+;
+const NODE_MAJOR = NODE_VERSION.major || 0;
+
+const _nativeNodeFetchIntegration = ((options = {}) => {
+  const _breadcrumbs = typeof options.breadcrumbs === 'undefined' ? true : options.breadcrumbs;
+  const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;
+
+  async function getInstrumentation() {
+    // Only add NodeFetch if Node >= 16, as previous versions do not support it
+    if (NODE_MAJOR < 16) {
+      return;
+    }
+
+    try {
+      const pkg = await import('opentelemetry-instrumentation-fetch-node');
+      return [
+        new pkg.FetchInstrumentation({
+          ignoreRequestHook: (request) => {
+            const url = request.origin;
+            return _ignoreOutgoingRequests && url && _ignoreOutgoingRequests(url);
+          },
+          onRequest: ({ span }) => {
+            _updateSpan(span);
+
+            if (_breadcrumbs) {
+              _addRequestBreadcrumb(span);
+            }
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } ),
+      ];
+    } catch (error) {
+      // Could not load instrumentation
+    }
+  }
+
+  return {
+    name: 'NodeFetch',
+    setupOnce() {
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      getInstrumentation().then(instrumentations => {
+        if (instrumentations) {
+          instrumentation.registerInstrumentations({
+            instrumentations,
+          });
+        }
+      });
+    },
+  };
+}) ;
+
+const nativeNodeFetchIntegration = core.defineIntegration(_nativeNodeFetchIntegration);
+
+/** Update the span with data we need. */
+function _updateSpan(span) {
+  addOriginToSpan(span, 'auto.http.otel.node_fetch');
+}
+
+/** Add a breadcrumb for outgoing requests. */
+function _addRequestBreadcrumb(span) {
+  if (opentelemetry.getSpanKind(span) !== api.SpanKind.CLIENT) {
+    return;
+  }
+
+  const data = opentelemetry._INTERNAL.getRequestSpanData(span);
+  core.addBreadcrumb({
+    category: 'http',
+    data: {
+      ...data,
+    },
+    type: 'http',
+  });
+}
+
+const INTEGRATION_NAME$8 = 'Console';
+
+const _consoleIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME$8,
+    setup(client) {
+      utils.addConsoleInstrumentationHandler(({ args, level }) => {
+        if (core.getClient() !== client) {
+          return;
+        }
+
+        core.addBreadcrumb(
+          {
+            category: 'console',
+            level: utils.severityLevelFromString(level),
+            message: util.format.apply(undefined, args),
+          },
+          {
+            input: [...args],
+            level,
+          },
+        );
+      });
+    },
+  };
+}) ;
+
+/**
+ * Capture console logs as breadcrumbs.
+ */
+const consoleIntegration = core.defineIntegration(_consoleIntegration);
+
+function _optionalChain$7(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+const readFileAsync$1 = util.promisify(fs.readFile);
+const readDirAsync = util.promisify(fs.readdir);
+
+const INTEGRATION_NAME$7 = 'Context';
+
+const _nodeContextIntegration = ((options = {}) => {
+  let cachedContext;
+
+  const _options = {
+    app: true,
+    os: true,
+    device: true,
+    culture: true,
+    cloudResource: true,
+    ...options,
+  };
+
+  /** Add contexts to the event. Caches the context so we only look it up once. */
+  async function addContext(event) {
+    if (cachedContext === undefined) {
+      cachedContext = _getContexts();
+    }
+
+    const updatedContext = _updateContext(await cachedContext);
+
+    event.contexts = {
+      ...event.contexts,
+      app: { ...updatedContext.app, ..._optionalChain$7([event, 'access', _ => _.contexts, 'optionalAccess', _2 => _2.app]) },
+      os: { ...updatedContext.os, ..._optionalChain$7([event, 'access', _3 => _3.contexts, 'optionalAccess', _4 => _4.os]) },
+      device: { ...updatedContext.device, ..._optionalChain$7([event, 'access', _5 => _5.contexts, 'optionalAccess', _6 => _6.device]) },
+      culture: { ...updatedContext.culture, ..._optionalChain$7([event, 'access', _7 => _7.contexts, 'optionalAccess', _8 => _8.culture]) },
+      cloud_resource: { ...updatedContext.cloud_resource, ..._optionalChain$7([event, 'access', _9 => _9.contexts, 'optionalAccess', _10 => _10.cloud_resource]) },
+    };
+
+    return event;
+  }
+
+  /** Get the contexts from node. */
+  async function _getContexts() {
+    const contexts = {};
+
+    if (_options.os) {
+      contexts.os = await getOsContext();
+    }
+
+    if (_options.app) {
+      contexts.app = getAppContext();
+    }
+
+    if (_options.device) {
+      contexts.device = getDeviceContext(_options.device);
+    }
+
+    if (_options.culture) {
+      const culture = getCultureContext();
+
+      if (culture) {
+        contexts.culture = culture;
+      }
+    }
+
+    if (_options.cloudResource) {
+      contexts.cloud_resource = getCloudResourceContext();
+    }
+
+    return contexts;
+  }
+
+  return {
+    name: INTEGRATION_NAME$7,
+    processEvent(event) {
+      return addContext(event);
+    },
+  };
+}) ;
+
+/**
+ * Capture context about the environment and the device that the client is running on, to events.
+ */
+const nodeContextIntegration = core.defineIntegration(_nodeContextIntegration);
+
+/**
+ * Updates the context with dynamic values that can change
+ */
+function _updateContext(contexts) {
+  // Only update properties if they exist
+  if (_optionalChain$7([contexts, 'optionalAccess', _11 => _11.app, 'optionalAccess', _12 => _12.app_memory])) {
+    contexts.app.app_memory = process.memoryUsage().rss;
+  }
+
+  if (_optionalChain$7([contexts, 'optionalAccess', _13 => _13.device, 'optionalAccess', _14 => _14.free_memory])) {
+    contexts.device.free_memory = os.freemem();
+  }
+
+  return contexts;
+}
+
+/**
+ * Returns the operating system context.
+ *
+ * Based on the current platform, this uses a different strategy to provide the
+ * most accurate OS information. Since this might involve spawning subprocesses
+ * or accessing the file system, this should only be executed lazily and cached.
+ *
+ *  - On macOS (Darwin), this will execute the `sw_vers` utility. The context
+ *    has a `name`, `version`, `build` and `kernel_version` set.
+ *  - On Linux, this will try to load a distribution release from `/etc` and set
+ *    the `name`, `version` and `kernel_version` fields.
+ *  - On all other platforms, only a `name` and `version` will be returned. Note
+ *    that `version` might actually be the kernel version.
+ */
+async function getOsContext() {
+  const platformId = os.platform();
+  switch (platformId) {
+    case 'darwin':
+      return getDarwinInfo();
+    case 'linux':
+      return getLinuxInfo();
+    default:
+      return {
+        name: PLATFORM_NAMES[platformId] || platformId,
+        version: os.release(),
+      };
+  }
+}
+
+function getCultureContext() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    if (typeof (process.versions ).icu !== 'string') {
+      // Node was built without ICU support
+      return;
+    }
+
+    // Check that node was built with full Intl support. Its possible it was built without support for non-English
+    // locales which will make resolvedOptions inaccurate
+    //
+    // https://nodejs.org/api/intl.html#detecting-internationalization-support
+    const january = new Date(9e8);
+    const spanish = new Intl.DateTimeFormat('es', { month: 'long' });
+    if (spanish.format(january) === 'enero') {
+      const options = Intl.DateTimeFormat().resolvedOptions();
+
+      return {
+        locale: options.locale,
+        timezone: options.timeZone,
+      };
+    }
+  } catch (err) {
+    //
+  }
+
+  return;
+}
+
+function getAppContext() {
+  const app_memory = process.memoryUsage().rss;
+  const app_start_time = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+  return { app_start_time, app_memory };
+}
+
+/**
+ * Gets device information from os
+ */
+function getDeviceContext(deviceOpt) {
+  const device = {};
+
+  // Sometimes os.uptime() throws due to lacking permissions: https://github.com/getsentry/sentry-javascript/issues/8202
+  let uptime;
+  try {
+    uptime = os.uptime && os.uptime();
+  } catch (e) {
+    // noop
+  }
+
+  // os.uptime or its return value seem to be undefined in certain environments (e.g. Azure functions).
+  // Hence, we only set boot time, if we get a valid uptime value.
+  // @see https://github.com/getsentry/sentry-javascript/issues/5856
+  if (typeof uptime === 'number') {
+    device.boot_time = new Date(Date.now() - uptime * 1000).toISOString();
+  }
+
+  device.arch = os.arch();
+
+  if (deviceOpt === true || deviceOpt.memory) {
+    device.memory_size = os.totalmem();
+    device.free_memory = os.freemem();
+  }
+
+  if (deviceOpt === true || deviceOpt.cpu) {
+    const cpuInfo = os.cpus();
+    if (cpuInfo && cpuInfo.length) {
+      const firstCpu = cpuInfo[0];
+
+      device.processor_count = cpuInfo.length;
+      device.cpu_description = firstCpu.model;
+      device.processor_frequency = firstCpu.speed;
+    }
+  }
+
+  return device;
+}
+
+/** Mapping of Node's platform names to actual OS names. */
+const PLATFORM_NAMES = {
+  aix: 'IBM AIX',
+  freebsd: 'FreeBSD',
+  openbsd: 'OpenBSD',
+  sunos: 'SunOS',
+  win32: 'Windows',
+};
+
+/** Linux version file to check for a distribution. */
+
+/** Mapping of linux release files located in /etc to distributions. */
+const LINUX_DISTROS = [
+  { name: 'fedora-release', distros: ['Fedora'] },
+  { name: 'redhat-release', distros: ['Red Hat Linux', 'Centos'] },
+  { name: 'redhat_version', distros: ['Red Hat Linux'] },
+  { name: 'SuSE-release', distros: ['SUSE Linux'] },
+  { name: 'lsb-release', distros: ['Ubuntu Linux', 'Arch Linux'] },
+  { name: 'debian_version', distros: ['Debian'] },
+  { name: 'debian_release', distros: ['Debian'] },
+  { name: 'arch-release', distros: ['Arch Linux'] },
+  { name: 'gentoo-release', distros: ['Gentoo Linux'] },
+  { name: 'novell-release', distros: ['SUSE Linux'] },
+  { name: 'alpine-release', distros: ['Alpine Linux'] },
+];
+
+/** Functions to extract the OS version from Linux release files. */
+const LINUX_VERSIONS
+
+ = {
+  alpine: content => content,
+  arch: content => matchFirst(/distrib_release=(.*)/, content),
+  centos: content => matchFirst(/release ([^ ]+)/, content),
+  debian: content => content,
+  fedora: content => matchFirst(/release (..)/, content),
+  mint: content => matchFirst(/distrib_release=(.*)/, content),
+  red: content => matchFirst(/release ([^ ]+)/, content),
+  suse: content => matchFirst(/VERSION = (.*)\n/, content),
+  ubuntu: content => matchFirst(/distrib_release=(.*)/, content),
+};
+
+/**
+ * Executes a regular expression with one capture group.
+ *
+ * @param regex A regular expression to execute.
+ * @param text Content to execute the RegEx on.
+ * @returns The captured string if matched; otherwise undefined.
+ */
+function matchFirst(regex, text) {
+  const match = regex.exec(text);
+  return match ? match[1] : undefined;
+}
+
+/** Loads the macOS operating system context. */
+async function getDarwinInfo() {
+  // Default values that will be used in case no operating system information
+  // can be loaded. The default version is computed via heuristics from the
+  // kernel version, but the build ID is missing.
+  const darwinInfo = {
+    kernel_version: os.release(),
+    name: 'Mac OS X',
+    version: `10.${Number(os.release().split('.')[0]) - 4}`,
+  };
+
+  try {
+    // We try to load the actual macOS version by executing the `sw_vers` tool.
+    // This tool should be available on every standard macOS installation. In
+    // case this fails, we stick with the values computed above.
+
+    const output = await new Promise((resolve, reject) => {
+      child_process.execFile('/usr/bin/sw_vers', (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(stdout);
+      });
+    });
+
+    darwinInfo.name = matchFirst(/^ProductName:\s+(.*)$/m, output);
+    darwinInfo.version = matchFirst(/^ProductVersion:\s+(.*)$/m, output);
+    darwinInfo.build = matchFirst(/^BuildVersion:\s+(.*)$/m, output);
+  } catch (e) {
+    // ignore
+  }
+
+  return darwinInfo;
+}
+
+/** Returns a distribution identifier to look up version callbacks. */
+function getLinuxDistroId(name) {
+  return name.split(' ')[0].toLowerCase();
+}
+
+/** Loads the Linux operating system context. */
+async function getLinuxInfo() {
+  // By default, we cannot assume anything about the distribution or Linux
+  // version. `os.release()` returns the kernel version and we assume a generic
+  // "Linux" name, which will be replaced down below.
+  const linuxInfo = {
+    kernel_version: os.release(),
+    name: 'Linux',
+  };
+
+  try {
+    // We start guessing the distribution by listing files in the /etc
+    // directory. This is were most Linux distributions (except Knoppix) store
+    // release files with certain distribution-dependent meta data. We search
+    // for exactly one known file defined in `LINUX_DISTROS` and exit if none
+    // are found. In case there are more than one file, we just stick with the
+    // first one.
+    const etcFiles = await readDirAsync('/etc');
+    const distroFile = LINUX_DISTROS.find(file => etcFiles.includes(file.name));
+    if (!distroFile) {
+      return linuxInfo;
+    }
+
+    // Once that file is known, load its contents. To make searching in those
+    // files easier, we lowercase the file contents. Since these files are
+    // usually quite small, this should not allocate too much memory and we only
+    // hold on to it for a very short amount of time.
+    const distroPath = path.join('/etc', distroFile.name);
+    const contents = ((await readFileAsync$1(distroPath, { encoding: 'utf-8' })) ).toLowerCase();
+
+    // Some Linux distributions store their release information in the same file
+    // (e.g. RHEL and Centos). In those cases, we scan the file for an
+    // identifier, that basically consists of the first word of the linux
+    // distribution name (e.g. "red" for Red Hat). In case there is no match, we
+    // just assume the first distribution in our list.
+    const { distros } = distroFile;
+    linuxInfo.name = distros.find(d => contents.indexOf(getLinuxDistroId(d)) >= 0) || distros[0];
+
+    // Based on the found distribution, we can now compute the actual version
+    // number. This is different for every distribution, so several strategies
+    // are computed in `LINUX_VERSIONS`.
+    const id = getLinuxDistroId(linuxInfo.name);
+    linuxInfo.version = LINUX_VERSIONS[id](contents);
+  } catch (e) {
+    // ignore
+  }
+
+  return linuxInfo;
+}
+
+/**
+ * Grabs some information about hosting provider based on best effort.
+ */
+function getCloudResourceContext() {
+  if (process.env.VERCEL) {
+    // https://vercel.com/docs/concepts/projects/environment-variables/system-environment-variables#system-environment-variables
+    return {
+      'cloud.provider': 'vercel',
+      'cloud.region': process.env.VERCEL_REGION,
+    };
+  } else if (process.env.AWS_REGION) {
+    // https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
+    return {
+      'cloud.provider': 'aws',
+      'cloud.region': process.env.AWS_REGION,
+      'cloud.platform': process.env.AWS_EXECUTION_ENV,
+    };
+  } else if (process.env.GCP_PROJECT) {
+    // https://cloud.google.com/composer/docs/how-to/managing/environment-variables#reserved_variables
+    return {
+      'cloud.provider': 'gcp',
+    };
+  } else if (process.env.ALIYUN_REGION_ID) {
+    // TODO: find where I found these environment variables - at least gc.github.com returns something
+    return {
+      'cloud.provider': 'alibaba_cloud',
+      'cloud.region': process.env.ALIYUN_REGION_ID,
+    };
+  } else if (process.env.WEBSITE_SITE_NAME && process.env.REGION_NAME) {
+    // https://learn.microsoft.com/en-us/azure/app-service/reference-app-settings?tabs=kudu%2Cdotnet#app-environment
+    return {
+      'cloud.provider': 'azure',
+      'cloud.region': process.env.REGION_NAME,
+    };
+  } else if (process.env.IBM_CLOUD_REGION) {
+    // TODO: find where I found these environment variables - at least gc.github.com returns something
+    return {
+      'cloud.provider': 'ibm_cloud',
+      'cloud.region': process.env.IBM_CLOUD_REGION,
+    };
+  } else if (process.env.TENCENTCLOUD_REGION) {
+    // https://www.tencentcloud.com/document/product/583/32748
+    return {
+      'cloud.provider': 'tencent_cloud',
+      'cloud.region': process.env.TENCENTCLOUD_REGION,
+      'cloud.account.id': process.env.TENCENTCLOUD_APPID,
+      'cloud.availability_zone': process.env.TENCENTCLOUD_ZONE,
+    };
+  } else if (process.env.NETLIFY) {
+    // https://docs.netlify.com/configure-builds/environment-variables/#read-only-variables
+    return {
+      'cloud.provider': 'netlify',
+    };
+  } else if (process.env.FLY_REGION) {
+    // https://fly.io/docs/reference/runtime-environment/
+    return {
+      'cloud.provider': 'fly.io',
+      'cloud.region': process.env.FLY_REGION,
+    };
+  } else if (process.env.DYNO) {
+    // https://devcenter.heroku.com/articles/dynos#local-environment-variables
+    return {
+      'cloud.provider': 'heroku',
+    };
+  } else {
+    return undefined;
+  }
+}
+
+function _optionalChain$6(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+const FILE_CONTENT_CACHE = new utils.LRUMap(100);
+const DEFAULT_LINES_OF_CONTEXT = 7;
+const INTEGRATION_NAME$6 = 'ContextLines';
+
+const readFileAsync = fs.promises.readFile;
+
+/** Exported only for tests, as a type-safe variant. */
+const _contextLinesIntegration = ((options = {}) => {
+  const contextLines = options.frameContextLines !== undefined ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
+
+  return {
+    name: INTEGRATION_NAME$6,
+    processEvent(event) {
+      return addSourceContext(event, contextLines);
+    },
+  };
+}) ;
+
+/**
+ * Capture the lines before and after the frame's context.
+ */
+const contextLinesIntegration = core.defineIntegration(_contextLinesIntegration);
+
+async function addSourceContext(event, contextLines) {
+  // keep a lookup map of which files we've already enqueued to read,
+  // so we don't enqueue the same file multiple times which would cause multiple i/o reads
+  const enqueuedReadSourceFileTasks = {};
+  const readSourceFileTasks = [];
+
+  if (contextLines > 0 && _optionalChain$6([event, 'access', _2 => _2.exception, 'optionalAccess', _3 => _3.values])) {
+    for (const exception of event.exception.values) {
+      if (!_optionalChain$6([exception, 'access', _4 => _4.stacktrace, 'optionalAccess', _5 => _5.frames])) {
+        continue;
+      }
+
+      // We want to iterate in reverse order as calling cache.get will bump the file in our LRU cache.
+      // This ends up prioritizes source context for frames at the top of the stack instead of the bottom.
+      for (let i = exception.stacktrace.frames.length - 1; i >= 0; i--) {
+        const frame = exception.stacktrace.frames[i];
+        // Call cache.get to bump the file to the top of the cache and ensure we have not already
+        // enqueued a read operation for this filename
+        if (frame.filename && !enqueuedReadSourceFileTasks[frame.filename] && !FILE_CONTENT_CACHE.get(frame.filename)) {
+          readSourceFileTasks.push(_readSourceFile(frame.filename));
+          enqueuedReadSourceFileTasks[frame.filename] = 1;
+        }
+      }
+    }
+  }
+
+  // check if files to read > 0, if so, await all of them to be read before adding source contexts.
+  // Normally, Promise.all here could be short circuited if one of the promises rejects, but we
+  // are guarding from that by wrapping the i/o read operation in a try/catch.
+  if (readSourceFileTasks.length > 0) {
+    await Promise.all(readSourceFileTasks);
+  }
+
+  // Perform the same loop as above, but this time we can assume all files are in the cache
+  // and attempt to add source context to frames.
+  if (contextLines > 0 && _optionalChain$6([event, 'access', _6 => _6.exception, 'optionalAccess', _7 => _7.values])) {
+    for (const exception of event.exception.values) {
+      if (exception.stacktrace && exception.stacktrace.frames) {
+        await addSourceContextToFrames(exception.stacktrace.frames, contextLines);
+      }
+    }
+  }
+
+  return event;
+}
+
+/** Adds context lines to frames */
+function addSourceContextToFrames(frames, contextLines) {
+  for (const frame of frames) {
+    // Only add context if we have a filename and it hasn't already been added
+    if (frame.filename && frame.context_line === undefined) {
+      const sourceFileLines = FILE_CONTENT_CACHE.get(frame.filename);
+
+      if (sourceFileLines) {
+        try {
+          utils.addContextToFrame(sourceFileLines, frame, contextLines);
+        } catch (e) {
+          // anomaly, being defensive in case
+          // unlikely to ever happen in practice but can definitely happen in theory
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Reads file contents and caches them in a global LRU cache.
+ * If reading fails, mark the file as null in the cache so we don't try again.
+ *
+ * @param filename filepath to read content from.
+ */
+async function _readSourceFile(filename) {
+  const cachedFile = FILE_CONTENT_CACHE.get(filename);
+
+  // We have already attempted to read this file and failed, do not try again
+  if (cachedFile === null) {
+    return null;
+  }
+
+  // We have a cache hit, return it
+  if (cachedFile !== undefined) {
+    return cachedFile;
+  }
+
+  // Guard from throwing if readFile fails, this enables us to use Promise.all and
+  // not have it short circuiting if one of the promises rejects + since context lines are added
+  // on a best effort basis, we want to throw here anyways.
+
+  // If we made it to here, it means that our file is not cache nor marked as failed, so attempt to read it
+  let content = null;
+  try {
+    const rawFileContents = await readFileAsync(filename, 'utf-8');
+    content = rawFileContents.split('\n');
+  } catch (_) {
+    // if we fail, we will mark the file as null in the cache and short circuit next time we try to read it
+  }
+
+  FILE_CONTENT_CACHE.set(filename, content);
+  return content;
+}
+
+/**
+ * Creates a rate limiter that will call the disable callback when the rate limit is reached and the enable callback
+ * when a timeout has occurred.
+ * @param maxPerSecond Maximum number of calls per second
+ * @param enable Callback to enable capture
+ * @param disable Callback to disable capture
+ * @returns A function to call to increment the rate limiter count
+ */
+function createRateLimiter(
+  maxPerSecond,
+  enable,
+  disable,
+) {
+  let count = 0;
+  let retrySeconds = 5;
+  let disabledTimeout = 0;
+
+  setInterval(() => {
+    if (disabledTimeout === 0) {
+      if (count > maxPerSecond) {
+        retrySeconds *= 2;
+        disable(retrySeconds);
+
+        // Cap at one day
+        if (retrySeconds > 86400) {
+          retrySeconds = 86400;
+        }
+        disabledTimeout = retrySeconds;
+      }
+    } else {
+      disabledTimeout -= 1;
+
+      if (disabledTimeout === 0) {
+        enable();
+      }
+    }
+
+    count = 0;
+  }, 1000).unref();
+
+  return () => {
+    count += 1;
+  };
+}
+
+// Add types for the exception event data
+
+/** Could this be an anonymous function? */
+function isAnonymous(name) {
+  return name !== undefined && (name.length === 0 || name === '?' || name === '<anonymous>');
+}
+
+/** Do the function names appear to match? */
+function functionNamesMatch(a, b) {
+  return a === b || (isAnonymous(a) && isAnonymous(b));
+}
+
+/** Creates a unique hash from stack frames */
+function hashFrames(frames) {
+  if (frames === undefined) {
+    return;
+  }
+
+  // Only hash the 10 most recent frames (ie. the last 10)
+  return frames.slice(-10).reduce((acc, frame) => `${acc},${frame.function},${frame.lineno},${frame.colno}`, '');
+}
+
+/**
+ * We use the stack parser to create a unique hash from the exception stack trace
+ * This is used to lookup vars when the exception passes through the event processor
+ */
+function hashFromStack(stackParser, stack) {
+  if (stack === undefined) {
+    return undefined;
+  }
+
+  return hashFrames(stackParser(stack, 1));
+}
+
+function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+/** Creates a container for callbacks to be called sequentially */
+function createCallbackList(complete) {
+  // A collection of callbacks to be executed last to first
+  let callbacks = [];
+
+  let completedCalled = false;
+  function checkedComplete(result) {
+    callbacks = [];
+    if (completedCalled) {
+      return;
+    }
+    completedCalled = true;
+    complete(result);
+  }
+
+  // complete should be called last
+  callbacks.push(checkedComplete);
+
+  function add(fn) {
+    callbacks.push(fn);
+  }
+
+  function next(result) {
+    const popped = callbacks.pop() || checkedComplete;
+
+    try {
+      popped(result);
+    } catch (_) {
+      // If there is an error, we still want to call the complete callback
+      checkedComplete(result);
+    }
+  }
+
+  return { add, next };
+}
+
+/**
+ * Promise API is available as `Experimental` and in Node 19 only.
+ *
+ * Callback-based API is `Stable` since v14 and `Experimental` since v8.
+ * Because of that, we are creating our own `AsyncSession` class.
+ *
+ * https://nodejs.org/docs/latest-v19.x/api/inspector.html#promises-api
+ * https://nodejs.org/docs/latest-v14.x/api/inspector.html
+ */
+class AsyncSession  {
+
+  /** Throws if inspector API is not available */
+   constructor() {
+    this._session = new inspector.Session();
+  }
+
+  /** @inheritdoc */
+   configureAndConnect(onPause, captureAll) {
+    this._session.connect();
+
+    this._session.on('Debugger.paused', event => {
+      onPause(event, () => {
+        // After the pause work is complete, resume execution or the exception context memory is leaked
+        this._session.post('Debugger.resume');
+      });
+    });
+
+    this._session.post('Debugger.enable');
+    this._session.post('Debugger.setPauseOnExceptions', { state: captureAll ? 'all' : 'uncaught' });
+  }
+
+   setPauseOnExceptions(captureAll) {
+    this._session.post('Debugger.setPauseOnExceptions', { state: captureAll ? 'all' : 'uncaught' });
+  }
+
+  /** @inheritdoc */
+   getLocalVariables(objectId, complete) {
+    this._getProperties(objectId, props => {
+      const { add, next } = createCallbackList(complete);
+
+      for (const prop of props) {
+        if (_optionalChain$5([prop, 'optionalAccess', _2 => _2.value, 'optionalAccess', _3 => _3.objectId]) && _optionalChain$5([prop, 'optionalAccess', _4 => _4.value, 'access', _5 => _5.className]) === 'Array') {
+          const id = prop.value.objectId;
+          add(vars => this._unrollArray(id, prop.name, vars, next));
+        } else if (_optionalChain$5([prop, 'optionalAccess', _6 => _6.value, 'optionalAccess', _7 => _7.objectId]) && _optionalChain$5([prop, 'optionalAccess', _8 => _8.value, 'optionalAccess', _9 => _9.className]) === 'Object') {
+          const id = prop.value.objectId;
+          add(vars => this._unrollObject(id, prop.name, vars, next));
+        } else if (_optionalChain$5([prop, 'optionalAccess', _10 => _10.value])) {
+          add(vars => this._unrollOther(prop, vars, next));
+        }
+      }
+
+      next({});
+    });
+  }
+
+  /**
+   * Gets all the PropertyDescriptors of an object
+   */
+   _getProperties(objectId, next) {
+    this._session.post(
+      'Runtime.getProperties',
+      {
+        objectId,
+        ownProperties: true,
+      },
+      (err, params) => {
+        if (err) {
+          next([]);
+        } else {
+          next(params.result);
+        }
+      },
+    );
+  }
+
+  /**
+   * Unrolls an array property
+   */
+   _unrollArray(objectId, name, vars, next) {
+    this._getProperties(objectId, props => {
+      vars[name] = props
+        .filter(v => v.name !== 'length' && !isNaN(parseInt(v.name, 10)))
+        .sort((a, b) => parseInt(a.name, 10) - parseInt(b.name, 10))
+        .map(v => _optionalChain$5([v, 'optionalAccess', _11 => _11.value, 'optionalAccess', _12 => _12.value]));
+
+      next(vars);
+    });
+  }
+
+  /**
+   * Unrolls an object property
+   */
+   _unrollObject(objectId, name, vars, next) {
+    this._getProperties(objectId, props => {
+      vars[name] = props
+        .map(v => [v.name, _optionalChain$5([v, 'optionalAccess', _13 => _13.value, 'optionalAccess', _14 => _14.value])])
+        .reduce((obj, [key, val]) => {
+          obj[key] = val;
+          return obj;
+        }, {} );
+
+      next(vars);
+    });
+  }
+
+  /**
+   * Unrolls other properties
+   */
+   _unrollOther(prop, vars, next) {
+    if (prop.value) {
+      if ('value' in prop.value) {
+        if (prop.value.value === undefined || prop.value.value === null) {
+          vars[prop.name] = `<${prop.value.value}>`;
+        } else {
+          vars[prop.name] = prop.value.value;
+        }
+      } else if ('description' in prop.value && prop.value.type !== 'function') {
+        vars[prop.name] = `<${prop.value.description}>`;
+      } else if (prop.value.type === 'undefined') {
+        vars[prop.name] = '<undefined>';
+      }
+    }
+
+    next(vars);
+  }
+}
+
+/**
+ * When using Vercel pkg, the inspector module is not available.
+ * https://github.com/getsentry/sentry-javascript/issues/6769
+ */
+function tryNewAsyncSession() {
+  try {
+    return new AsyncSession();
+  } catch (e) {
+    return undefined;
+  }
+}
+
+const INTEGRATION_NAME$5 = 'LocalVariables';
+
+/**
+ * Adds local variables to exception frames
+ */
+const _localVariablesSyncIntegration = ((
+  options = {},
+  session = tryNewAsyncSession(),
+) => {
+  const cachedFrames = new utils.LRUMap(20);
+  let rateLimiter;
+  let shouldProcessEvent = false;
+
+  function handlePaused(
+    stackParser,
+    { params: { reason, data, callFrames } },
+    complete,
+  ) {
+    if (reason !== 'exception' && reason !== 'promiseRejection') {
+      complete();
+      return;
+    }
+
+    _optionalChain$5([rateLimiter, 'optionalCall', _15 => _15()]);
+
+    // data.description contains the original error.stack
+    const exceptionHash = hashFromStack(stackParser, _optionalChain$5([data, 'optionalAccess', _16 => _16.description]));
+
+    if (exceptionHash == undefined) {
+      complete();
+      return;
+    }
+
+    const { add, next } = createCallbackList(frames => {
+      cachedFrames.set(exceptionHash, frames);
+      complete();
+    });
+
+    // Because we're queuing up and making all these calls synchronously, we can potentially overflow the stack
+    // For this reason we only attempt to get local variables for the first 5 frames
+    for (let i = 0; i < Math.min(callFrames.length, 5); i++) {
+      const { scopeChain, functionName, this: obj } = callFrames[i];
+
+      const localScope = scopeChain.find(scope => scope.type === 'local');
+
+      // obj.className is undefined in ESM modules
+      const fn = obj.className === 'global' || !obj.className ? functionName : `${obj.className}.${functionName}`;
+
+      if (_optionalChain$5([localScope, 'optionalAccess', _17 => _17.object, 'access', _18 => _18.objectId]) === undefined) {
+        add(frames => {
+          frames[i] = { function: fn };
+          next(frames);
+        });
+      } else {
+        const id = localScope.object.objectId;
+        add(frames =>
+          _optionalChain$5([session, 'optionalAccess', _19 => _19.getLocalVariables, 'call', _20 => _20(id, vars => {
+            frames[i] = { function: fn, vars };
+            next(frames);
+          })]),
+        );
+      }
+    }
+
+    next([]);
+  }
+
+  function addLocalVariablesToException(exception) {
+    const hash = hashFrames(_optionalChain$5([exception, 'optionalAccess', _21 => _21.stacktrace, 'optionalAccess', _22 => _22.frames]));
+
+    if (hash === undefined) {
+      return;
+    }
+
+    // Check if we have local variables for an exception that matches the hash
+    // remove is identical to get but also removes the entry from the cache
+    const cachedFrame = cachedFrames.remove(hash);
+
+    if (cachedFrame === undefined) {
+      return;
+    }
+
+    const frameCount = _optionalChain$5([exception, 'access', _23 => _23.stacktrace, 'optionalAccess', _24 => _24.frames, 'optionalAccess', _25 => _25.length]) || 0;
+
+    for (let i = 0; i < frameCount; i++) {
+      // Sentry frames are in reverse order
+      const frameIndex = frameCount - i - 1;
+
+      // Drop out if we run out of frames to match up
+      if (!_optionalChain$5([exception, 'optionalAccess', _26 => _26.stacktrace, 'optionalAccess', _27 => _27.frames, 'optionalAccess', _28 => _28[frameIndex]]) || !cachedFrame[i]) {
+        break;
+      }
+
+      if (
+        // We need to have vars to add
+        cachedFrame[i].vars === undefined ||
+        // We're not interested in frames that are not in_app because the vars are not relevant
+        exception.stacktrace.frames[frameIndex].in_app === false ||
+        // The function names need to match
+        !functionNamesMatch(exception.stacktrace.frames[frameIndex].function, cachedFrame[i].function)
+      ) {
+        continue;
+      }
+
+      exception.stacktrace.frames[frameIndex].vars = cachedFrame[i].vars;
+    }
+  }
+
+  function addLocalVariablesToEvent(event) {
+    for (const exception of _optionalChain$5([event, 'optionalAccess', _29 => _29.exception, 'optionalAccess', _30 => _30.values]) || []) {
+      addLocalVariablesToException(exception);
+    }
+
+    return event;
+  }
+
+  return {
+    name: INTEGRATION_NAME$5,
+    setupOnce() {
+      const client = core.getClient();
+      const clientOptions = _optionalChain$5([client, 'optionalAccess', _31 => _31.getOptions, 'call', _32 => _32()]);
+
+      if (session && _optionalChain$5([clientOptions, 'optionalAccess', _33 => _33.includeLocalVariables])) {
+        // Only setup this integration if the Node version is >= v18
+        // https://github.com/getsentry/sentry-javascript/issues/7697
+        const unsupportedNodeVersion = NODE_MAJOR < 18;
+
+        if (unsupportedNodeVersion) {
+          utils.logger.log('The `LocalVariables` integration is only supported on Node >= v18.');
+          return;
+        }
+
+        const captureAll = options.captureAllExceptions !== false;
+
+        session.configureAndConnect(
+          (ev, complete) =>
+            handlePaused(clientOptions.stackParser, ev , complete),
+          captureAll,
+        );
+
+        if (captureAll) {
+          const max = options.maxExceptionsPerSecond || 50;
+
+          rateLimiter = createRateLimiter(
+            max,
+            () => {
+              utils.logger.log('Local variables rate-limit lifted.');
+              _optionalChain$5([session, 'optionalAccess', _34 => _34.setPauseOnExceptions, 'call', _35 => _35(true)]);
+            },
+            seconds => {
+              utils.logger.log(
+                `Local variables rate-limit exceeded. Disabling capturing of caught exceptions for ${seconds} seconds.`,
+              );
+              _optionalChain$5([session, 'optionalAccess', _36 => _36.setPauseOnExceptions, 'call', _37 => _37(false)]);
+            },
+          );
+        }
+
+        shouldProcessEvent = true;
+      }
+    },
+    processEvent(event) {
+      if (shouldProcessEvent) {
+        return addLocalVariablesToEvent(event);
+      }
+
+      return event;
+    },
+    // These are entirely for testing
+    _getCachedFramesCount() {
+      return cachedFrames.size;
+    },
+    _getFirstCachedFrame() {
+      return cachedFrames.values()[0];
+    },
+  };
+}) ;
+
+const localVariablesSyncIntegration = core.defineIntegration(_localVariablesSyncIntegration);
+
+/**
+ * Adds local variables to exception frames.
+ * @deprecated Use `localVariablesSyncIntegration()` instead.
+ */
+// eslint-disable-next-line deprecation/deprecation
+core.convertIntegrationFnToClass(
+  INTEGRATION_NAME$5,
+  localVariablesSyncIntegration,
+)
+
+;
+
+// eslint-disable-next-line deprecation/deprecation
+
+const localVariablesIntegration = localVariablesSyncIntegration;
+
+let moduleCache;
+
+const INTEGRATION_NAME$4 = 'Modules';
+
+const _modulesIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME$4,
+    processEvent(event) {
+      event.modules = {
+        ...event.modules,
+        ..._getModules(),
+      };
+
+      return event;
+    },
+  };
+}) ;
+
+/**
+ * Add node modules / packages to the event.
+ */
+const modulesIntegration = core.defineIntegration(_modulesIntegration);
+
+/** Extract information about paths */
+function getPaths() {
+  try {
+    return require.cache ? Object.keys(require.cache ) : [];
+  } catch (e) {
+    return [];
+  }
+}
+
+/** Extract information about package.json modules */
+function collectModules()
+
+ {
+  const mainPaths = (require.main && require.main.paths) || [];
+  const paths = getPaths();
+  const infos
+
+ = {};
+  const seen
+
+ = {};
+
+  paths.forEach(path$1 => {
+    let dir = path$1;
+
+    /** Traverse directories upward in the search of package.json file */
+    const updir = () => {
+      const orig = dir;
+      dir = path.dirname(orig);
+
+      if (!dir || orig === dir || seen[orig]) {
+        return undefined;
+      }
+      if (mainPaths.indexOf(dir) < 0) {
+        return updir();
+      }
+
+      const pkgfile = path.join(orig, 'package.json');
+      seen[orig] = true;
+
+      if (!fs.existsSync(pkgfile)) {
+        return updir();
+      }
+
+      try {
+        const info = JSON.parse(fs.readFileSync(pkgfile, 'utf8'))
+
+;
+        infos[info.name] = info.version;
+      } catch (_oO) {
+        // no-empty
+      }
+    };
+
+    updir();
+  });
+
+  return infos;
+}
+
+/** Fetches the list of modules and the versions loaded by the entry file for your node.js app. */
+function _getModules() {
+  if (!moduleCache) {
+    moduleCache = collectModules();
+  }
+  return moduleCache;
+}
+
+/**
+ * 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 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
+
+const DEFAULT_SHUTDOWN_TIMEOUT = 2000;
+
+/**
+ * @hidden
+ */
+function logAndExitProcess(error) {
+  utils.consoleSandbox(() => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+  });
+
+  const client = core.getClient();
+
+  if (client === undefined) {
+    DEBUG_BUILD && utils.logger.warn('No NodeClient was defined, we are exiting the process now.');
+    global.process.exit(1);
+    return;
+  }
+
+  const options = client.getOptions();
+  const timeout =
+    (options && options.shutdownTimeout && options.shutdownTimeout > 0 && options.shutdownTimeout) ||
+    DEFAULT_SHUTDOWN_TIMEOUT;
+  client.close(timeout).then(
+    (result) => {
+      if (!result) {
+        DEBUG_BUILD && utils.logger.warn('We reached the timeout for emptying the request buffer, still exiting now!');
+      }
+      global.process.exit(1);
+    },
+    error => {
+      DEBUG_BUILD && utils.logger.error(error);
+    },
+  );
+}
+
+const INTEGRATION_NAME$3 = 'OnUncaughtException';
+
+const _onUncaughtExceptionIntegration = ((options = {}) => {
+  const _options = {
+    exitEvenIfOtherHandlersAreRegistered: true,
+    ...options,
+  };
+
+  return {
+    name: INTEGRATION_NAME$3,
+    setup(client) {
+      global.process.on('uncaughtException', makeErrorHandler(client, _options));
+    },
+  };
+}) ;
+
+/**
+ * Add a global exception handler.
+ */
+const onUncaughtExceptionIntegration = core.defineIntegration(_onUncaughtExceptionIntegration);
+
+/** Exported only for tests */
+function makeErrorHandler(client, options) {
+  const timeout = 2000;
+  let caughtFirstError = false;
+  let caughtSecondError = false;
+  let calledFatalError = false;
+  let firstError;
+
+  const clientOptions = client.getOptions();
+
+  return Object.assign(
+    (error) => {
+      let onFatalError = logAndExitProcess;
+
+      if (options.onFatalError) {
+        onFatalError = options.onFatalError;
+      } else if (clientOptions.onFatalError) {
+        onFatalError = clientOptions.onFatalError ;
+      }
+
+      // Attaching a listener to `uncaughtException` will prevent the node process from exiting. We generally do not
+      // want to alter this behaviour so we check for other listeners that users may have attached themselves and adjust
+      // exit behaviour of the SDK accordingly:
+      // - If other listeners are attached, do not exit.
+      // - If the only listener attached is ours, exit.
+      const userProvidedListenersCount = (global.process.listeners('uncaughtException') ).filter(
+        listener => {
+          // There are 3 listeners we ignore:
+          return (
+            // as soon as we're using domains this listener is attached by node itself
+            listener.name !== 'domainUncaughtExceptionClear' &&
+            // the handler we register for tracing
+            listener.tag !== 'sentry_tracingErrorCallback' &&
+            // the handler we register in this integration
+            (listener )._errorHandler !== true
+          );
+        },
+      ).length;
+
+      const processWouldExit = userProvidedListenersCount === 0;
+      const shouldApplyFatalHandlingLogic = options.exitEvenIfOtherHandlersAreRegistered || processWouldExit;
+
+      if (!caughtFirstError) {
+        // this is the first uncaught error and the ultimate reason for shutting down
+        // we want to do absolutely everything possible to ensure it gets captured
+        // also we want to make sure we don't go recursion crazy if more errors happen after this one
+        firstError = error;
+        caughtFirstError = true;
+
+        if (core.getClient() === client) {
+          core.captureException(error, {
+            originalException: error,
+            captureContext: {
+              level: 'fatal',
+            },
+            mechanism: {
+              handled: false,
+              type: 'onuncaughtexception',
+            },
+          });
+        }
+
+        if (!calledFatalError && shouldApplyFatalHandlingLogic) {
+          calledFatalError = true;
+          onFatalError(error);
+        }
+      } else {
+        if (shouldApplyFatalHandlingLogic) {
+          if (calledFatalError) {
+            // we hit an error *after* calling onFatalError - pretty boned at this point, just shut it down
+            DEBUG_BUILD &&
+              utils.logger.warn(
+                'uncaught exception after calling fatal error shutdown callback - this is bad! forcing shutdown',
+              );
+            logAndExitProcess(error);
+          } else if (!caughtSecondError) {
+            // two cases for how we can hit this branch:
+            //   - capturing of first error blew up and we just caught the exception from that
+            //     - quit trying to capture, proceed with shutdown
+            //   - a second independent error happened while waiting for first error to capture
+            //     - want to avoid causing premature shutdown before first error capture finishes
+            // it's hard to immediately tell case 1 from case 2 without doing some fancy/questionable domain stuff
+            // so let's instead just delay a bit before we proceed with our action here
+            // in case 1, we just wait a bit unnecessarily but ultimately do the same thing
+            // in case 2, the delay hopefully made us wait long enough for the capture to finish
+            // two potential nonideal outcomes:
+            //   nonideal case 1: capturing fails fast, we sit around for a few seconds unnecessarily before proceeding correctly by calling onFatalError
+            //   nonideal case 2: case 2 happens, 1st error is captured but slowly, timeout completes before capture and we treat second error as the sendErr of (nonexistent) failure from trying to capture first error
+            // note that after hitting this branch, we might catch more errors where (caughtSecondError && !calledFatalError)
+            //   we ignore them - they don't matter to us, we're just waiting for the second error timeout to finish
+            caughtSecondError = true;
+            setTimeout(() => {
+              if (!calledFatalError) {
+                // it was probably case 1, let's treat err as the sendErr and call onFatalError
+                calledFatalError = true;
+                onFatalError(firstError, error);
+              }
+            }, timeout); // capturing could take at least sendTimeout to fail, plus an arbitrary second for how long it takes to collect surrounding source etc
+          }
+        }
+      }
+    },
+    { _errorHandler: true },
+  );
+}
+
+const INTEGRATION_NAME$2 = 'OnUnhandledRejection';
+
+const _onUnhandledRejectionIntegration = ((options = {}) => {
+  const mode = options.mode || 'warn';
+
+  return {
+    name: INTEGRATION_NAME$2,
+    setup(client) {
+      global.process.on('unhandledRejection', makeUnhandledPromiseHandler(client, { mode }));
+    },
+  };
+}) ;
+
+/**
+ * Add a global promise rejection handler.
+ */
+const onUnhandledRejectionIntegration = core.defineIntegration(_onUnhandledRejectionIntegration);
+
+/**
+ * Send an exception with reason
+ * @param reason string
+ * @param promise promise
+ *
+ * Exported only for tests.
+ */
+function makeUnhandledPromiseHandler(
+  client,
+  options,
+) {
+  return function sendUnhandledPromise(reason, promise) {
+    if (core.getClient() !== client) {
+      return;
+    }
+
+    core.captureException(reason, {
+      originalException: promise,
+      captureContext: {
+        extra: { unhandledPromiseRejection: true },
+      },
+      mechanism: {
+        handled: false,
+        type: 'onunhandledrejection',
+      },
+    });
+
+    handleRejection(reason, options);
+  };
+}
+
+/**
+ * Handler for `mode` option
+
+ */
+function handleRejection(
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  reason,
+  options,
+) {
+  // https://github.com/nodejs/node/blob/7cf6f9e964aa00772965391c23acda6d71972a9a/lib/internal/process/promises.js#L234-L240
+  const rejectionWarning =
+    'This error originated either by ' +
+    'throwing inside of an async function without a catch block, ' +
+    'or by rejecting a promise which was not handled with .catch().' +
+    ' The promise rejected with the reason:';
+
+  /* eslint-disable no-console */
+  if (options.mode === 'warn') {
+    utils.consoleSandbox(() => {
+      console.warn(rejectionWarning);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      console.error(reason && reason.stack ? reason.stack : reason);
+    });
+  } else if (options.mode === 'strict') {
+    utils.consoleSandbox(() => {
+      console.warn(rejectionWarning);
+    });
+    logAndExitProcess(reason);
+  }
+  /* eslint-enable no-console */
+}
+
+// This string is a placeholder that gets overwritten with the worker code.
+const base64WorkerScript = 'import { Session } from 'inspector';
import { workerData, parentPort } from 'worker_threads';
import { posix, sep } from 'path';
import * as http$1 from 'node:http';
import * as https from 'node:https';
import { Readable } from 'stream';
import { createGzip } from 'zlib';
import * as net from 'net';
import * as tls from 'tls';
import * as http from 'http';

// 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.
 *
 * @param wat The value to be checked
 * @param className
 * @returns A boolean representing the result.
 */
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}.
 *
 * @param wat A value to be checked.
 * @returns A boolean representing the result.
 */
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.
 */
function isThenable(wat) {
  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
  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
// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js
// core-js has the following licence:
//
// Copyright (c) 2014-2022 Denis Pushkarev
//
// 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.

/** Returns 'obj' if it's the global object, otherwise returns undefined */
function isGlobalObj(obj) {
  return obj && obj.Math == Math ? obj : undefined;
}

/** Get's the global object for the current JavaScript runtime */
const GLOBAL_OBJ =
  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||
  // eslint-disable-next-line no-restricted-globals
  (typeof window == 'object' && isGlobalObj(window)) ||
  (typeof self == 'object' && isGlobalObj(self)) ||
  (typeof global == 'object' && isGlobalObj(global)) ||
  (function () {
    return this;
  })() ||
  {};

/**
 * @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.
 *
 * 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__);

/** Prefix for logging strings */
const PREFIX = 'Sentry Logger ';

const CONSOLE_LEVELS = [
  'debug',
  'info',
  'warn',
  'error',
  'log',
  'assert',
  'trace',
] ;

/** This may be mutated by the console instrumentation. */
const originalConsoleMethods

 = {};

/** JSDoc */

/**
 * Temporarily disable sentry console instrumentations.
 *
 * @param callback The function to run against the original `console` messages
 * @returns The results of the callback
 */
function consoleSandbox(callback) {
  if (!('console' in GLOBAL_OBJ)) {
    return callback();
  }

  const console = GLOBAL_OBJ.console ;
  const wrappedFuncs = {};

  const wrappedLevels = Object.keys(originalConsoleMethods) ;

  // Restore all wrapped console methods
  wrappedLevels.forEach(level => {
    const originalConsoleMethod = originalConsoleMethods[level] ;
    wrappedFuncs[level] = console[level] ;
    console[level] = originalConsoleMethod;
  });

  try {
    return callback();
  } finally {
    // Revert restoration to wrapped state
    wrappedLevels.forEach(level => {
      console[level] = wrappedFuncs[level] ;
    });
  }
}

function makeLogger() {
  let enabled = false;
  const logger = {
    enable: () => {
      enabled = true;
    },
    disable: () => {
      enabled = false;
    },
    isEnabled: () => enabled,
  };

  if (DEBUG_BUILD$1) {
    CONSOLE_LEVELS.forEach(name => {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      logger[name] = (...args) => {
        if (enabled) {
          consoleSandbox(() => {
            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
          });
        }
      };
    });
  } else {
    CONSOLE_LEVELS.forEach(name => {
      logger[name] = () => undefined;
    });
  }

  return logger ;
}

const logger = makeLogger();

/**
 * Renders the string representation of this Dsn.
 *
 * By default, this will render the public representation without the password
 * component. To get the deprecated private representation, set `withPassword`
 * to true.
 *
 * @param withPassword When set to true, the password will be included.
 */
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}`
  );
}

/** An error emitted by Sentry SDKs and related utilities. */
class SentryError extends Error {
  /** Display name of this error instance. */

   constructor( message, logLevel = 'warn') {
    super(message);this.message = message;
    this.name = new.target.prototype.constructor.name;
    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line
    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes
    // instances of `SentryError` fail `obj instanceof SentryError` checks.
    Object.setPrototypeOf(this, new.target.prototype);
    this.logLevel = logLevel;
  }
}

const STACKTRACE_FRAME_LIMIT = 50;
const UNKNOWN_FUNCTION = '?';
const STRIP_FRAME_REGEXP = /captureMessage|captureException/;

/**
 * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.
 * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the
 * function that caused the crash is the last frame in the array.
 * @hidden
 */
function stripSentryFramesAndReverse(stack) {
  if (!stack.length) {
    return [];
  }

  const localStack = Array.from(stack);

  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {
    localStack.pop();
  }

  // Reversing in the middle of the procedure allows us to just pop the values off the stack
  localStack.reverse();

  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
    localStack.pop();

    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`
    // is produced within the hub itself, making it:
    //
    //   Sentry.captureException()
    //   getCurrentHub().captureException()
    //
    // instead of just the top `Sentry` call itself.
    // This forces us to possibly strip an additional frame in the exact same was as above.
    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {
      localStack.pop();
    }
  }

  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({
    ...frame,
    filename: frame.filename || localStack[localStack.length - 1].filename,
    function: frame.function || UNKNOWN_FUNCTION,
  }));
}

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;
  }
}

/**
 * This extracts the original function if available.  See
 * `markFunctionWrapped` for more information.
 *
 * @param func the function to unwrap
 * @returns the unwrapped version of the function if available.
 */
function getOriginalFunction(func) {
  return func.__sentry_original__;
}

/**
 * Encodes given object into url-friendly format
 *
 * @param object An object that contains serializable values
 * @returns string Encoded
 */
function urlEncode(object) {
  return Object.keys(object)
    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)
    .join('&');
}

/**
 * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
 * non-enumerable properties attached.
 *
 * @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 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 {};
  }
}

/**
 * Given any object, return a new object having removed all fields whose value was `undefined`.
 * Works recursively on objects and arrays.
 *
 * Attention: This function keeps circular references in the returned object.
 */
function dropUndefinedKeys(inputValue) {
  // This map keeps track of what already visited nodes map to.
  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular
  // references as the input object.
  const memoizationMap = new Map();

  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API
  return _dropUndefinedKeys(inputValue, memoizationMap);
}

function _dropUndefinedKeys(inputValue, memoizationMap) {
  if (isPojo(inputValue)) {
    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object
    const memoVal = memoizationMap.get(inputValue);
    if (memoVal !== undefined) {
      return memoVal ;
    }

    const returnValue = {};
    // Store the mapping of this value in case we visit it again, in case of circular data
    memoizationMap.set(inputValue, returnValue);

    for (const key of Object.keys(inputValue)) {
      if (typeof inputValue[key] !== 'undefined') {
        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);
      }
    }

    return returnValue ;
  }

  if (Array.isArray(inputValue)) {
    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object
    const memoVal = memoizationMap.get(inputValue);
    if (memoVal !== undefined) {
      return memoVal ;
    }

    const returnValue = [];
    // Store the mapping of this value in case we visit it again, in case of circular data
    memoizationMap.set(inputValue, returnValue);

    inputValue.forEach((item) => {
      returnValue.push(_dropUndefinedKeys(item, memoizationMap));
    });

    return returnValue ;
  }

  return inputValue;
}

function isPojo(input) {
  if (!isPlainObject(input)) {
    return false;
  }

  try {
    const name = (Object.getPrototypeOf(input) ).constructor.name;
    return !name || name === 'Object';
  } catch (e) {
    return true;
  }
}

/**
 * UUID4 generator
 *
 * @returns string Generated UUID4.
 */
function uuid4() {
  const gbl = GLOBAL_OBJ ;
  const crypto = gbl.crypto || gbl.msCrypto;

  let getRandomByte = () => Math.random() * 16;
  try {
    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];
      };
    }
  } 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';
}

/**
 * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint
 * across platforms and working directory.
 *
 * @param url The URL to be normalized.
 * @param basePath The application base path.
 * @returns The normalized URL.
 */
function normalizeUrlToBase(url, basePath) {
  const escapedBase = basePath
    // Backslash to forward
    .replace(/\\/g, '/')
    // Escape RegExp special characters
    .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');

  let newUrl = url;
  try {
    newUrl = decodeURI(url);
  } catch (_Oo) {
    // Sometime this breaks
  }
  return (
    newUrl
      .replace(/\\/g, '/')
      .replace(/webpack:\/?/g, '') // Remove intermediate base path
      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor
      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')
  );
}

// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
const splitPathRe = /^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;
/** JSDoc */
function splitPath(filename) {
  // Truncate files names greater than 1024 characters to avoid regex dos
  // https://github.com/getsentry/sentry-javascript/pull/8737#discussion_r1285719172
  const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;
  const parts = splitPathRe.exec(truncated);
  return parts ? parts.slice(1) : [];
}

/** JSDoc */
function dirname(path) {
  const result = splitPath(path);
  const root = result[0];
  let dir = result[1];

  if (!root && !dir) {
    // No dirname whatsoever
    return '.';
  }

  if (dir) {
    // It has a dirname, strip trailing slash
    dir = dir.slice(0, dir.length - 1);
  }

  return root + dir;
}

/* 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 = {}));

// Overloads so we can call resolvedSyncPromise without arguments and generic argument

/**
 * Creates a resolved sync promise.
 *
 * @param value the value to resolve the promise with
 * @returns the resolved sync promise
 */
function resolvedSyncPromise(value) {
  return new SyncPromise(resolve => {
    resolve(value);
  });
}

/**
 * Creates a rejected sync promise.
 *
 * @param value the value to reject the promise with
 * @returns the rejected sync promise
 */
function rejectedSyncPromise(reason) {
  return new SyncPromise((_, reject) => {
    reject(reason);
  });
}

/**
 * Thenable class that behaves like a Promise and follows it's interface
 * but is not async internally
 */
class SyncPromise {

   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 = [];

    try {
      executor(this._resolve, this._reject);
    } catch (e) {
      this._reject(e);
    }
  }

  /** 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();
    });
  }

  /** JSDoc */
   catch(
    onrejected,
  ) {
    return this.then(val => val, onrejected);
  }

  /** JSDoc */
   finally(onfinally) {
    return new SyncPromise((resolve, reject) => {
      let val;
      let isRejected;

      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;
        }

        resolve(val );
      });
    });
  }

  /** JSDoc */
    __init() {this._resolve = (value) => {
    this._setResult(States.RESOLVED, value);
  };}

  /** JSDoc */
    __init2() {this._reject = (reason) => {
    this._setResult(States.REJECTED, reason);
  };}

  /** JSDoc */
    __init3() {this._setResult = (state, value) => {
    if (this._state !== States.PENDING) {
      return;
    }

    if (isThenable(value)) {
      void (value ).then(this._resolve, this._reject);
      return;
    }

    this._state = state;
    this._value = value;

    this._executeHandlers();
  };}

  /** JSDoc */
    __init4() {this._executeHandlers = () => {
    if (this._state === States.PENDING) {
      return;
    }

    const cachedHandlers = this._handlers.slice();
    this._handlers = [];

    cachedHandlers.forEach(handler => {
      if (handler[0]) {
        return;
      }

      if (this._state === States.RESOLVED) {
        handler[1](this._value );
      }

      if (this._state === States.REJECTED) {
        handler[2](this._value);
      }

      handler[0] = true;
    });
  };}
}

/**
 * Creates an new PromiseBuffer object with the specified limit
 * @param limit max number of promises that can be stored in the buffer
 */
function makePromiseBuffer(limit) {
  const buffer = [];

  function isReady() {
    return limit === undefined || buffer.length < limit;
  }

  /**
   * Remove a promise from the queue.
   *
   * @param task Can be any PromiseLike<T>
   * @returns Removed promise.
   */
  function remove(task) {
    return buffer.splice(buffer.indexOf(task), 1)[0];
  }

  /**
   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.
   *
   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:
   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor
   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By
   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer
   *        limit check.
   * @returns The original promise.
   */
  function add(taskProducer) {
    if (!isReady()) {
      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));
    }

    // start the task and add its promise to the queue
    const task = taskProducer();
    if (buffer.indexOf(task) === -1) {
      buffer.push(task);
    }
    void task
      .then(() => remove(task))
      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
      // have promises, so TS has to polyfill when down-compiling.)
      .then(null, () =>
        remove(task).then(null, () => {
          // We have to add another catch here because `remove()` starts a new promise chain.
        }),
      );
    return task;
  }

  /**
   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.
   *
   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or
   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to
   * `true`.
   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and
   * `false` otherwise
   */
  function drain(timeout) {
    return new SyncPromise((resolve, reject) => {
      let counter = buffer.length;

      if (!counter) {
        return resolve(true);
      }

      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
      const capturedSetTimeout = setTimeout(() => {
        if (timeout && timeout > 0) {
          resolve(false);
        }
      }, timeout);

      // if all promises resolve in time, cancel the timer and resolve to `true`
      buffer.forEach(item => {
        void resolvedSyncPromise(item).then(() => {
          if (!--counter) {
            clearTimeout(capturedSetTimeout);
            resolve(true);
          }
        }, reject);
      });
    });
  }

  return {
    $: buffer,
    add,
    drain,
  };
}

/**
 * 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;
  }
}

/**
 * Does this filename look like it's part of the app code?
 */
function filenameIsInApp(filename, isNative = false) {
  const isInternal =
    isNative ||
    (filename &&
      // It's not internal if it's an absolute linux path
      !filename.startsWith('/') &&
      // It's not internal if it's an absolute windows path
      !filename.match(/^[A-Z]:/) &&
      // It's not internal if the path is starting with a dot
      !filename.startsWith('.') &&
      // It's not internal if the frame has a protocol. In node, this is usually the case if the file got pre-processed with a bundler like webpack
      !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//)); // Schema from: https://stackoverflow.com/a/3641782

  // in_app is all that's not an internal Node function or a module within node_modules
  // note that isNative appears to return true even for node core libraries
  // see https://github.com/getsentry/raven-node/issues/176

  return !isInternal && filename !== undefined && !filename.includes('node_modules/');
}

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) {
    return dateTimestampInSeconds;
  }

  // Some browser and environments don't have a timeOrigin, so we fallback to
  // using Date.now() to compute the starting time.
  const approxStartingTimeOrigin = Date.now() - performance.now();
  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;

  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current
  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.
  //
  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the
  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and
  // correct for this.
  // See: https://github.com/getsentry/sentry-javascript/issues/2590
  // See: https://github.com/mdn/content/issues/4713
  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6
  return () => {
    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;
  };
}

/**
 * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
 * availability of the Performance API.
 *
 * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
 * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
 * skew can grow to arbitrary amounts like days, weeks or months.
 * See https://github.com/getsentry/sentry-javascript/issues/2590.
 */
const timestampInSeconds = createUnixTimestampInSecondsFunc();

/**
 * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
 * performance API is available.
 */
(() => {
  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
  // data as reliable if they are within a reasonable threshold of the current time.

  const { performance } = GLOBAL_OBJ ;
  if (!performance || !performance.now) {
    return undefined;
  }

  const threshold = 3600 * 1000;
  const performanceNow = performance.now();
  const dateNow = Date.now();

  // if timeOrigin isn't available set delta to threshold so it isn't used
  const timeOriginDelta = performance.timeOrigin
    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)
    : threshold;
  const timeOriginIsReliable = timeOriginDelta < threshold;

  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
  // Date API.
  // eslint-disable-next-line deprecation/deprecation
  const navigationStart = performance.timing && performance.timing.navigationStart;
  const hasNavigationStart = typeof navigationStart === 'number';
  // if navigationStart isn't available set delta to threshold so it isn't used
  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;
  const navigationStartIsReliable = navigationStartDelta < threshold;

  if (timeOriginIsReliable || navigationStartIsReliable) {
    // Use the more reliable time origin
    if (timeOriginDelta <= navigationStartDelta) {
      return performance.timeOrigin;
    } else {
      return navigationStart;
    }
  }
  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)
 *
 * If the callback returns true, the rest of the items will be skipped.
 */
function forEachEnvelopeItem(
  envelope,
  callback,
) {
  const envelopeItems = envelope[1];

  for (const envelopeItem of envelopeItems) {
    const envelopeItemType = envelopeItem[0].type;
    const result = callback(envelopeItem, envelopeItemType);

    if (result) {
      return true;
    }
  }

  return false;
}

/**
 * Encode a string to UTF8 array.
 */
function encodeUTF8(input) {
  return new TextEncoder().encode(input);
}

/**
 * Serializes an envelope.
 */
function serializeEnvelope(envelope) {
  const [envHeaders, items] = envelope;

  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data
  let parts = JSON.stringify(envHeaders);

  function append(next) {
    if (typeof parts === 'string') {
      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts), next];
    } else {
      parts.push(typeof next === 'string' ? encodeUTF8(next) : next);
    }
  }

  for (const item of items) {
    const [itemHeaders, payload] = item;

    append(`\n${JSON.stringify(itemHeaders)}\n`);

    if (typeof payload === 'string' || payload instanceof Uint8Array) {
      append(payload);
    } else {
      let stringifiedPayload;
      try {
        stringifiedPayload = JSON.stringify(payload);
      } catch (e) {
        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still
        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a
        // performance impact but in this case a performance hit is better than throwing.
        stringifiedPayload = JSON.stringify(normalize(payload));
      }
      append(stringifiedPayload);
    }
  }

  return typeof parts === 'string' ? parts : concatBuffers(parts);
}

function concatBuffers(buffers) {
  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);

  const merged = new Uint8Array(totalLength);
  let offset = 0;
  for (const buffer of buffers) {
    merged.set(buffer, offset);
    offset += buffer.length;
  }

  return merged;
}

const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
  session: 'session',
  sessions: 'session',
  attachment: 'attachment',
  transaction: 'transaction',
  event: 'error',
  client_report: 'internal',
  user_report: 'default',
  profile: 'profile',
  replay_event: 'replay',
  replay_recording: 'replay',
  check_in: 'monitor',
  feedback: 'feedback',
  // TODO: This is a temporary workaround until we have a proper data category for metrics
  statsd: 'unknown',
};

/**
 * Maps the type of an envelope item to a data category.
 */
function envelopeItemTypeToDataCategory(type) {
  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
}

/** Extracts the minimal SDK info from from the metadata or an events */
function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
  if (!metadataOrEvent || !metadataOrEvent.sdk) {
    return;
  }
  const { name, version } = metadataOrEvent.sdk;
  return { name, version };
}

/**
 * Creates event envelope headers, based on event, sdk info and tunnel
 * Note: This function was extracted from the core package to make it available in Replay
 */
function createEventEnvelopeHeaders(
  event,
  sdkInfo,
  tunnel,
  dsn,
) {
  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;
  return {
    event_id: event.event_id ,
    sent_at: new Date().toISOString(),
    ...(sdkInfo && { sdk: sdkInfo }),
    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),
    ...(dynamicSamplingContext && {
      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),
    }),
  };
}

// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend

const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds

/**
 * Extracts Retry-After value from the request header or returns default value
 * @param header string representation of 'Retry-After' header
 * @param now current unix timestamp
 *
 */
function parseRetryAfterHeader(header, now = Date.now()) {
  const headerDelay = parseInt(`${header}`, 10);
  if (!isNaN(headerDelay)) {
    return headerDelay * 1000;
  }

  const headerDate = Date.parse(`${header}`);
  if (!isNaN(headerDate)) {
    return headerDate - now;
  }

  return DEFAULT_RETRY_AFTER;
}

/**
 * Gets the time that the given category is disabled until for rate limiting.
 * In case no category-specific limit is set but a general rate limit across all categories is active,
 * that time is returned.
 *
 * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.
 */
function disabledUntil(limits, category) {
  return limits[category] || limits.all || 0;
}

/**
 * Checks if a category is rate limited
 */
function isRateLimited(limits, category, now = Date.now()) {
  return disabledUntil(limits, category) > now;
}

/**
 * Update ratelimits from incoming headers.
 *
 * @return the updated RateLimits object.
 */
function updateRateLimits(
  limits,
  { statusCode, headers },
  now = Date.now(),
) {
  const updatedRateLimits = {
    ...limits,
  };

  // "The name is case-insensitive."
  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];
  const retryAfterHeader = headers && headers['retry-after'];

  if (rateLimitHeader) {
    /**
     * rate limit headers are of the form
     *     <header>,<header>,..
     * where each <header> is of the form
     *     <retry_after>: <categories>: <scope>: <reason_code>
     * where
     *     <retry_after> is a delay in seconds
     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
     *         <category>;<category>;...
     *     <scope> is what's being limited (org, project, or key) - ignored by SDK
     *     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
     */
    for (const limit of rateLimitHeader.trim().split(',')) {
      const [retryAfter, categories] = limit.split(':', 2);
      const headerDelay = parseInt(retryAfter, 10);
      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
      if (!categories) {
        updatedRateLimits.all = now + delay;
      } else {
        for (const category of categories.split(';')) {
          updatedRateLimits[category] = now + delay;
        }
      }
    }
  } else if (retryAfterHeader) {
    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);
  } else if (statusCode === 429) {
    updatedRateLimits.all = now + 60 * 1000;
  }

  return updatedRateLimits;
}

/**
 * A node.js watchdog timer
 * @param pollInterval The interval that we expect to get polled at
 * @param anrThreshold The threshold for when we consider ANR
 * @param callback The callback to call for ANR
 * @returns An object with `poll` and `enabled` functions {@link WatchdogReturn}
 */
function watchdogTimer(
  createTimer,
  pollInterval,
  anrThreshold,
  callback,
) {
  const timer = createTimer();
  let triggered = false;
  let enabled = true;

  setInterval(() => {
    const diffMs = timer.getTimeMs();

    if (triggered === false && diffMs > pollInterval + anrThreshold) {
      triggered = true;
      if (enabled) {
        callback();
      }
    }

    if (diffMs < pollInterval + anrThreshold) {
      triggered = false;
    }
  }, 20);

  return {
    poll: () => {
      timer.reset();
    },
    enabled: (state) => {
      enabled = state;
    },
  };
}

// types copied from inspector.d.ts

/**
 * Converts Debugger.CallFrame to Sentry StackFrame
 */
function callFrameToStackFrame(
  frame,
  url,
  getModuleFromFilename,
) {
  const filename = url ? url.replace(/^file:\/\//, '') : undefined;

  // CallFrame row/col are 0 based, whereas StackFrame are 1 based
  const colno = frame.location.columnNumber ? frame.location.columnNumber + 1 : undefined;
  const lineno = frame.location.lineNumber ? frame.location.lineNumber + 1 : undefined;

  return dropUndefinedKeys({
    filename,
    module: getModuleFromFilename(filename),
    function: frame.functionName || UNKNOWN_FUNCTION,
    colno,
    lineno,
    in_app: filename ? filenameIsInApp(filename) : undefined,
  });
}

/**
 * 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 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);

/**
 * @private Private API with no semver guarantees!
 *
 * Strategy used to track async context.
 */

/**
 * 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;
}

/** 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.
 *
 * @param context (optional) additional properties to be applied to the returned session object
 *
 * @returns a new `Session` object
 */
function makeSession(context) {
  // Both timestamp and started are in seconds since the UNIX epoch.
  const startingTime = timestampInSeconds();

  const session = {
    sid: uuid4(),
    init: true,
    timestamp: startingTime,
    started: startingTime,
    duration: 0,
    status: 'ok',
    errors: 0,
    ignoreDuration: false,
    toJSON: () => sessionToJSON(session),
  };

  if (context) {
    updateSession(session, context);
  }

  return session;
}

/**
 * Updates a session object with the properties passed in the context.
 *
 * Note that this function mutates the passed object and returns void.
 * (Had to do this instead of returning a new and updated session because closing and sending a session
 * makes an update to the session after it was passed to the sending logic.
 * @see BaseClient.captureSession )
 *
 * @param session the `Session` to update
 * @param context the `SessionContext` holding the properties that should be updated in @param session
 */
// eslint-disable-next-line complexity
function updateSession(session, context = {}) {
  if (context.user) {
    if (!session.ipAddress && context.user.ip_address) {
      session.ipAddress = context.user.ip_address;
    }

    if (!session.did && !context.did) {
      session.did = context.user.id || context.user.email || context.user.username;
    }
  }

  session.timestamp = context.timestamp || timestampInSeconds();

  if (context.abnormal_mechanism) {
    session.abnormal_mechanism = context.abnormal_mechanism;
  }

  if (context.ignoreDuration) {
    session.ignoreDuration = context.ignoreDuration;
  }
  if (context.sid) {
    // Good enough uuid validation. — Kamil
    session.sid = context.sid.length === 32 ? context.sid : uuid4();
  }
  if (context.init !== undefined) {
    session.init = context.init;
  }
  if (!session.did && context.did) {
    session.did = `${context.did}`;
  }
  if (typeof context.started === 'number') {
    session.started = context.started;
  }
  if (session.ignoreDuration) {
    session.duration = undefined;
  } else if (typeof context.duration === 'number') {
    session.duration = context.duration;
  } else {
    const duration = session.timestamp - session.started;
    session.duration = duration >= 0 ? duration : 0;
  }
  if (context.release) {
    session.release = context.release;
  }
  if (context.environment) {
    session.environment = context.environment;
  }
  if (!session.ipAddress && context.ipAddress) {
    session.ipAddress = context.ipAddress;
  }
  if (!session.userAgent && context.userAgent) {
    session.userAgent = context.userAgent;
  }
  if (typeof context.errors === 'number') {
    session.errors = context.errors;
  }
  if (context.status) {
    session.status = context.status;
  }
}

/**
 * Closes a session by setting its status and updating the session object with it.
 * Internally calls `updateSession` to update the passed session object.
 *
 * Note that this function mutates the passed session (@see updateSession for explanation).
 *
 * @param session the `Session` object to be closed
 * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,
 *               this function will keep the previously set status, unless it was `'ok'` in which case
 *               it is changed to `'exited'`.
 */
function closeSession(session, status) {
  let context = {};
  if (status) {
    context = { status };
  } else if (session.status === 'ok') {
    context = { status: 'exited' };
  }

  updateSession(session, context);
}

/**
 * Serializes a passed session object to a JSON object with a slightly different structure.
 * This is necessary because the Sentry backend requires a slightly different schema of a session
 * than the one the JS SDKs use internally.
 *
 * @param session the session to be converted
 *
 * @returns a JSON object of the passed session
 */
function sessionToJSON(session) {
  return dropUndefinedKeys({
    sid: `${session.sid}`,
    init: session.init,
    // Make sure that sec is converted to ms for date constructor
    started: new Date(session.started * 1000).toISOString(),
    timestamp: new Date(session.timestamp * 1000).toISOString(),
    status: session.status,
    errors: session.errors,
    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,
    duration: session.duration,
    abnormal_mechanism: session.abnormal_mechanism,
    attrs: {
      release: session.release,
      environment: session.environment,
      ip_address: session.ipAddress,
      user_agent: session.userAgent,
    },
  });
}

/**
 * Default value for maximum number of breadcrumbs added to an event.
 */
const DEFAULT_MAX_BREADCRUMBS = 100;

/**
 * Holds additional event information.
 */
class Scope  {
  /** Flag if notifying is happening. */

  /** Callback for client to receive scope changes. */

  /** Callback list that will be called during event processing. */

  /** Array of breadcrumbs. */

  /** User */

  /** Tags */

  /** Extra */

  /** Contexts */

  /** Attachments */

  /** Propagation Context for distributed tracing */

  /**
   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
   * sent to Sentry
   */

  /** Fingerprint */

  /** Severity */

  /**
   * 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 */

  /** Session */

  /** Request Mode Session Status */

  /** The client on this scope */

  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.

   constructor() {
    this._notifyingListeners = false;
    this._scopeListeners = [];
    this._eventProcessors = [];
    this._breadcrumbs = [];
    this._attachments = [];
    this._user = {};
    this._tags = {};
    this._extra = {};
    this._contexts = {};
    this._sdkProcessingMetadata = {};
    this._propagationContext = generatePropagationContext();
  }

  /**
   * Inherit values from the parent scope.
   * @deprecated Use `scope.clone()` and `new Scope()` instead.
   */
   static clone(scope) {
    return scope ? scope.clone() : new Scope();
  }

  /**
   * @inheritDoc
   */
   clone() {
    const newScope = new Scope();
    newScope._breadcrumbs = [...this._breadcrumbs];
    newScope._tags = { ...this._tags };
    newScope._extra = { ...this._extra };
    newScope._contexts = { ...this._contexts };
    newScope._user = this._user;
    newScope._level = this._level;
    newScope._span = this._span;
    newScope._session = this._session;
    newScope._transactionName = this._transactionName;
    newScope._fingerprint = this._fingerprint;
    newScope._eventProcessors = [...this._eventProcessors];
    newScope._requestSession = this._requestSession;
    newScope._attachments = [...this._attachments];
    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };
    newScope._propagationContext = { ...this._propagationContext };
    newScope._client = this._client;

    return newScope;
  }

  /**
   * @inheritDoc
   */
   setClient(client) {
    this._client = client;
  }

  /**
   * @inheritDoc
   */
   getClient() {
    return this._client ;
  }

  /**
   * @inheritDoc
   */
   addScopeListener(callback) {
    this._scopeListeners.push(callback);
  }

  /**
   * @inheritDoc
   */
   addEventProcessor(callback) {
    this._eventProcessors.push(callback);
    return this;
  }

  /**
   * @inheritDoc
   */
   setUser(user) {
    // If null is passed we want to unset everything, but still define keys,
    // so that later down in the pipeline any existing values are cleared.
    this._user = user || {
      email: undefined,
      id: undefined,
      ip_address: undefined,
      username: undefined,
    };

    if (this._session) {
      updateSession(this._session, { user });
    }

    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   getUser() {
    return this._user;
  }

  /**
   * @inheritDoc
   */
   getRequestSession() {
    return this._requestSession;
  }

  /**
   * @inheritDoc
   */
   setRequestSession(requestSession) {
    this._requestSession = requestSession;
    return this;
  }

  /**
   * @inheritDoc
   */
   setTags(tags) {
    this._tags = {
      ...this._tags,
      ...tags,
    };
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setTag(key, value) {
    this._tags = { ...this._tags, [key]: value };
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setExtras(extras) {
    this._extra = {
      ...this._extra,
      ...extras,
    };
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setExtra(key, extra) {
    this._extra = { ...this._extra, [key]: extra };
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setFingerprint(fingerprint) {
    this._fingerprint = fingerprint;
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setLevel(level) {
    this._level = level;
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setTransactionName(name) {
    this._transactionName = name;
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   setContext(key, context) {
    if (context === null) {
      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
      delete this._contexts[key];
    } else {
      this._contexts[key] = context;
    }

    this._notifyScopeListeners();
    return this;
  }

  /**
   * Sets the Span on the scope.
   * @param span Span
   * @deprecated Instead of setting a span on a scope, use `startSpan()`/`startSpanManual()` instead.
   */
   setSpan(span) {
    this._span = span;
    this._notifyScopeListeners();
    return this;
  }

  /**
   * Returns the `Span` if there is one.
   * @deprecated Use `getActiveSpan()` instead.
   */
   getSpan() {
    return this._span;
  }

  /**
   * Returns the `Transaction` attached to the scope (if there is one).
   * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.
   */
   getTransaction() {
    // 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
    if (span && (span ).transaction) {
      // eslint-disable-next-line deprecation/deprecation
      return (span ).transaction;
    }
    return undefined;
  }

  /**
   * @inheritDoc
   */
   setSession(session) {
    if (!session) {
      delete this._session;
    } else {
      this._session = session;
    }
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   getSession() {
    return this._session;
  }

  /**
   * @inheritDoc
   */
   update(captureContext) {
    if (!captureContext) {
      return this;
    }

    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;

    if (scopeToMerge instanceof Scope) {
      const scopeData = scopeToMerge.getScopeData();

      this._tags = { ...this._tags, ...scopeData.tags };
      this._extra = { ...this._extra, ...scopeData.extra };
      this._contexts = { ...this._contexts, ...scopeData.contexts };
      if (scopeData.user && Object.keys(scopeData.user).length) {
        this._user = scopeData.user;
      }
      if (scopeData.level) {
        this._level = scopeData.level;
      }
      if (scopeData.fingerprint.length) {
        this._fingerprint = scopeData.fingerprint;
      }
      if (scopeToMerge.getRequestSession()) {
        this._requestSession = scopeToMerge.getRequestSession();
      }
      if (scopeData.propagationContext) {
        this._propagationContext = scopeData.propagationContext;
      }
    } else if (isPlainObject(scopeToMerge)) {
      const scopeContext = captureContext ;
      this._tags = { ...this._tags, ...scopeContext.tags };
      this._extra = { ...this._extra, ...scopeContext.extra };
      this._contexts = { ...this._contexts, ...scopeContext.contexts };
      if (scopeContext.user) {
        this._user = scopeContext.user;
      }
      if (scopeContext.level) {
        this._level = scopeContext.level;
      }
      if (scopeContext.fingerprint) {
        this._fingerprint = scopeContext.fingerprint;
      }
      if (scopeContext.requestSession) {
        this._requestSession = scopeContext.requestSession;
      }
      if (scopeContext.propagationContext) {
        this._propagationContext = scopeContext.propagationContext;
      }
    }

    return this;
  }

  /**
   * @inheritDoc
   */
   clear() {
    // client is not cleared here on purpose!
    this._breadcrumbs = [];
    this._tags = {};
    this._extra = {};
    this._user = {};
    this._contexts = {};
    this._level = undefined;
    this._transactionName = undefined;
    this._fingerprint = undefined;
    this._requestSession = undefined;
    this._span = undefined;
    this._session = undefined;
    this._notifyScopeListeners();
    this._attachments = [];
    this._propagationContext = generatePropagationContext();
    return this;
  }

  /**
   * @inheritDoc
   */
   addBreadcrumb(breadcrumb, maxBreadcrumbs) {
    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;

    // No data has been changed, so don't notify scope listeners
    if (maxCrumbs <= 0) {
      return this;
    }

    const mergedBreadcrumb = {
      timestamp: dateTimestampInSeconds(),
      ...breadcrumb,
    };

    const breadcrumbs = this._breadcrumbs;
    breadcrumbs.push(mergedBreadcrumb);
    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;

    this._notifyScopeListeners();

    return this;
  }

  /**
   * @inheritDoc
   */
   getLastBreadcrumb() {
    return this._breadcrumbs[this._breadcrumbs.length - 1];
  }

  /**
   * @inheritDoc
   */
   clearBreadcrumbs() {
    this._breadcrumbs = [];
    this._notifyScopeListeners();
    return this;
  }

  /**
   * @inheritDoc
   */
   addAttachment(attachment) {
    this._attachments.push(attachment);
    return this;
  }

  /**
   * @inheritDoc
   * @deprecated Use `getScopeData()` instead.
   */
   getAttachments() {
    const data = this.getScopeData();

    return data.attachments;
  }

  /**
   * @inheritDoc
   */
   clearAttachments() {
    this._attachments = [];
    return this;
  }

  /** @inheritDoc */
   getScopeData() {
    const {
      _breadcrumbs,
      _attachments,
      _contexts,
      _tags,
      _extra,
      _user,
      _level,
      _fingerprint,
      _eventProcessors,
      _propagationContext,
      _sdkProcessingMetadata,
      _transactionName,
      _span,
    } = this;

    return {
      breadcrumbs: _breadcrumbs,
      attachments: _attachments,
      contexts: _contexts,
      tags: _tags,
      extra: _extra,
      user: _user,
      level: _level,
      fingerprint: _fingerprint || [],
      eventProcessors: _eventProcessors,
      propagationContext: _propagationContext,
      sdkProcessingMetadata: _sdkProcessingMetadata,
      transactionName: _transactionName,
      span: _span,
    };
  }

  /**
   * @inheritDoc
   */
   setSDKProcessingMetadata(newData) {
    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };

    return this;
  }

  /**
   * @inheritDoc
   */
   setPropagationContext(context) {
    this._propagationContext = context;
    return this;
  }

  /**
   * @inheritDoc
   */
   getPropagationContext() {
    return this._propagationContext;
  }

  /**
   * @inheritDoc
   */
   captureException(exception, hint) {
    const eventId = hint && hint.event_id ? hint.event_id : uuid4();

    if (!this._client) {
      logger.warn('No client configured on scope - will not capture exception!');
      return eventId;
    }

    const syntheticException = new Error('Sentry syntheticException');

    this._client.captureException(
      exception,
      {
        originalException: exception,
        syntheticException,
        ...hint,
        event_id: eventId,
      },
      this,
    );

    return eventId;
  }

  /**
   * @inheritDoc
   */
   captureMessage(message, level, hint) {
    const eventId = hint && hint.event_id ? hint.event_id : uuid4();

    if (!this._client) {
      logger.warn('No client configured on scope - will not capture message!');
      return eventId;
    }

    const syntheticException = new Error(message);

    this._client.captureMessage(
      message,
      level,
      {
        originalException: message,
        syntheticException,
        ...hint,
        event_id: eventId,
      },
      this,
    );

    return eventId;
  }

  /**
   * @inheritDoc
   */
   captureEvent(event, hint) {
    const eventId = hint && hint.event_id ? hint.event_id : uuid4();

    if (!this._client) {
      logger.warn('No client configured on scope - will not capture event!');
      return eventId;
    }

    this._client.captureEvent(event, { ...hint, event_id: eventId }, this);

    return eventId;
  }

  /**
   * This will be called on every set call.
   */
   _notifyScopeListeners() {
    // We need this check for this._notifyingListeners to be able to work on scope during updates
    // If this check is not here we'll produce endless recursion when something is done with the scope
    // during the callback.
    if (!this._notifyingListeners) {
      this._notifyingListeners = true;
      this._scopeListeners.forEach(callback => {
        callback(this);
      });
      this._notifyingListeners = false;
    }
  }
}

function generatePropagationContext() {
  return {
    traceId: uuid4(),
    spanId: uuid4().substring(16),
  };
}

const SDK_VERSION = '8.0.0-alpha.3';

/**
 * API compatibility version of this hub.
 *
 * WARNING: This number should only be increased when the global interface
 * changes and new methods are introduced.
 *
 * @hidden
 */
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$1 = 100;

/**
 * A layer in the process stack.
 * @hidden
 */

/**
 * @inheritDoc
 */
class Hub  {
  /** Is a {@link Layer}[] containing the client and scope */

  /**
   * Creates a new instance of the hub, will push one {@link Layer} into the
   * internal stack on creation.
   *
   * @param client bound to the hub.
   * @param scope bound to the hub.
   * @param version number, higher number means higher priority.
   *
   * @deprecated Instantiation of Hub objects is deprecated and the constructor will be removed in version 8 of the SDK.
   *
   * If you are currently using the Hub for multi-client use like so:
   *
   * ```
   * // OLD
   * const hub = new Hub();
   * hub.bindClient(client);
   * makeMain(hub)
   * ```
   *
   * instead initialize the client as follows:
   *
   * ```
   * // NEW
   * Sentry.withIsolationScope(() => {
   *    Sentry.setCurrentClient(client);
   *    client.init();
   * });
   * ```
   *
   * If you are using the Hub to capture events like so:
   *
   * ```
   * // OLD
   * const client = new Client();
   * const hub = new Hub(client);
   * hub.captureException()
   * ```
   *
   * instead capture isolated events as follows:
   *
   * ```
   * // NEW
   * const client = new Client();
   * const scope = new Scope();
   * scope.setClient(client);
   * scope.captureException();
   * ```
   */
   constructor(
    client,
    scope,
    isolationScope,
      _version = API_VERSION,
  ) {this._version = _version;
    let assignedScope;
    if (!scope) {
      assignedScope = new Scope();
      assignedScope.setClient(client);
    } else {
      assignedScope = scope;
    }

    let assignedIsolationScope;
    if (!isolationScope) {
      assignedIsolationScope = new Scope();
      assignedIsolationScope.setClient(client);
    } else {
      assignedIsolationScope = isolationScope;
    }

    this._stack = [{ scope: assignedScope }];

    if (client) {
      // eslint-disable-next-line deprecation/deprecation
      this.bindClient(client);
    }

    this._isolationScope = assignedIsolationScope;
  }

  /**
   * Checks if this hub's version is older than the given version.
   *
   * @param version A version number to compare to.
   * @return True if the given version is newer; otherwise false.
   *
   * @deprecated This will be removed in v8.
   */
   isOlderThan(version) {
    return this._version < version;
  }

  /**
   * This binds the given client to the current scope.
   * @param client An SDK client (client) instance.
   *
   * @deprecated Use `initAndBind()` directly, or `setCurrentClient()` and/or `client.init()` instead.
   */
   bindClient(client) {
    // eslint-disable-next-line deprecation/deprecation
    const top = this.getStackTop();
    top.client = client;
    top.scope.setClient(client);
    // eslint-disable-next-line deprecation/deprecation
    if (client && client.setupIntegrations) {
      // eslint-disable-next-line deprecation/deprecation
      client.setupIntegrations();
    }
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `withScope` instead.
   */
   pushScope() {
    // We want to clone the content of prev scope
    // eslint-disable-next-line deprecation/deprecation
    const scope = this.getScope().clone();
    // eslint-disable-next-line deprecation/deprecation
    this.getStack().push({
      // eslint-disable-next-line deprecation/deprecation
      client: this.getClient(),
      scope,
    });
    return scope;
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `withScope` instead.
   */
   popScope() {
    // eslint-disable-next-line deprecation/deprecation
    if (this.getStack().length <= 1) return false;
    // eslint-disable-next-line deprecation/deprecation
    return !!this.getStack().pop();
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `Sentry.withScope()` instead.
   */
   withScope(callback) {
    // eslint-disable-next-line deprecation/deprecation
    const scope = this.pushScope();

    let maybePromiseResult;
    try {
      maybePromiseResult = callback(scope);
    } catch (e) {
      // eslint-disable-next-line deprecation/deprecation
      this.popScope();
      throw e;
    }

    if (isThenable(maybePromiseResult)) {
      // @ts-expect-error - isThenable returns the wrong type
      return maybePromiseResult.then(
        res => {
          // eslint-disable-next-line deprecation/deprecation
          this.popScope();
          return res;
        },
        e => {
          // eslint-disable-next-line deprecation/deprecation
          this.popScope();
          throw e;
        },
      );
    }

    // eslint-disable-next-line deprecation/deprecation
    this.popScope();
    return maybePromiseResult;
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `Sentry.getClient()` instead.
   */
   getClient() {
    // eslint-disable-next-line deprecation/deprecation
    return this.getStackTop().client ;
  }

  /**
   * Returns the scope of the top stack.
   *
   * @deprecated Use `Sentry.getCurrentScope()` instead.
   */
   getScope() {
    // eslint-disable-next-line deprecation/deprecation
    return this.getStackTop().scope;
  }

  /**
   * @deprecated Use `Sentry.getIsolationScope()` instead.
   */
   getIsolationScope() {
    return this._isolationScope;
  }

  /**
   * Returns the scope stack for domains or the process.
   * @deprecated This will be removed in v8.
   */
   getStack() {
    return this._stack;
  }

  /**
   * Returns the topmost scope layer in the order domain > local > process.
   * @deprecated This will be removed in v8.
   */
   getStackTop() {
    return this._stack[this._stack.length - 1];
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `Sentry.captureException()` instead.
   */
   captureException(exception, hint) {
    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, {
      originalException: exception,
      syntheticException,
      ...hint,
      event_id: eventId,
    });

    return eventId;
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use  `Sentry.captureMessage()` instead.
   */
   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, {
      originalException: message,
      syntheticException,
      ...hint,
      event_id: eventId,
    });

    return eventId;
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `Sentry.captureEvent()` instead.
   */
   captureEvent(event, hint) {
    const eventId = hint && hint.event_id ? hint.event_id : uuid4();
    // eslint-disable-next-line deprecation/deprecation
    this.getScope().captureEvent(event, { ...hint, event_id: eventId });
    return eventId;
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use `Sentry.addBreadcrumb()` instead.
   */
   addBreadcrumb(breadcrumb, hint) {
    // eslint-disable-next-line deprecation/deprecation
    const { client } = this.getStackTop();

    if (!client) return;

    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS$1 } =
      (client.getOptions && client.getOptions()) || {};

    if (maxBreadcrumbs <= 0) return;

    const timestamp = dateTimestampInSeconds();
    const mergedBreadcrumb = { timestamp, ...breadcrumb };
    const finalBreadcrumb = beforeBreadcrumb
      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )
      : mergedBreadcrumb;

    if (finalBreadcrumb === null) return;

    client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);

    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setUser()` instead.
   */
   setUser(user) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setUser(user);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setTags()` instead.
   */
   setTags(tags) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setTags(tags);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setExtras()` instead.
   */
   setExtras(extras) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setExtras(extras);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setTag()` instead.
   */
   setTag(key, value) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setTag(key, value);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setExtra()` instead.
   */
   setExtra(key, extra) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setExtra(key, extra);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.setContext()` instead.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   setContext(name, context) {
    // eslint-disable-next-line deprecation/deprecation
    this.getIsolationScope().setContext(name, context);
  }

  /**
   * @inheritDoc
   * @deprecated Use `Sentry.getClient().getIntegrationByName()` instead.
   */
   getIntegration(integration) {
    // eslint-disable-next-line deprecation/deprecation
    const client = this.getClient();
    if (!client) return null;
    try {
      // 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`);
      return null;
    }
  }

  /**
   * @inheritDoc
   *
   * @deprecated Use top level `captureSession` instead.
   */
   captureSession(endSession = false) {
    // both send the update and pull the session from the scope
    if (endSession) {
      // eslint-disable-next-line deprecation/deprecation
      return this.endSession();
    }

    // only send the update
    this._sendSessionUpdate();
  }

  /**
   * @inheritDoc
   * @deprecated Use top level `endSession` instead.
   */
   endSession() {
    // eslint-disable-next-line deprecation/deprecation
    const layer = this.getStackTop();
    const scope = layer.scope;
    const session = scope.getSession();
    if (session) {
      closeSession(session);
    }
    this._sendSessionUpdate();

    // the session is over; take it off of the scope
    scope.setSession();
  }

  /**
   * @inheritDoc
   * @deprecated Use top level `startSession` instead.
   */
   startSession(context) {
    // eslint-disable-next-line deprecation/deprecation
    const { scope, client } = this.getStackTop();
    const { release, environment = DEFAULT_ENVIRONMENT } = (client && client.getOptions()) || {};

    // Will fetch userAgent if called from browser sdk
    const { userAgent } = GLOBAL_OBJ.navigator || {};

    const session = makeSession({
      release,
      environment,
      user: scope.getUser(),
      ...(userAgent && { userAgent }),
      ...context,
    });

    // End existing session if there's one
    const currentSession = scope.getSession && scope.getSession();
    if (currentSession && currentSession.status === 'ok') {
      updateSession(currentSession, { status: 'exited' });
    }
    // eslint-disable-next-line deprecation/deprecation
    this.endSession();

    // Afterwards we set the new session on the scope
    scope.setSession(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 && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
  }
}

/** 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;

/**
 * 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(),
      });
    }

    // 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';
}

/** 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';
}

/**
 * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
 * Merge with existing data if any.
 **/
function enhanceEventWithSdkInfo(event, sdkInfo) {
  if (!sdkInfo) {
    return event;
  }
  event.sdk = event.sdk || {};
  event.sdk.name = event.sdk.name || sdkInfo.name;
  event.sdk.version = event.sdk.version || sdkInfo.version;
  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];
  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];
  return event;
}

/** Creates an envelope from a Session */
function createSessionEnvelope(
  session,
  dsn,
  metadata,
  tunnel,
) {
  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
  const envelopeHeaders = {
    sent_at: new Date().toISOString(),
    ...(sdkInfo && { sdk: sdkInfo }),
    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),
  };

  const envelopeItem =
    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];

  return createEnvelope(envelopeHeaders, [envelopeItem]);
}

/**
 * Create an Envelope from an event.
 */
function createEventEnvelope(
  event,
  dsn,
  metadata,
  tunnel,
) {
  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);

  /*
    Note: Due to TS, event.type may be `replay_event`, theoretically.
    In practice, we never call `createEventEnvelope` with `replay_event` type,
    and we'd have to adjut a looot of types to make this work properly.
    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)
    So the safe choice is to really guard against the replay_event type here.
  */
  const eventType = event.type && event.type !== 'replay_event' ? event.type : 'event';

  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);

  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);

  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to
  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may
  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid
  // of this `delete`, lest we miss putting it back in the next time the property is in use.)
  delete event.sdkProcessingMetadata;

  const eventItem = [{ type: eventType }, event];
  return createEnvelope(envelopeHeaders, [eventItem]);
}

const SENTRY_API_VERSION = '7';

/** Returns the prefix to construct Sentry ingestion API endpoints. */
function getBaseApiEndpoint(dsn) {
  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
  const port = dsn.port ? `:${dsn.port}` : '';
  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
}

/** Returns the ingest API endpoint for target. */
function _getIngestEndpoint(dsn) {
  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
}

/** Returns a URL-encoded string with auth config suitable for a query string. */
function _encodedAuth(dsn, sdkInfo) {
  return urlEncode({
    // We send only the minimum set of required information. See
    // https://github.com/getsentry/sentry-javascript/issues/2572.
    sentry_key: dsn.publicKey,
    sentry_version: SENTRY_API_VERSION,
    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),
  });
}

/**
 * Returns the envelope endpoint URL with auth in the query string.
 *
 * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
 */
function getEnvelopeEndpointWithUrlEncodedAuth(
  dsn,
  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below
  // options: ClientOptions = {} as ClientOptions,
  tunnelOrOptions = {} ,
) {
  // TODO (v8): Use this code instead
  // const { tunnel, _metadata = {} } = options;
  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;

  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;
  const sdkInfo =
    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;

  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
}

/**
 * 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;
}

const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;

/**
 * Creates an instance of a Sentry `Transport`
 *
 * @param options
 * @param makeRequest
 */
function createTransport(
  options,
  makeRequest,
  buffer = makePromiseBuffer(
    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,
  ),
) {
  let rateLimits = {};
  const flush = (timeout) => buffer.drain(timeout);

  function send(envelope) {
    const filteredEnvelopeItems = [];

    // Drop rate limited items from envelope
    forEachEnvelopeItem(envelope, (item, type) => {
      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);
      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {
        const event = getEventForEnvelopeItem(item, type);
        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory, event);
      } else {
        filteredEnvelopeItems.push(item);
      }
    });

    // Skip sending if envelope is empty after filtering out rate limited events
    if (filteredEnvelopeItems.length === 0) {
      return resolvedSyncPromise({});
    }

    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );

    // Creates client report for each item in an envelope
    const recordEnvelopeLoss = (reason) => {
      forEachEnvelopeItem(filteredEnvelope, (item, type) => {
        const event = getEventForEnvelopeItem(item, type);
        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);
      });
    };

    const requestTask = () =>
      makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then(
        response => {
          // We don't want to throw on NOK responses, but we want to at least log them
          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {
            DEBUG_BUILD && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
          }

          rateLimits = updateRateLimits(rateLimits, response);
          return response;
        },
        error => {
          recordEnvelopeLoss('network_error');
          throw error;
        },
      );

    return buffer.add(requestTask).then(
      result => result,
      error => {
        if (error instanceof SentryError) {
          DEBUG_BUILD && logger.error('Skipped sending event because buffer is full.');
          recordEnvelopeLoss('queue_overflow');
          return resolvedSyncPromise({});
        } else {
          throw error;
        }
      },
    );
  }

  return {
    send,
    flush,
  };
}

function getEventForEnvelopeItem(item, type) {
  if (type !== 'event' && type !== 'transaction') {
    return undefined;
  }

  return Array.isArray(item) ? (item )[1] : undefined;
}

/** 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();

function ensureMetadataStacksAreParsed(parser) {
  if (!GLOBAL_OBJ._sentryModuleMetadata) {
    return;
  }

  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {
    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];

    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;
      }
    }
  }
}

/**
 * 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);
}

/**
 * Adds metadata to stack frames.
 *
 * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.
 */
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.
  }
}

/**
 * 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.
 *
 * 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 ),
            },
    },
  };

  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.
 */
// 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);
    }
  }

  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;
  }

  return {
    include: {
      ip,
      user: addReqDataUserOpt,
      request: requestIncludeKeys.length !== 0 ? requestIncludeKeys : undefined,
      transaction: transactionNamingScheme,
    },
  };
}

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);
    },
  };
}) ;

/**
 * Patch toString calls to return proper name for wrapped functions.
 *
 * ```js
 * Sentry.init({
 *   integrations: [
 *     functionToStringIntegration(),
 *   ],
 * });
 * ```
 */
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,
) ;

function _nullishCoalesce$2(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }/**
 * This code was originally forked from https://github.com/TooTallNate/proxy-agents/tree/b133295fd16f6475578b6b15bd9b4e33ecb0d0b7
 * With the following licence:
 *
 * (The MIT License)
 *
 * Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>*
 *
 * 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.
 */

const INTERNAL = Symbol('AgentBaseInternalState');

class Agent extends http.Agent {

  // Set by `http.Agent` - missing from `@types/node`

  constructor(opts) {
    super(opts);
    this[INTERNAL] = {};
  }

  /**
   * Determine whether this is an `http` or `https` request.
   */
  isSecureEndpoint(options) {
    if (options) {
      // First check the `secureEndpoint` property explicitly, since this
      // means that a parent `Agent` is "passing through" to this instance.
      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
      if (typeof (options ).secureEndpoint === 'boolean') {
        return options.secureEndpoint;
      }

      // If no explicit `secure` endpoint, check if `protocol` property is
      // set. This will usually be the case since using a full string URL
      // or `URL` instance should be the most common usage.
      if (typeof options.protocol === 'string') {
        return options.protocol === 'https:';
      }
    }

    // Finally, if no `protocol` property was set, then fall back to
    // checking the stack trace of the current call stack, and try to
    // detect the "https" module.
    const { stack } = new Error();
    if (typeof stack !== 'string') return false;
    return stack.split('\n').some(l => l.indexOf('(https.js:') !== -1 || l.indexOf('node:https:') !== -1);
  }

  createSocket(req, options, cb) {
    const connectOpts = {
      ...options,
      secureEndpoint: this.isSecureEndpoint(options),
    };
    Promise.resolve()
      .then(() => this.connect(req, connectOpts))
      .then(socket => {
        if (socket instanceof http.Agent) {
          // @ts-expect-error `addRequest()` isn't defined in `@types/node`
          return socket.addRequest(req, connectOpts);
        }
        this[INTERNAL].currentSocket = socket;
        // @ts-expect-error `createSocket()` isn't defined in `@types/node`
        super.createSocket(req, options, cb);
      }, cb);
  }

  createConnection() {
    const socket = this[INTERNAL].currentSocket;
    this[INTERNAL].currentSocket = undefined;
    if (!socket) {
      throw new Error('No socket was returned in the `connect()` function');
    }
    return socket;
  }

  get defaultPort() {
    return _nullishCoalesce$2(this[INTERNAL].defaultPort, () => ( (this.protocol === 'https:' ? 443 : 80)));
  }

  set defaultPort(v) {
    if (this[INTERNAL]) {
      this[INTERNAL].defaultPort = v;
    }
  }

  get protocol() {
    return _nullishCoalesce$2(this[INTERNAL].protocol, () => ( (this.isSecureEndpoint() ? 'https:' : 'http:')));
  }

  set protocol(v) {
    if (this[INTERNAL]) {
      this[INTERNAL].protocol = v;
    }
  }
}

function debug$1(...args) {
  logger.log('[https-proxy-agent:parse-proxy-response]', ...args);
}

function parseProxyResponse(socket) {
  return new Promise((resolve, reject) => {
    // we need to buffer any HTTP traffic that happens with the proxy before we get
    // the CONNECT response, so that if the response is anything other than an "200"
    // response code, then we can re-play the "data" events on the socket once the
    // HTTP parser is hooked up...
    let buffersLength = 0;
    const buffers = [];

    function read() {
      const b = socket.read();
      if (b) ondata(b);
      else socket.once('readable', read);
    }

    function cleanup() {
      socket.removeListener('end', onend);
      socket.removeListener('error', onerror);
      socket.removeListener('readable', read);
    }

    function onend() {
      cleanup();
      debug$1('onend');
      reject(new Error('Proxy connection ended before receiving CONNECT response'));
    }

    function onerror(err) {
      cleanup();
      debug$1('onerror %o', err);
      reject(err);
    }

    function ondata(b) {
      buffers.push(b);
      buffersLength += b.length;

      const buffered = Buffer.concat(buffers, buffersLength);
      const endOfHeaders = buffered.indexOf('\r\n\r\n');

      if (endOfHeaders === -1) {
        // keep buffering
        debug$1('have not received end of HTTP headers yet...');
        read();
        return;
      }

      const headerParts = buffered.slice(0, endOfHeaders).toString('ascii').split('\r\n');
      const firstLine = headerParts.shift();
      if (!firstLine) {
        socket.destroy();
        return reject(new Error('No header received from proxy CONNECT response'));
      }
      const firstLineParts = firstLine.split(' ');
      const statusCode = +firstLineParts[1];
      const statusText = firstLineParts.slice(2).join(' ');
      const headers = {};
      for (const header of headerParts) {
        if (!header) continue;
        const firstColon = header.indexOf(':');
        if (firstColon === -1) {
          socket.destroy();
          return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
        }
        const key = header.slice(0, firstColon).toLowerCase();
        const value = header.slice(firstColon + 1).trimStart();
        const current = headers[key];
        if (typeof current === 'string') {
          headers[key] = [current, value];
        } else if (Array.isArray(current)) {
          current.push(value);
        } else {
          headers[key] = value;
        }
      }
      debug$1('got proxy server response: %o %o', firstLine, headers);
      cleanup();
      resolve({
        connect: {
          statusCode,
          statusText,
          headers,
        },
        buffered,
      });
    }

    socket.on('error', onerror);
    socket.on('end', onend);

    read();
  });
}

function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }

function debug(...args) {
  logger.log('[https-proxy-agent]', ...args);
}

/**
 * The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
 * the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
 *
 * Outgoing HTTP requests are first tunneled through the proxy server using the
 * `CONNECT` HTTP request method to establish a connection to the proxy server,
 * and then the proxy server connects to the destination target and issues the
 * HTTP request from the proxy server.
 *
 * `https:` requests have their socket connection upgraded to TLS once
 * the connection to the proxy server has been established.
 */
class HttpsProxyAgent extends Agent {
  static __initStatic() {this.protocols = ['http', 'https']; }

  constructor(proxy, opts) {
    super(opts);
    this.options = {};
    this.proxy = typeof proxy === 'string' ? new URL(proxy) : proxy;
    this.proxyHeaders = _nullishCoalesce$1(_optionalChain$1([opts, 'optionalAccess', _2 => _2.headers]), () => ( {}));
    debug('Creating new HttpsProxyAgent instance: %o', this.proxy.href);

    // Trim off the brackets from IPv6 addresses
    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, '');
    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === 'https:' ? 443 : 80;
    this.connectOpts = {
      // Attempt to negotiate http/1.1 for proxy servers that support http/2
      ALPNProtocols: ['http/1.1'],
      ...(opts ? omit(opts, 'headers') : null),
      host,
      port,
    };
  }

  /**
   * Called when the node-core HTTP client library is creating a
   * new HTTP request.
   */
  async connect(req, opts) {
    const { proxy } = this;

    if (!opts.host) {
      throw new TypeError('No "host" provided');
    }

    // Create a socket connection to the proxy server.
    let socket;
    if (proxy.protocol === 'https:') {
      debug('Creating `tls.Socket`: %o', this.connectOpts);
      const servername = this.connectOpts.servername || this.connectOpts.host;
      socket = tls.connect({
        ...this.connectOpts,
        servername: servername && net.isIP(servername) ? undefined : servername,
      });
    } else {
      debug('Creating `net.Socket`: %o', this.connectOpts);
      socket = net.connect(this.connectOpts);
    }

    const headers =
      typeof this.proxyHeaders === 'function' ? this.proxyHeaders() : { ...this.proxyHeaders };
    const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
    let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;

    // Inject the `Proxy-Authorization` header if necessary.
    if (proxy.username || proxy.password) {
      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
      headers['Proxy-Authorization'] = `Basic ${Buffer.from(auth).toString('base64')}`;
    }

    headers.Host = `${host}:${opts.port}`;

    if (!headers['Proxy-Connection']) {
      headers['Proxy-Connection'] = this.keepAlive ? 'Keep-Alive' : 'close';
    }
    for (const name of Object.keys(headers)) {
      payload += `${name}: ${headers[name]}\r\n`;
    }

    const proxyResponsePromise = parseProxyResponse(socket);

    socket.write(`${payload}\r\n`);

    const { connect, buffered } = await proxyResponsePromise;
    req.emit('proxyConnect', connect);
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-ignore Not EventEmitter in Node types
    this.emit('proxyConnect', connect, req);

    if (connect.statusCode === 200) {
      req.once('socket', resume);

      if (opts.secureEndpoint) {
        // The proxy is connecting to a TLS server, so upgrade
        // this socket connection to a TLS connection.
        debug('Upgrading socket connection to TLS');
        const servername = opts.servername || opts.host;
        return tls.connect({
          ...omit(opts, 'host', 'path', 'port'),
          socket,
          servername: net.isIP(servername) ? undefined : servername,
        });
      }

      return socket;
    }

    // Some other status code that's not 200... need to re-play the HTTP
    // header "data" events onto the socket once the HTTP machinery is
    // attached so that the node core `http` can parse and handle the
    // error status code.

    // Close the original socket, and a new "fake" socket is returned
    // instead, so that the proxy doesn't get the HTTP request
    // written to it (which may contain `Authorization` headers or other
    // sensitive data).
    //
    // See: https://hackerone.com/reports/541502
    socket.destroy();

    const fakeSocket = new net.Socket({ writable: false });
    fakeSocket.readable = true;

    // Need to wait for the "socket" event to re-play the "data" events.
    req.once('socket', (s) => {
      debug('Replaying proxy buffer for failed request');
      // Replay the "buffered" Buffer onto the fake `socket`, since at
      // this point the HTTP module machinery has been hooked up for
      // the user.
      s.push(buffered);
      s.push(null);
    });

    return fakeSocket;
  }
} HttpsProxyAgent.__initStatic();

function resume(socket) {
  socket.resume();
}

function omit(
  obj,
  ...keys
)

 {
  const ret = {}

;
  let key;
  for (key in obj) {
    if (!keys.includes(key)) {
      ret[key] = obj[key];
    }
  }
  return ret;
}

function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
// Estimated maximum size for reasonable standalone event
const GZIP_THRESHOLD = 1024 * 32;

/**
 * Gets a stream from a Uint8Array or string
 * Readable.from is ideal but was added in node.js v12.3.0 and v10.17.0
 */
function streamFromBody(body) {
  return new Readable({
    read() {
      this.push(body);
      this.push(null);
    },
  });
}

/**
 * Creates a Transport that uses native the native 'http' and 'https' modules to send events to Sentry.
 */
function makeNodeTransport(options) {
  let urlSegments;

  try {
    urlSegments = new URL(options.url);
  } catch (e) {
    consoleSandbox(() => {
      // eslint-disable-next-line no-console
      console.warn(
        '[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used.',
      );
    });
    return createTransport(options, () => Promise.resolve({}));
  }

  const isHttps = urlSegments.protocol === 'https:';

  // Proxy prioritization: http => `options.proxy` | `process.env.http_proxy`
  // Proxy prioritization: https => `options.proxy` | `process.env.https_proxy` | `process.env.http_proxy`
  const proxy = applyNoProxyOption(
    urlSegments,
    options.proxy || (isHttps ? process.env.https_proxy : undefined) || process.env.http_proxy,
  );

  const nativeHttpModule = isHttps ? https : http$1;
  const keepAlive = options.keepAlive === undefined ? false : options.keepAlive;

  // TODO(v7): Evaluate if we can set keepAlive to true. This would involve testing for memory leaks in older node
  // versions(>= 8) as they had memory leaks when using it: #2555
  const agent = proxy
    ? (new HttpsProxyAgent(proxy) )
    : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2000 });

  const requestExecutor = createRequestExecutor(options, _nullishCoalesce(options.httpModule, () => ( nativeHttpModule)), agent);
  return createTransport(options, requestExecutor);
}

/**
 * Honors the `no_proxy` env variable with the highest priority to allow for hosts exclusion.
 *
 * @param transportUrl The URL the transport intends to send events to.
 * @param proxy The client configured proxy.
 * @returns A proxy the transport should use.
 */
function applyNoProxyOption(transportUrlSegments, proxy) {
  const { no_proxy } = process.env;

  const urlIsExemptFromProxy =
    no_proxy &&
    no_proxy
      .split(',')
      .some(
        exemption => transportUrlSegments.host.endsWith(exemption) || transportUrlSegments.hostname.endsWith(exemption),
      );

  if (urlIsExemptFromProxy) {
    return undefined;
  } else {
    return proxy;
  }
}

/**
 * Creates a RequestExecutor to be used with `createTransport`.
 */
function createRequestExecutor(
  options,
  httpModule,
  agent,
) {
  const { hostname, pathname, port, protocol, search } = new URL(options.url);
  return function makeRequest(request) {
    return new Promise((resolve, reject) => {
      let body = streamFromBody(request.body);

      const headers = { ...options.headers };

      if (request.body.length > GZIP_THRESHOLD) {
        headers['content-encoding'] = 'gzip';
        body = body.pipe(createGzip());
      }

      const req = httpModule.request(
        {
          method: 'POST',
          agent,
          headers,
          hostname,
          path: `${pathname}${search}`,
          port,
          protocol,
          ca: options.caCerts,
        },
        res => {
          res.on('data', () => {
            // Drain socket
          });

          res.on('end', () => {
            // Drain socket
          });

          res.setEncoding('utf8');

          // "Key-value pairs of header names and values. Header names are lower-cased."
          // https://nodejs.org/api/http.html#http_message_headers
          const retryAfterHeader = _nullishCoalesce(res.headers['retry-after'], () => ( null));
          const rateLimitsHeader = _nullishCoalesce(res.headers['x-sentry-rate-limits'], () => ( null));

          resolve({
            statusCode: res.statusCode,
            headers: {
              'retry-after': retryAfterHeader,
              'x-sentry-rate-limits': Array.isArray(rateLimitsHeader) ? rateLimitsHeader[0] : rateLimitsHeader,
            },
          });
        },
      );

      req.on('error', reject);
      body.pipe(req);
    });
  };
}

/** normalizes Windows paths */
function normalizeWindowsPath(path) {
  return path
    .replace(/^[A-Z]:/, '') // remove Windows-style prefix
    .replace(/\\/g, '/'); // replace all `\` instances with `/`
}

/** Creates a function that gets the module name from a filename */
function createGetModuleFromFilename(
  basePath = process.argv[1] ? dirname(process.argv[1]) : process.cwd(),
  isWindows = sep === '\\',
) {
  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;

  return (filename) => {
    if (!filename) {
      return;
    }

    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;

    // eslint-disable-next-line prefer-const
    let { dir, base: file, ext } = posix.parse(normalizedFilename);

    if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
      file = file.slice(0, ext.length * -1);
    }

    if (!dir) {
      // No dirname whatsoever
      dir = '.';
    }

    const n = dir.lastIndexOf('/node_modules');
    if (n > -1) {
      return `${dir.slice(n + 14).replace(/\//g, '.')}:${file}`;
    }

    // Let's see if it's a part of the main module
    // To be a part of main module, it has to share the same base
    if (dir.startsWith(normalizedBase)) {
      let moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');

      if (moduleName) {
        moduleName += ':';
      }
      moduleName += file;

      return moduleName;
    }

    return file;
  };
}

function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
const options = workerData;
let session;
let hasSentAnrEvent = false;

function log(msg) {
  if (options.debug) {
    // eslint-disable-next-line no-console
    console.log(`[ANR Worker] ${msg}`);
  }
}

const url = getEnvelopeEndpointWithUrlEncodedAuth(options.dsn);
const transport = makeNodeTransport({
  url,
  recordDroppedEvent: () => {
    //
  },
});

async function sendAbnormalSession() {
  // of we have an existing session passed from the main thread, send it as abnormal
  if (session) {
    log('Sending abnormal session');
    updateSession(session, { status: 'abnormal', abnormal_mechanism: 'anr_foreground' });

    const envelope = createSessionEnvelope(session, options.dsn, options.sdkMetadata);
    // Log the envelope so to aid in testing
    log(JSON.stringify(envelope));

    await transport.send(envelope);

    try {
      // Notify the main process that the session has ended so the session can be cleared from the scope
      _optionalChain([parentPort, 'optionalAccess', _2 => _2.postMessage, 'call', _3 => _3('session-ended')]);
    } catch (_) {
      // ignore
    }
  }
}

log('Started');

function prepareStackFrames(stackFrames) {
  if (!stackFrames) {
    return undefined;
  }

  // Strip Sentry frames and reverse the stack frames so they are in the correct order
  const strippedFrames = stripSentryFramesAndReverse(stackFrames);

  // If we have an app root path, rewrite the filenames to be relative to the app root
  if (options.appRootPath) {
    for (const frame of strippedFrames) {
      if (!frame.filename) {
        continue;
      }

      frame.filename = normalizeUrlToBase(frame.filename, options.appRootPath);
    }
  }

  return strippedFrames;
}

async function sendAnrEvent(frames, traceContext) {
  if (hasSentAnrEvent) {
    return;
  }

  hasSentAnrEvent = true;

  await sendAbnormalSession();

  log('Sending event');

  const event = {
    event_id: uuid4(),
    contexts: { ...options.contexts, trace: traceContext },
    release: options.release,
    environment: options.environment,
    dist: options.dist,
    platform: 'node',
    level: 'error',
    exception: {
      values: [
        {
          type: 'ApplicationNotResponding',
          value: `Application Not Responding for at least ${options.anrThreshold} ms`,
          stacktrace: { frames: prepareStackFrames(frames) },
          // This ensures the UI doesn't say 'Crashed in' for the stack trace
          mechanism: { type: 'ANR' },
        },
      ],
    },
    tags: options.staticTags,
  };

  const envelope = createEventEnvelope(event, options.dsn, options.sdkMetadata);
  // Log the envelope so to aid in testing
  log(JSON.stringify(envelope));

  await transport.send(envelope);
  await transport.flush(2000);

  // Delay for 5 seconds so that stdio can flush in the main event loop ever restarts.
  // This is mainly for the benefit of logging/debugging issues.
  setTimeout(() => {
    process.exit(0);
  }, 5000);
}

let debuggerPause;

if (options.captureStackTrace) {
  log('Connecting to debugger');

  const session = new Session();
  session.connectToMainThread();

  log('Connected to debugger');

  // Collect scriptId -> url map so we can look up the filenames later
  const scripts = new Map();

  session.on('Debugger.scriptParsed', event => {
    scripts.set(event.params.scriptId, event.params.url);
  });

  session.on('Debugger.paused', event => {
    if (event.params.reason !== 'other') {
      return;
    }

    try {
      log('Debugger paused');

      // copy the frames
      const callFrames = [...event.params.callFrames];

      const getModuleName = options.appRootPath ? createGetModuleFromFilename(options.appRootPath) : () => undefined;
      const stackFrames = callFrames.map(frame =>
        callFrameToStackFrame(frame, scripts.get(frame.location.scriptId), getModuleName),
      );

      // Evaluate a script in the currently paused context
      session.post(
        'Runtime.evaluate',
        {
          // Grab the trace context from the current scope
          expression:
            'const ctx = __SENTRY__.acs?.getCurrentScope().getPropagationContext() || {}; ctx.traceId + "-" + ctx.spanId + "-" + ctx.parentSpanId',
          // Don't re-trigger the debugger if this causes an error
          silent: true,
        },
        (_, param) => {
          const traceId = param && param.result ? (param.result.value ) : '--';
          const [trace_id, span_id, parent_span_id] = traceId.split('-') ;

          session.post('Debugger.resume');
          session.post('Debugger.disable');

          const context = _optionalChain([trace_id, 'optionalAccess', _4 => _4.length]) && _optionalChain([span_id, 'optionalAccess', _5 => _5.length]) ? { trace_id, span_id, parent_span_id } : undefined;
          sendAnrEvent(stackFrames, context).then(null, () => {
            log('Sending ANR event failed.');
          });
        },
      );
    } catch (e) {
      session.post('Debugger.resume');
      session.post('Debugger.disable');
      throw e;
    }
  });

  debuggerPause = () => {
    try {
      session.post('Debugger.enable', () => {
        session.post('Debugger.pause');
      });
    } catch (_) {
      //
    }
  };
}

function createHrTimer() {
  // TODO (v8): We can use process.hrtime.bigint() after we drop node v8
  let lastPoll = process.hrtime();

  return {
    getTimeMs: () => {
      const [seconds, nanoSeconds] = process.hrtime(lastPoll);
      return Math.floor(seconds * 1e3 + nanoSeconds / 1e6);
    },
    reset: () => {
      lastPoll = process.hrtime();
    },
  };
}

function watchdogTimeout() {
  log('Watchdog timeout');

  if (debuggerPause) {
    log('Pausing debugger to capture stack trace');
    debuggerPause();
  } else {
    log('Capturing event without a stack trace');
    sendAnrEvent().then(null, () => {
      log('Sending ANR event failed on watchdog timeout.');
    });
  }
}

const { poll } = watchdogTimer(createHrTimer, options.pollInterval, options.anrThreshold, watchdogTimeout);

_optionalChain([parentPort, 'optionalAccess', _6 => _6.on, 'call', _7 => _7('message', (msg) => {
  if (msg.session) {
    session = makeSession(msg.session);
  }

  poll();
})]);';
+
+function _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+const DEFAULT_INTERVAL = 50;
+const DEFAULT_HANG_THRESHOLD = 5000;
+
+function log(message, ...args) {
+  utils.logger.log(`[ANR] ${message}`, ...args);
+}
+
+/**
+ * Gets contexts by calling all event processors. This relies on being called after all integrations are setup
+ */
+async function getContexts(client) {
+  let event = { message: 'ANR' };
+  const eventHint = {};
+
+  for (const processor of client.getEventProcessors()) {
+    if (event === null) break;
+    event = await processor(event, eventHint);
+  }
+
+  return _optionalChain$4([event, 'optionalAccess', _2 => _2.contexts]) || {};
+}
+
+const INTEGRATION_NAME$1 = 'Anr';
+
+const _anrIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME$1,
+    setup(client) {
+      if (NODE_MAJOR < 16 || (NODE_MAJOR === 16 && (NODE_VERSION.minor || 0) < 17)) {
+        throw new Error('ANR detection requires Node 16.17.0 or later');
+      }
+
+      // setImmediate is used to ensure that all other integrations have been setup
+      setImmediate(() => _startWorker(client, options));
+    },
+  };
+}) ;
+
+const anrIntegration = core.defineIntegration(_anrIntegration);
+
+/**
+ * Starts the ANR worker thread
+ */
+async function _startWorker(client, _options) {
+  const contexts = await getContexts(client);
+  const dsn = client.getDsn();
+
+  if (!dsn) {
+    return;
+  }
+
+  // These will not be accurate if sent later from the worker thread
+   _optionalChainDelete([contexts, 'access', _3 => _3.app, 'optionalAccess', _4 => delete _4.app_memory]);
+   _optionalChainDelete([contexts, 'access', _5 => _5.device, 'optionalAccess', _6 => delete _6.free_memory]);
+
+  const initOptions = client.getOptions();
+
+  const sdkMetadata = client.getSdkMetadata() || {};
+  if (sdkMetadata.sdk) {
+    sdkMetadata.sdk.integrations = initOptions.integrations.map(i => i.name);
+  }
+
+  const options = {
+    debug: utils.logger.isEnabled(),
+    dsn,
+    environment: initOptions.environment || 'production',
+    release: initOptions.release,
+    dist: initOptions.dist,
+    sdkMetadata,
+    appRootPath: _options.appRootPath,
+    pollInterval: _options.pollInterval || DEFAULT_INTERVAL,
+    anrThreshold: _options.anrThreshold || DEFAULT_HANG_THRESHOLD,
+    captureStackTrace: !!_options.captureStackTrace,
+    staticTags: _options.staticTags || {},
+    contexts,
+  };
+
+  if (options.captureStackTrace) {
+    if (!inspector.url()) {
+      inspector.open(0);
+    }
+  }
+
+  const worker = new worker_threads.Worker(new URL(`data:application/javascript;base64,${base64WorkerScript}`), {
+    workerData: options,
+  });
+
+  process.on('exit', () => {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    worker.terminate();
+  });
+
+  const timer = setInterval(() => {
+    try {
+      const currentSession = core.getCurrentScope().getSession();
+      // We need to copy the session object and remove the toJSON method so it can be sent to the worker
+      // serialized without making it a SerializedSession
+      const session = currentSession ? { ...currentSession, toJSON: undefined } : undefined;
+      // message the worker to tell it the main event loop is still running
+      worker.postMessage({ session });
+    } catch (_) {
+      //
+    }
+  }, options.pollInterval);
+  // Timer should not block exit
+  timer.unref();
+
+  worker.on('message', (msg) => {
+    if (msg === 'session-ended') {
+      log('ANR event sent from ANR worker. Clearing session in this thread.');
+      core.getCurrentScope().setSession(undefined);
+    }
+  });
+
+  worker.once('error', (err) => {
+    clearInterval(timer);
+    log('ANR worker error', err);
+  });
+
+  worker.once('exit', (code) => {
+    clearInterval(timer);
+    log('ANR worker exit', code);
+  });
+
+  // Ensure this thread can't block app exit
+  worker.unref();
+}
+
+function _optionalChain$3(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+const _expressIntegration = (() => {
+  return {
+    name: 'Express',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationExpress.ExpressInstrumentation({
+            requestHook(span) {
+              addOriginToSpan(span, 'auto.http.otel.express');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Express integration
+ *
+ * Capture tracing data for express.
+ * In order to capture exceptions, you have to call `setupExpressErrorHandler(app)` before any other middleware and after all controllers.
+ */
+const expressIntegration = core.defineIntegration(_expressIntegration);
+
+/**
+ * An Express-compatible error handler.
+ */
+function expressErrorHandler(options
+
+) {
+  return function sentryErrorMiddleware(
+    error,
+    _req,
+    res,
+    next,
+  ) {
+    const shouldHandleError = _optionalChain$3([options, 'optionalAccess', _ => _.shouldHandleError]) || defaultShouldHandleError;
 
+    if (shouldHandleError(error)) {
+      const client = core.getClient();
+      if (client && client.getOptions().autoSessionTracking) {
+        // Check if the `SessionFlusher` is instantiated on the client to go into this branch that marks the
+        // `requestSession.status` as `Crashed`, and this check is necessary because the `SessionFlusher` is only
+        // instantiated when the the`requestHandler` middleware is initialised, which indicates that we should be
+        // running in SessionAggregates mode
+        const isSessionAggregatesMode = client['_sessionFlusher'] !== undefined;
+        if (isSessionAggregatesMode) {
+          const requestSession = core.getIsolationScope().getRequestSession();
+          // If an error bubbles to the `errorHandler`, then this is an unhandled error, and should be reported as a
+          // Crashed session. The `_requestSession.status` is checked to ensure that this error is happening within
+          // the bounds of a request, and if so the status is updated
+          if (requestSession && requestSession.status !== undefined) {
+            requestSession.status = 'crashed';
+          }
+        }
+      }
 
+      const eventId = core.captureException(error, { mechanism: { type: 'middleware', handled: false } });
+      (res ).sentry = eventId;
+      next(error);
+
+      return;
+    }
+
+    next(error);
+  };
+}
+
+/**
+ * Setup an error handler for Express.
+ * The error handler must be before any other middleware and after all controllers.
+ */
+function setupExpressErrorHandler(app) {
+  app.use(expressErrorHandler());
+}
+
+function getStatusCodeFromResponse(error) {
+  const statusCode = error.status || error.statusCode || error.status_code || (error.output && error.output.statusCode);
+  return statusCode ? parseInt(statusCode , 10) : 500;
+}
+
+/** Returns true if response code is internal server error */
+function defaultShouldHandleError(error) {
+  const status = getStatusCodeFromResponse(error);
+  return status >= 500;
+}
+
+const _fastifyIntegration = (() => {
+  return {
+    name: 'Fastify',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationFastify.FastifyInstrumentation({
+            requestHook(span) {
+              addOriginToSpan(span, 'auto.http.otel.fastify');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Express integration
+ *
+ * Capture tracing data for fastify.
+ */
+const fastifyIntegration = core.defineIntegration(_fastifyIntegration);
+
+// We inline the types we care about here
+
+/**
+ * Setup an error handler for Fastify.
+ */
+function setupFastifyErrorHandler(fastify) {
+  const plugin = Object.assign(
+    function (fastify, options, done) {
+      fastify.addHook('onError', async (_request, _reply, error) => {
+        core.captureException(error);
+      });
+
+      done();
+    },
+    {
+      [Symbol.for('skip-override')]: true,
+      [Symbol.for('fastify.display-name')]: 'sentry-fastify-error-handler',
+    },
+  );
+
+  fastify.register(plugin);
+}
+
+const _graphqlIntegration = (() => {
+  return {
+    name: 'Graphql',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationGraphql.GraphQLInstrumentation({
+            ignoreTrivialResolveSpans: true,
+            responseHook(span) {
+              addOriginToSpan(span, 'auto.graphql.otel.graphql');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * GraphQL integration
+ *
+ * Capture tracing data for GraphQL.
+ */
+const graphqlIntegration = core.defineIntegration(_graphqlIntegration);
+
+const _mongoIntegration = (() => {
+  return {
+    name: 'Mongo',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationMongodb.MongoDBInstrumentation({
+            responseHook(span) {
+              addOriginToSpan(span, 'auto.db.otel.mongo');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * MongoDB integration
+ *
+ * Capture tracing data for MongoDB.
+ */
+const mongoIntegration = core.defineIntegration(_mongoIntegration);
+
+const _mongooseIntegration = (() => {
+  return {
+    name: 'Mongoose',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationMongoose.MongooseInstrumentation({
+            responseHook(span) {
+              addOriginToSpan(span, 'auto.db.otel.mongoose');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Mongoose integration
+ *
+ * Capture tracing data for Mongoose.
+ */
+const mongooseIntegration = core.defineIntegration(_mongooseIntegration);
+
+const _mysqlIntegration = (() => {
+  return {
+    name: 'Mysql',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [new instrumentationMysql.MySQLInstrumentation({})],
+      });
+    },
+  };
+}) ;
+
+/**
+ * MySQL integration
+ *
+ * Capture tracing data for mysql.
+ */
+const mysqlIntegration = core.defineIntegration(_mysqlIntegration);
+
+const _mysql2Integration = (() => {
+  return {
+    name: 'Mysql2',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationMysql2.MySQL2Instrumentation({
+            responseHook(span) {
+              addOriginToSpan(span, 'auto.db.otel.mysql2');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * MySQL2 integration
+ *
+ * Capture tracing data for mysql2
+ */
+const mysql2Integration = core.defineIntegration(_mysql2Integration);
+
+const _nestIntegration = (() => {
+  return {
+    name: 'Nest',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [new instrumentationNestjsCore.NestInstrumentation({})],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Nest framework integration
+ *
+ * Capture tracing data for nest.
+ */
+const nestIntegration = core.defineIntegration(_nestIntegration);
+
+const _postgresIntegration = (() => {
+  return {
+    name: 'Postgres',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          new instrumentationPg.PgInstrumentation({
+            requireParentSpan: true,
+            requestHook(span) {
+              addOriginToSpan(span, 'auto.db.otel.postgres');
+            },
+          }),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Postgres integration
+ *
+ * Capture tracing data for pg.
+ */
+const postgresIntegration = core.defineIntegration(_postgresIntegration);
+
+const _prismaIntegration = (() => {
+  return {
+    name: 'Prisma',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [
+          // does not have a hook to adjust spans & add origin
+          new prismaInstrumentation.PrismaInstrumentation({}),
+        ],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Prisma integration
+ *
+ * Capture tracing data for prisma.
+ * Note: This requieres to set:
+ * previewFeatures = ["tracing"]
+ * For the prisma client.
+ * See https://www.prisma.io/docs/concepts/components/prisma-client/opentelemetry-tracing for more details.
+ */
+const prismaIntegration = core.defineIntegration(_prismaIntegration);
+
+const _hapiIntegration = (() => {
+  return {
+    name: 'Hapi',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [new instrumentationHapi.HapiInstrumentation()],
+      });
+    },
+  };
+}) ;
+
+/**
+ * Hapi integration
+ *
+ * Capture tracing data for Hapi.
+ * If you also want to capture errors, you need to call `setupHapiErrorHandler(server)` after you set up your server.
+ */
+const hapiIntegration = core.defineIntegration(_hapiIntegration);
+
+function isBoomObject(response) {
+  return response && (response ).isBoom !== undefined;
+}
+
+function isErrorEvent(event) {
+  return event && (event ).error !== undefined;
+}
+
+function sendErrorToSentry(errorData) {
+  core.captureException(errorData, {
+    mechanism: {
+      type: 'hapi',
+      handled: false,
+      data: {
+        function: 'hapiErrorPlugin',
+      },
+    },
+  });
+}
+
+const hapiErrorPlugin = {
+  name: 'SentryHapiErrorPlugin',
+  version: core.SDK_VERSION,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  register: async function (serverArg) {
+    const server = serverArg ;
+
+    server.events.on('request', (request, event) => {
+      const activeSpan = core.getActiveSpan();
+      const rootSpan = activeSpan ? core.getRootSpan(activeSpan) : undefined;
+
+      if (request.response && isBoomObject(request.response)) {
+        sendErrorToSentry(request.response);
+      } else if (isErrorEvent(event)) {
+        sendErrorToSentry(event.error);
+      }
+
+      if (rootSpan) {
+        rootSpan.setStatus({ code: core.SPAN_STATUS_ERROR, message: 'internal_error' });
+        rootSpan.end();
+      }
+    });
+  },
+};
+
+/**
+ * Add a Hapi plugin to capture errors to Sentry.
+ */
+async function setupHapiErrorHandler(server) {
+  await server.register(hapiErrorPlugin);
+}
+
+const INTEGRATION_NAME = 'Spotlight';
+
+const _spotlightIntegration = ((options = {}) => {
+  const _options = {
+    sidecarUrl: options.sidecarUrl || 'http://localhost:8969/stream',
+  };
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (typeof process === 'object' && process.env && process.env.NODE_ENV !== 'development') {
+        utils.logger.warn("[Spotlight] It seems you're not in dev mode. Do you really want to have Spotlight enabled?");
+      }
+      connectToSpotlight(client, _options);
+    },
+  };
+}) ;
+
+/**
+ * Use this integration to send errors and transactions to Spotlight.
+ *
+ * Learn more about spotlight at https://spotlightjs.com
+ *
+ * Important: This integration only works with Node 18 or newer.
+ */
+const spotlightIntegration = core.defineIntegration(_spotlightIntegration);
+
+function connectToSpotlight(client, options) {
+  const spotlightUrl = parseSidecarUrl(options.sidecarUrl);
+  if (!spotlightUrl) {
+    return;
+  }
+
+  let failedRequests = 0;
+
+  client.on('beforeEnvelope', (envelope) => {
+    if (failedRequests > 3) {
+      utils.logger.warn('[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests');
+      return;
+    }
+
+    const serializedEnvelope = utils.serializeEnvelope(envelope);
+
+    const request = getNativeHttpRequest();
+    const req = request(
+      {
+        method: 'POST',
+        path: spotlightUrl.pathname,
+        hostname: spotlightUrl.hostname,
+        port: spotlightUrl.port,
+        headers: {
+          'Content-Type': 'application/x-sentry-envelope',
+        },
+      },
+      res => {
+        res.on('data', () => {
+          // Drain socket
+        });
+
+        res.on('end', () => {
+          // Drain socket
+        });
+        res.setEncoding('utf8');
+      },
+    );
+
+    req.on('error', () => {
+      failedRequests++;
+      utils.logger.warn('[Spotlight] Failed to send envelope to Spotlight Sidecar');
+    });
+    req.write(serializedEnvelope);
+    req.end();
+  });
+}
+
+function parseSidecarUrl(url) {
+  try {
+    return new URL(`${url}`);
+  } catch (e) {
+    utils.logger.warn(`[Spotlight] Invalid sidecar URL: ${url}`);
+    return undefined;
+  }
+}
+
+/**
+ * We want to get an unpatched http request implementation to avoid capturing our own calls.
+ */
+function getNativeHttpRequest() {
+  const { request } = http;
+  if (isWrapped(request)) {
+    return request.__sentry_original__;
+  }
+
+  return request;
+}
+
+function isWrapped(impl) {
+  return '__sentry_original__' in impl;
+}
+
+const _koaIntegration = (() => {
+  return {
+    name: 'Koa',
+    setupOnce() {
+      instrumentation.registerInstrumentations({
+        instrumentations: [new instrumentationKoa.KoaInstrumentation()],
+      });
+    },
+  };
+}) ;
+
+const koaIntegration = core.defineIntegration(_koaIntegration);
+
+/**
+ * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
+ */
+function getAutoPerformanceIntegrations() {
+  return [
+    expressIntegration(),
+    fastifyIntegration(),
+    graphqlIntegration(),
+    mongoIntegration(),
+    mongooseIntegration(),
+    mysqlIntegration(),
+    mysql2Integration(),
+    postgresIntegration(),
+    prismaIntegration(),
+    nestIntegration(),
+    hapiIntegration(),
+    koaIntegration(),
+  ];
+}
+
+function _nullishCoalesce$2(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }/**
+* This code was originally forked from https://github.com/TooTallNate/proxy-agents/tree/b133295fd16f6475578b6b15bd9b4e33ecb0d0b7
+* With the following licence:
+*
+* (The MIT License)
+*
+* Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>*
+*
+* 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.
+*/
+
+const INTERNAL = Symbol('AgentBaseInternalState');
+
+class Agent extends http.Agent {
+
+  // Set by `http.Agent` - missing from `@types/node`
+
+  constructor(opts) {
+    super(opts);
+    this[INTERNAL] = {};
+  }
+
+  /**
+   * Determine whether this is an `http` or `https` request.
+   */
+  isSecureEndpoint(options) {
+    if (options) {
+      // First check the `secureEndpoint` property explicitly, since this
+      // means that a parent `Agent` is "passing through" to this instance.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+      if (typeof (options ).secureEndpoint === 'boolean') {
+        return options.secureEndpoint;
+      }
+
+      // If no explicit `secure` endpoint, check if `protocol` property is
+      // set. This will usually be the case since using a full string URL
+      // or `URL` instance should be the most common usage.
+      if (typeof options.protocol === 'string') {
+        return options.protocol === 'https:';
+      }
+    }
+
+    // Finally, if no `protocol` property was set, then fall back to
+    // checking the stack trace of the current call stack, and try to
+    // detect the "https" module.
+    const { stack } = new Error();
+    if (typeof stack !== 'string') return false;
+    return stack.split('\n').some(l => l.indexOf('(https.js:') !== -1 || l.indexOf('node:https:') !== -1);
+  }
+
+  createSocket(req, options, cb) {
+    const connectOpts = {
+      ...options,
+      secureEndpoint: this.isSecureEndpoint(options),
+    };
+    Promise.resolve()
+      .then(() => this.connect(req, connectOpts))
+      .then(socket => {
+        if (socket instanceof http.Agent) {
+          // @ts-expect-error `addRequest()` isn't defined in `@types/node`
+          return socket.addRequest(req, connectOpts);
+        }
+        this[INTERNAL].currentSocket = socket;
+        // @ts-expect-error `createSocket()` isn't defined in `@types/node`
+        super.createSocket(req, options, cb);
+      }, cb);
+  }
+
+  createConnection() {
+    const socket = this[INTERNAL].currentSocket;
+    this[INTERNAL].currentSocket = undefined;
+    if (!socket) {
+      throw new Error('No socket was returned in the `connect()` function');
+    }
+    return socket;
+  }
+
+  get defaultPort() {
+    return _nullishCoalesce$2(this[INTERNAL].defaultPort, () => ( (this.protocol === 'https:' ? 443 : 80)));
+  }
+
+  set defaultPort(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].defaultPort = v;
+    }
+  }
+
+  get protocol() {
+    return _nullishCoalesce$2(this[INTERNAL].protocol, () => ( (this.isSecureEndpoint() ? 'https:' : 'http:')));
+  }
+
+  set protocol(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].protocol = v;
+    }
+  }
+}
+
+function debug$1(...args) {
+  utils.logger.log('[https-proxy-agent:parse-proxy-response]', ...args);
+}
+
+function parseProxyResponse(socket) {
+  return new Promise((resolve, reject) => {
+    // we need to buffer any HTTP traffic that happens with the proxy before we get
+    // the CONNECT response, so that if the response is anything other than an "200"
+    // response code, then we can re-play the "data" events on the socket once the
+    // HTTP parser is hooked up...
+    let buffersLength = 0;
+    const buffers = [];
+
+    function read() {
+      const b = socket.read();
+      if (b) ondata(b);
+      else socket.once('readable', read);
+    }
+
+    function cleanup() {
+      socket.removeListener('end', onend);
+      socket.removeListener('error', onerror);
+      socket.removeListener('readable', read);
+    }
+
+    function onend() {
+      cleanup();
+      debug$1('onend');
+      reject(new Error('Proxy connection ended before receiving CONNECT response'));
+    }
+
+    function onerror(err) {
+      cleanup();
+      debug$1('onerror %o', err);
+      reject(err);
+    }
+
+    function ondata(b) {
+      buffers.push(b);
+      buffersLength += b.length;
+
+      const buffered = Buffer.concat(buffers, buffersLength);
+      const endOfHeaders = buffered.indexOf('\r\n\r\n');
+
+      if (endOfHeaders === -1) {
+        // keep buffering
+        debug$1('have not received end of HTTP headers yet...');
+        read();
+        return;
+      }
+
+      const headerParts = buffered.slice(0, endOfHeaders).toString('ascii').split('\r\n');
+      const firstLine = headerParts.shift();
+      if (!firstLine) {
+        socket.destroy();
+        return reject(new Error('No header received from proxy CONNECT response'));
+      }
+      const firstLineParts = firstLine.split(' ');
+      const statusCode = +firstLineParts[1];
+      const statusText = firstLineParts.slice(2).join(' ');
+      const headers = {};
+      for (const header of headerParts) {
+        if (!header) continue;
+        const firstColon = header.indexOf(':');
+        if (firstColon === -1) {
+          socket.destroy();
+          return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+        }
+        const key = header.slice(0, firstColon).toLowerCase();
+        const value = header.slice(firstColon + 1).trimStart();
+        const current = headers[key];
+        if (typeof current === 'string') {
+          headers[key] = [current, value];
+        } else if (Array.isArray(current)) {
+          current.push(value);
+        } else {
+          headers[key] = value;
+        }
+      }
+      debug$1('got proxy server response: %o %o', firstLine, headers);
+      cleanup();
+      resolve({
+        connect: {
+          statusCode,
+          statusText,
+          headers,
+        },
+        buffered,
+      });
+    }
+
+    socket.on('error', onerror);
+    socket.on('end', onend);
+
+    read();
+  });
+}
+
+function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$2(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+function debug(...args) {
+  utils.logger.log('[https-proxy-agent]', ...args);
+}
+
+/**
+ * The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
+ * the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
+ *
+ * Outgoing HTTP requests are first tunneled through the proxy server using the
+ * `CONNECT` HTTP request method to establish a connection to the proxy server,
+ * and then the proxy server connects to the destination target and issues the
+ * HTTP request from the proxy server.
+ *
+ * `https:` requests have their socket connection upgraded to TLS once
+ * the connection to the proxy server has been established.
+ */
+class HttpsProxyAgent extends Agent {
+  static __initStatic() {this.protocols = ['http', 'https']; }
+
+  constructor(proxy, opts) {
+    super(opts);
+    this.options = {};
+    this.proxy = typeof proxy === 'string' ? new URL(proxy) : proxy;
+    this.proxyHeaders = _nullishCoalesce$1(_optionalChain$2([opts, 'optionalAccess', _2 => _2.headers]), () => ( {}));
+    debug('Creating new HttpsProxyAgent instance: %o', this.proxy.href);
+
+    // Trim off the brackets from IPv6 addresses
+    const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, '');
+    const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === 'https:' ? 443 : 80;
+    this.connectOpts = {
+      // Attempt to negotiate http/1.1 for proxy servers that support http/2
+      ALPNProtocols: ['http/1.1'],
+      ...(opts ? omit(opts, 'headers') : null),
+      host,
+      port,
+    };
+  }
+
+  /**
+   * Called when the node-core HTTP client library is creating a
+   * new HTTP request.
+   */
+  async connect(req, opts) {
+    const { proxy } = this;
+
+    if (!opts.host) {
+      throw new TypeError('No "host" provided');
+    }
+
+    // Create a socket connection to the proxy server.
+    let socket;
+    if (proxy.protocol === 'https:') {
+      debug('Creating `tls.Socket`: %o', this.connectOpts);
+      const servername = this.connectOpts.servername || this.connectOpts.host;
+      socket = tls.connect({
+        ...this.connectOpts,
+        servername: servername && net.isIP(servername) ? undefined : servername,
+      });
+    } else {
+      debug('Creating `net.Socket`: %o', this.connectOpts);
+      socket = net.connect(this.connectOpts);
+    }
+
+    const headers =
+      typeof this.proxyHeaders === 'function' ? this.proxyHeaders() : { ...this.proxyHeaders };
+    const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+    let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;
+
+    // Inject the `Proxy-Authorization` header if necessary.
+    if (proxy.username || proxy.password) {
+      const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers['Proxy-Authorization'] = `Basic ${Buffer.from(auth).toString('base64')}`;
+    }
+
+    headers.Host = `${host}:${opts.port}`;
+
+    if (!headers['Proxy-Connection']) {
+      headers['Proxy-Connection'] = this.keepAlive ? 'Keep-Alive' : 'close';
+    }
+    for (const name of Object.keys(headers)) {
+      payload += `${name}: ${headers[name]}\r\n`;
+    }
+
+    const proxyResponsePromise = parseProxyResponse(socket);
+
+    socket.write(`${payload}\r\n`);
+
+    const { connect, buffered } = await proxyResponsePromise;
+    req.emit('proxyConnect', connect);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Not EventEmitter in Node types
+    this.emit('proxyConnect', connect, req);
+
+    if (connect.statusCode === 200) {
+      req.once('socket', resume);
+
+      if (opts.secureEndpoint) {
+        // The proxy is connecting to a TLS server, so upgrade
+        // this socket connection to a TLS connection.
+        debug('Upgrading socket connection to TLS');
+        const servername = opts.servername || opts.host;
+        return tls.connect({
+          ...omit(opts, 'host', 'path', 'port'),
+          socket,
+          servername: net.isIP(servername) ? undefined : servername,
+        });
+      }
+
+      return socket;
+    }
+
+    // Some other status code that's not 200... need to re-play the HTTP
+    // header "data" events onto the socket once the HTTP machinery is
+    // attached so that the node core `http` can parse and handle the
+    // error status code.
+
+    // Close the original socket, and a new "fake" socket is returned
+    // instead, so that the proxy doesn't get the HTTP request
+    // written to it (which may contain `Authorization` headers or other
+    // sensitive data).
+    //
+    // See: https://hackerone.com/reports/541502
+    socket.destroy();
+
+    const fakeSocket = new net.Socket({ writable: false });
+    fakeSocket.readable = true;
+
+    // Need to wait for the "socket" event to re-play the "data" events.
+    req.once('socket', (s) => {
+      debug('Replaying proxy buffer for failed request');
+      // Replay the "buffered" Buffer onto the fake `socket`, since at
+      // this point the HTTP module machinery has been hooked up for
+      // the user.
+      s.push(buffered);
+      s.push(null);
+    });
+
+    return fakeSocket;
+  }
+}HttpsProxyAgent.__initStatic();
+
+function resume(socket) {
+  socket.resume();
+}
+
+function omit(
+  obj,
+  ...keys
+)
+
+ {
+  const ret = {}
+
+;
+  let key;
+  for (key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+
+// Estimated maximum size for reasonable standalone event
+const GZIP_THRESHOLD = 1024 * 32;
+
+/**
+ * Gets a stream from a Uint8Array or string
+ * Readable.from is ideal but was added in node.js v12.3.0 and v10.17.0
+ */
+function streamFromBody(body) {
+  return new stream.Readable({
+    read() {
+      this.push(body);
+      this.push(null);
+    },
+  });
+}
+
+/**
+ * Creates a Transport that uses native the native 'http' and 'https' modules to send events to Sentry.
+ */
+function makeNodeTransport(options) {
+  let urlSegments;
+
+  try {
+    urlSegments = new URL(options.url);
+  } catch (e) {
+    utils.consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[@sentry/node]: Invalid dsn or tunnel option, will not send any events. The tunnel option must be a full URL when used.',
+      );
+    });
+    return core.createTransport(options, () => Promise.resolve({}));
+  }
+
+  const isHttps = urlSegments.protocol === 'https:';
+
+  // Proxy prioritization: http => `options.proxy` | `process.env.http_proxy`
+  // Proxy prioritization: https => `options.proxy` | `process.env.https_proxy` | `process.env.http_proxy`
+  const proxy = applyNoProxyOption(
+    urlSegments,
+    options.proxy || (isHttps ? process.env.https_proxy : undefined) || process.env.http_proxy,
+  );
+
+  const nativeHttpModule = isHttps ? https : http$1;
+  const keepAlive = options.keepAlive === undefined ? false : options.keepAlive;
+
+  // TODO(v7): Evaluate if we can set keepAlive to true. This would involve testing for memory leaks in older node
+  // versions(>= 8) as they had memory leaks when using it: #2555
+  const agent = proxy
+    ? (new HttpsProxyAgent(proxy) )
+    : new nativeHttpModule.Agent({ keepAlive, maxSockets: 30, timeout: 2000 });
+
+  const requestExecutor = createRequestExecutor(options, _nullishCoalesce(options.httpModule, () => ( nativeHttpModule)), agent);
+  return core.createTransport(options, requestExecutor);
+}
+
+/**
+ * Honors the `no_proxy` env variable with the highest priority to allow for hosts exclusion.
+ *
+ * @param transportUrl The URL the transport intends to send events to.
+ * @param proxy The client configured proxy.
+ * @returns A proxy the transport should use.
+ */
+function applyNoProxyOption(transportUrlSegments, proxy) {
+  const { no_proxy } = process.env;
+
+  const urlIsExemptFromProxy =
+    no_proxy &&
+    no_proxy
+      .split(',')
+      .some(
+        exemption => transportUrlSegments.host.endsWith(exemption) || transportUrlSegments.hostname.endsWith(exemption),
+      );
+
+  if (urlIsExemptFromProxy) {
+    return undefined;
+  } else {
+    return proxy;
+  }
+}
+
+/**
+ * Creates a RequestExecutor to be used with `createTransport`.
+ */
+function createRequestExecutor(
+  options,
+  httpModule,
+  agent,
+) {
+  const { hostname, pathname, port, protocol, search } = new URL(options.url);
+  return function makeRequest(request) {
+    return new Promise((resolve, reject) => {
+      let body = streamFromBody(request.body);
+
+      const headers = { ...options.headers };
+
+      if (request.body.length > GZIP_THRESHOLD) {
+        headers['content-encoding'] = 'gzip';
+        body = body.pipe(zlib.createGzip());
+      }
+
+      const req = httpModule.request(
+        {
+          method: 'POST',
+          agent,
+          headers,
+          hostname,
+          path: `${pathname}${search}`,
+          port,
+          protocol,
+          ca: options.caCerts,
+        },
+        res => {
+          res.on('data', () => {
+            // Drain socket
+          });
+
+          res.on('end', () => {
+            // Drain socket
+          });
+
+          res.setEncoding('utf8');
+
+          // "Key-value pairs of header names and values. Header names are lower-cased."
+          // https://nodejs.org/api/http.html#http_message_headers
+          const retryAfterHeader = _nullishCoalesce(res.headers['retry-after'], () => ( null));
+          const rateLimitsHeader = _nullishCoalesce(res.headers['x-sentry-rate-limits'], () => ( null));
+
+          resolve({
+            statusCode: res.statusCode,
+            headers: {
+              'retry-after': retryAfterHeader,
+              'x-sentry-rate-limits': Array.isArray(rateLimitsHeader) ? rateLimitsHeader[0] : rateLimitsHeader,
+            },
+          });
+        },
+      );
+
+      req.on('error', reject);
+      body.pipe(req);
+    });
+  };
+}
+
+/** normalizes Windows paths */
+function normalizeWindowsPath(path) {
+  return path
+    .replace(/^[A-Z]:/, '') // remove Windows-style prefix
+    .replace(/\\/g, '/'); // replace all `\` instances with `/`
+}
+
+/** Creates a function that gets the module name from a filename */
+function createGetModuleFromFilename(
+  basePath = process.argv[1] ? utils.dirname(process.argv[1]) : process.cwd(),
+  isWindows = path.sep === '\\',
+) {
+  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
+
+  return (filename) => {
+    if (!filename) {
+      return;
+    }
+
+    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
+
+    // eslint-disable-next-line prefer-const
+    let { dir, base: file, ext } = path.posix.parse(normalizedFilename);
+
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+      file = file.slice(0, ext.length * -1);
+    }
+
+    if (!dir) {
+      // No dirname whatsoever
+      dir = '.';
+    }
+
+    const n = dir.lastIndexOf('/node_modules');
+    if (n > -1) {
+      return `${dir.slice(n + 14).replace(/\//g, '.')}:${file}`;
+    }
+
+    // Let's see if it's a part of the main module
+    // To be a part of main module, it has to share the same base
+    if (dir.startsWith(normalizedBase)) {
+      let moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, '.');
+
+      if (moduleName) {
+        moduleName += ':';
+      }
+      moduleName += file;
+
+      return moduleName;
+    }
+
+    return file;
+  };
+}
+
+// PUBLIC APIS
+
+
+/** Get the currently active client. */
+function getClient() {
+  const currentScope = core.getCurrentScope();
+
+  const client = currentScope.getClient();
+  if (client) {
+    return client ;
+  }
+
+  // TODO otherwise ensure we use a noop client
+  return {} ;
+}
+
+/**
+ * Returns a release dynamically from environment variables.
+ */
+function getSentryRelease(fallback) {
+  // Always read first as Sentry takes this as precedence
+  if (process.env.SENTRY_RELEASE) {
+    return process.env.SENTRY_RELEASE;
+  }
+
+  // This supports the variable that sentry-webpack-plugin injects
+  if (utils.GLOBAL_OBJ.SENTRY_RELEASE && utils.GLOBAL_OBJ.SENTRY_RELEASE.id) {
+    return utils.GLOBAL_OBJ.SENTRY_RELEASE.id;
+  }
+
+  return (
+    // GitHub Actions - https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables#default-environment-variables
+    process.env.GITHUB_SHA ||
+    // Netlify - https://docs.netlify.com/configure-builds/environment-variables/#build-metadata
+    process.env.COMMIT_REF ||
+    // Vercel - https://vercel.com/docs/v2/build-step#system-environment-variables
+    process.env.VERCEL_GIT_COMMIT_SHA ||
+    process.env.VERCEL_GITHUB_COMMIT_SHA ||
+    process.env.VERCEL_GITLAB_COMMIT_SHA ||
+    process.env.VERCEL_BITBUCKET_COMMIT_SHA ||
+    // Zeit (now known as Vercel)
+    process.env.ZEIT_GITHUB_COMMIT_SHA ||
+    process.env.ZEIT_GITLAB_COMMIT_SHA ||
+    process.env.ZEIT_BITBUCKET_COMMIT_SHA ||
+    // Cloudflare Pages - https://developers.cloudflare.com/pages/platform/build-configuration/#environment-variables
+    process.env.CF_PAGES_COMMIT_SHA ||
+    fallback
+  );
+}
+
+/** Node.js stack parser */
+const defaultStackParser = utils.createStackParser(utils.nodeStackLineParser(createGetModuleFromFilename()));
+
+/**
+ * This method is a noop and only here to ensure vite-plugin v0.6.0 (which is used by Sveltekit) still works,
+ * as that uses this.
+ *
+ * @deprecated This will be removed before v8 is finalized.
+ */
+function makeMain(hub) {
+  // noop
+  return hub;
+}
+
+function _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+/** A client for using Sentry with Node & OpenTelemetry. */
+class NodeClient extends core.ServerRuntimeClient {
+
+   constructor(options) {
+    const clientOptions = {
+      ...options,
+      platform: 'node',
+      runtime: { name: 'node', version: global.process.version },
+      serverName: options.serverName || global.process.env.SENTRY_NAME || os.hostname(),
+    };
+
+    core.applySdkMetadata(clientOptions, 'node');
+
+    super(clientOptions);
+  }
+
+  /** Get the OTEL tracer. */
+   get tracer() {
+    if (this._tracer) {
+      return this._tracer;
+    }
+
+    const name = '@sentry/node';
+    const version = core.SDK_VERSION;
+    const tracer = api.trace.getTracer(name, version);
+    this._tracer = tracer;
+
+    return tracer;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   async flush(timeout) {
+    const provider = this.traceProvider;
+    const spanProcessor = _optionalChain$1([provider, 'optionalAccess', _ => _.activeSpanProcessor]);
+
+    if (spanProcessor) {
+      await spanProcessor.forceFlush();
+    }
+
+    return super.flush(timeout);
+  }
+}
+
+/**
+ * This is a custom ContextManager for OpenTelemetry, which extends the default AsyncLocalStorageContextManager.
+ * It ensures that we create a new hub per context, so that the OTEL Context & the Sentry Hub are always in sync.
+ *
+ * Note that we currently only support AsyncHooks with this,
+ * but since this should work for Node 14+ anyhow that should be good enough.
+ */
+const SentryContextManager = opentelemetry.wrapContextManagerClass(contextAsyncHooks.AsyncLocalStorageContextManager);
+
+/**
+ * Initialize OpenTelemetry for Node.
+ */
+function initOtel() {
+  const client = getClient();
+
+  if (!client) {
+    DEBUG_BUILD &&
+      utils.logger.warn(
+        'No client available, skipping OpenTelemetry setup. This probably means that `Sentry.init()` was not called before `initOtel()`.',
+      );
+    return;
+  }
+
+  if (client.getOptions().debug) {
+    const otelLogger = new Proxy(utils.logger , {
+      get(target, prop, receiver) {
+        const actualProp = prop === 'verbose' ? 'debug' : prop;
+        return Reflect.get(target, actualProp, receiver);
+      },
+    });
+
+    api.diag.setLogger(otelLogger, api.DiagLogLevel.DEBUG);
+  }
+
+  opentelemetry.setupEventContextTrace(client);
+
+  const provider = setupOtel(client);
+  client.traceProvider = provider;
+}
+
+/** Just exported for tests. */
+function setupOtel(client) {
+  // Create and configure NodeTracerProvider
+  const provider = new sdkTraceBase.BasicTracerProvider({
+    sampler: new opentelemetry.SentrySampler(client),
+    resource: new resources.Resource({
+      [semanticConventions.SemanticResourceAttributes.SERVICE_NAME]: 'node',
+      [semanticConventions.SemanticResourceAttributes.SERVICE_NAMESPACE]: 'sentry',
+      [semanticConventions.SemanticResourceAttributes.SERVICE_VERSION]: core.SDK_VERSION,
+    }),
+    forceFlushTimeoutMillis: 500,
+  });
+  provider.addSpanProcessor(new opentelemetry.SentrySpanProcessor());
+
+  // Initialize the provider
+  provider.register({
+    propagator: new opentelemetry.SentryPropagator(),
+    contextManager: new SentryContextManager(),
+  });
+
+  return provider;
+}
+
+function getCjsOnlyIntegrations(isCjs = typeof require !== 'undefined') {
+  return isCjs ? [modulesIntegration()] : [];
+}
+
+/** Get the default integrations for the Node Experimental SDK. */
+function getDefaultIntegrations(options) {
+  return [
+    // Common
+    core.inboundFiltersIntegration(),
+    core.functionToStringIntegration(),
+    core.linkedErrorsIntegration(),
+    core.requestDataIntegration(),
+    // Native Wrappers
+    consoleIntegration(),
+    httpIntegration(),
+    nativeNodeFetchIntegration(),
+    // Global Handlers
+    onUncaughtExceptionIntegration(),
+    onUnhandledRejectionIntegration(),
+    // Event Info
+    contextLinesIntegration(),
+    localVariablesIntegration(),
+    nodeContextIntegration(),
+    httpIntegration(),
+    ...getCjsOnlyIntegrations(),
+    ...(core.hasTracingEnabled(options) ? getAutoPerformanceIntegrations() : []),
+  ];
+}
+
+/**
+ * Initialize Sentry for Node.
+ */
+function init(options = {}) {
+  const clientOptions = getClientOptions(options);
+
+  if (clientOptions.debug === true) {
+    if (DEBUG_BUILD) {
+      utils.logger.enable();
+    } else {
+      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped
+      utils.consoleSandbox(() => {
+        // eslint-disable-next-line no-console
+        console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');
+      });
+    }
+  }
+
+  opentelemetry.setOpenTelemetryContextAsyncContextStrategy();
+
+  const scope = core.getCurrentScope();
+  scope.update(options.initialScope);
+
+  const client = new NodeClient(clientOptions);
+  // The client is on the current scope, from where it generally is inherited
+  core.getCurrentScope().setClient(client);
+
+  if (isEnabled(client)) {
+    client.init();
+  }
+
+  if (options.autoSessionTracking) {
+    startSessionTracking();
+  }
+
+  updateScopeFromEnvVariables();
+
+  if (options.spotlight) {
+    // force integrations to be setup even if no DSN was set
+    // If they have already been added before, they will be ignored anyhow
+    const integrations = client.getOptions().integrations;
+    for (const integration of integrations) {
+      client.addIntegration(integration);
+    }
+    client.addIntegration(
+      spotlightIntegration({
+        sidecarUrl: typeof options.spotlight === 'string' ? options.spotlight : undefined,
+      }),
+    );
+  }
+
+  // If users opt-out of this, they _have_ to set up OpenTelemetry themselves
+  // There is no way to use this SDK without OpenTelemetry!
+  if (!options.skipOpenTelemetrySetup) {
+    initOtel();
+  }
+
+  validateOpenTelemetrySetup();
+}
+
+function validateOpenTelemetrySetup() {
+  if (!DEBUG_BUILD) {
+    return;
+  }
+
+  const setup = opentelemetry.openTelemetrySetupCheck();
+
+  const required = ['SentrySpanProcessor', 'SentryContextManager', 'SentryPropagator'] ;
+  for (const k of required) {
+    if (!setup.includes(k)) {
+      utils.logger.error(
+        `You have to set up the ${k}. Without this, the OpenTelemetry & Sentry integration will not work properly.`,
+      );
+    }
+  }
+
+  if (!setup.includes('SentrySampler')) {
+    utils.logger.warn(
+      'You have to set up the SentrySampler. Without this, the OpenTelemetry & Sentry integration may still work, but sample rates set for the Sentry SDK will not be respected.',
+    );
+  }
+}
+
+function getClientOptions(options) {
+  if (options.defaultIntegrations === undefined) {
+    options.defaultIntegrations = getDefaultIntegrations(options);
+  }
+
+  const release = getRelease(options.release);
+
+  const autoSessionTracking =
+    typeof release !== 'string'
+      ? false
+      : options.autoSessionTracking === undefined
+        ? true
+        : options.autoSessionTracking;
+
+  const tracesSampleRate = getTracesSampleRate(options.tracesSampleRate);
+
+  const baseOptions = utils.dropUndefinedKeys({
+    transport: makeNodeTransport,
+    dsn: process.env.SENTRY_DSN,
+    environment: process.env.SENTRY_ENVIRONMENT,
+  });
+
+  const overwriteOptions = utils.dropUndefinedKeys({
+    release,
+    autoSessionTracking,
+    tracesSampleRate,
+  });
+
+  const clientOptions = {
+    ...baseOptions,
+    ...options,
+    ...overwriteOptions,
+    stackParser: utils.stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
+    integrations: core.getIntegrationsToSetup({
+      defaultIntegrations: options.defaultIntegrations,
+      integrations: options.integrations,
+    }),
+  };
+
+  return clientOptions;
+}
+
+function getRelease(release) {
+  if (release !== undefined) {
+    return release;
+  }
+
+  const detectedRelease = getSentryRelease();
+  if (detectedRelease !== undefined) {
+    return detectedRelease;
+  }
+
+  return undefined;
+}
+
+function getTracesSampleRate(tracesSampleRate) {
+  if (tracesSampleRate !== undefined) {
+    return tracesSampleRate;
+  }
+
+  const sampleRateFromEnv = process.env.SENTRY_TRACES_SAMPLE_RATE;
+  if (!sampleRateFromEnv) {
+    return undefined;
+  }
+
+  const parsed = parseFloat(sampleRateFromEnv);
+  return isFinite(parsed) ? parsed : undefined;
+}
+
+/**
+ * Update scope and propagation context based on environmental variables.
+ *
+ * See https://github.com/getsentry/rfcs/blob/main/text/0071-continue-trace-over-process-boundaries.md
+ * for more details.
+ */
+function updateScopeFromEnvVariables() {
+  const sentryUseEnvironment = (process.env.SENTRY_USE_ENVIRONMENT || '').toLowerCase();
+  if (!['false', 'n', 'no', 'off', '0'].includes(sentryUseEnvironment)) {
+    const sentryTraceEnv = process.env.SENTRY_TRACE;
+    const baggageEnv = process.env.SENTRY_BAGGAGE;
+    const propagationContext = utils.propagationContextFromHeaders(sentryTraceEnv, baggageEnv);
+    core.getCurrentScope().setPropagationContext(propagationContext);
+  }
+}
+
+/**
+ * Enable automatic Session Tracking for the node process.
+ */
+function startSessionTracking() {
+  const client = core.getClient();
+  if (client && client.getOptions().autoSessionTracking) {
+    client.initSessionFlusher();
+  }
+
+  core.startSession();
+
+  // Emitted in the case of healthy sessions, error of `mechanism.handled: true` and unhandledrejections because
+  // The 'beforeExit' event is not emitted for conditions causing explicit termination,
+  // such as calling process.exit() or uncaught exceptions.
+  // Ref: https://nodejs.org/api/process.html#process_event_beforeexit
+  process.on('beforeExit', () => {
+    const session = core.getIsolationScope().getSession();
+
+    // Only call endSession, if the Session exists on Scope and SessionStatus is not a
+    // Terminal Status i.e. Exited or Crashed because
+    // "When a session is moved away from ok it must not be updated anymore."
+    // Ref: https://develop.sentry.dev/sdk/sessions/
+    if (session && session.status !== 'ok') {
+      core.endSession();
+    }
+  });
+}
+
+function isEnabled(client) {
+  return client.getOptions().enabled !== false && client.getTransport() !== undefined;
+}
+
+/**
+ * This is for legacy reasons, and returns a proxy object instead of a hub to be used.
+ * @deprecated Use the methods directly.
+ */
+function getCurrentHub() {
+  return {
+    isOlderThan(_version) {
+      return false;
+    },
+
+    bindClient(client) {
+      const scope = core.getCurrentScope();
+      scope.setClient(client);
+    },
+
+    pushScope() {
+      // TODO: This does not work and is actually deprecated
+      return core.getCurrentScope();
+    },
+
+    popScope() {
+      // TODO: This does not work and is actually deprecated
+      return false;
+    },
+
+    withScope: core.withScope,
+    getClient: () => getClient() ,
+    getScope: core.getCurrentScope,
+    getIsolationScope: core.getIsolationScope,
+    captureException: (exception, hint) => {
+      return core.getCurrentScope().captureException(exception, hint);
+    },
+    captureMessage: (message, level, hint) => {
+      return core.getCurrentScope().captureMessage(message, level, hint);
+    },
+    captureEvent: core.captureEvent,
+    addBreadcrumb: core.addBreadcrumb,
+    setUser: core.setUser,
+    setTags: core.setTags,
+    setTag: core.setTag,
+    setExtra: core.setExtra,
+    setExtras: core.setExtras,
+    setContext: core.setContext,
+
+    getIntegration(integration) {
+      // eslint-disable-next-line deprecation/deprecation
+      return getClient().getIntegration(integration);
+    },
+
+    startSession: core.startSession,
+
+    endSession: core.endSession,
+
+    captureSession(endSession) {
+      // both send the update and pull the session from the scope
+      if (endSession) {
+        // eslint-disable-next-line deprecation/deprecation
+        return this.endSession();
+      }
+
+      // only send the update
+      _sendSessionUpdate();
+    },
+
+    shouldSendDefaultPii() {
+      const client = getClient();
+      const options = client.getOptions();
+      return Boolean(options.sendDefaultPii);
+    },
+  };
+}
+
+/**
+ * Sends the current Session on the scope
+ */
+function _sendSessionUpdate() {
+  const scope = core.getCurrentScope();
+  const client = getClient();
+
+  const session = scope.getSession();
+  if (session) {
+    client.captureSession(session);
+  }
+}
+
+const replacements = [
+  ['january', '1'],
+  ['february', '2'],
+  ['march', '3'],
+  ['april', '4'],
+  ['may', '5'],
+  ['june', '6'],
+  ['july', '7'],
+  ['august', '8'],
+  ['september', '9'],
+  ['october', '10'],
+  ['november', '11'],
+  ['december', '12'],
+  ['jan', '1'],
+  ['feb', '2'],
+  ['mar', '3'],
+  ['apr', '4'],
+  ['may', '5'],
+  ['jun', '6'],
+  ['jul', '7'],
+  ['aug', '8'],
+  ['sep', '9'],
+  ['oct', '10'],
+  ['nov', '11'],
+  ['dec', '12'],
+  ['sunday', '0'],
+  ['monday', '1'],
+  ['tuesday', '2'],
+  ['wednesday', '3'],
+  ['thursday', '4'],
+  ['friday', '5'],
+  ['saturday', '6'],
+  ['sun', '0'],
+  ['mon', '1'],
+  ['tue', '2'],
+  ['wed', '3'],
+  ['thu', '4'],
+  ['fri', '5'],
+  ['sat', '6'],
+];
+
+/**
+ * Replaces names in cron expressions
+ */
+function replaceCronNames(cronExpression) {
+  return replacements.reduce(
+    // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor
+    (acc, [name, replacement]) => acc.replace(new RegExp(name, 'gi'), replacement),
+    cronExpression,
+  );
+}
+
+const ERROR_TEXT = 'Automatic instrumentation of CronJob only supports crontab string';
+
+/**
+ * Instruments the `cron` library to send a check-in event to Sentry for each job execution.
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ * import { CronJob } from 'cron';
+ *
+ * const CronJobWithCheckIn = Sentry.cron.instrumentCron(CronJob, 'my-cron-job');
+ *
+ * // use the constructor
+ * const job = new CronJobWithCheckIn('* * * * *', () => {
+ *  console.log('You will see this message every minute');
+ * });
+ *
+ * // or from
+ * const job = CronJobWithCheckIn.from({ cronTime: '* * * * *', onTick: () => {
+ *   console.log('You will see this message every minute');
+ * });
+ * ```
+ */
+function instrumentCron(lib, monitorSlug) {
+  let jobScheduled = false;
+
+  return new Proxy(lib, {
+    construct(target, args) {
+      const [cronTime, onTick, onComplete, start, timeZone, ...rest] = args;
+
+      if (typeof cronTime !== 'string') {
+        throw new Error(ERROR_TEXT);
+      }
+
+      if (jobScheduled) {
+        throw new Error(`A job named '${monitorSlug}' has already been scheduled`);
+      }
+
+      jobScheduled = true;
+
+      const cronString = replaceCronNames(cronTime);
+
+      function monitoredTick(context, onComplete) {
+        return core.withMonitor(
+          monitorSlug,
+          () => {
+            return onTick(context, onComplete);
+          },
+          {
+            schedule: { type: 'crontab', value: cronString },
+            ...(timeZone ? { timeZone } : {}),
+          },
+        );
+      }
+
+      return new target(cronTime, monitoredTick, onComplete, start, timeZone, ...rest);
+    },
+    get(target, prop) {
+      if (prop === 'from') {
+        return (param) => {
+          const { cronTime, onTick, timeZone } = param;
+
+          if (typeof cronTime !== 'string') {
+            throw new Error(ERROR_TEXT);
+          }
+
+          if (jobScheduled) {
+            throw new Error(`A job named '${monitorSlug}' has already been scheduled`);
+          }
+
+          jobScheduled = true;
+
+          const cronString = replaceCronNames(cronTime);
+
+          param.onTick = (context, onComplete) => {
+            return core.withMonitor(
+              monitorSlug,
+              () => {
+                return onTick(context, onComplete);
+              },
+              {
+                schedule: { type: 'crontab', value: cronString },
+                ...(timeZone ? { timeZone } : {}),
+              },
+            );
+          };
+
+          return target.from(param);
+        };
+      } else {
+        return target[prop];
+      }
+    },
+  });
+}
+
+/**
+ * Wraps the `node-cron` library with check-in monitoring.
+ *
+ * ```ts
+ * import * as Sentry from "@sentry/node";
+ * import cron from "node-cron";
+ *
+ * const cronWithCheckIn = Sentry.cron.instrumentNodeCron(cron);
+ *
+ * cronWithCheckIn.schedule(
+ *   "* * * * *",
+ *   () => {
+ *     console.log("running a task every minute");
+ *   },
+ *   { name: "my-cron-job" },
+ * );
+ * ```
+ */
+function instrumentNodeCron(lib) {
+  return new Proxy(lib, {
+    get(target, prop) {
+      if (prop === 'schedule' && target.schedule) {
+        // When 'get' is called for schedule, return a proxied version of the schedule function
+        return new Proxy(target.schedule, {
+          apply(target, thisArg, argArray) {
+            const [expression, , options] = argArray;
+
+            if (!_optionalChain([options, 'optionalAccess', _ => _.name])) {
+              throw new Error('Missing "name" for scheduled job. A name is required for Sentry check-in monitoring.');
+            }
+
+            return core.withMonitor(
+              options.name,
+              () => {
+                return target.apply(thisArg, argArray);
+              },
+              {
+                schedule: { type: 'crontab', value: replaceCronNames(expression) },
+                timezone: _optionalChain([options, 'optionalAccess', _2 => _2.timezone]),
+              },
+            );
+          },
+        });
+      } else {
+        return target[prop];
+      }
+    },
+  });
+}
+
+/**
+ * Instruments the `node-schedule` library to send a check-in event to Sentry for each job execution.
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ * import * as schedule from 'node-schedule';
+ *
+ * const scheduleWithCheckIn = Sentry.cron.instrumentNodeSchedule(schedule);
+ *
+ * const job = scheduleWithCheckIn.scheduleJob('my-cron-job', '* * * * *', () => {
+ *  console.log('You will see this message every minute');
+ * });
+ * ```
+ */
+function instrumentNodeSchedule(lib) {
+  return new Proxy(lib, {
+    get(target, prop) {
+      if (prop === 'scheduleJob') {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        return new Proxy(target.scheduleJob, {
+          apply(target, thisArg, argArray) {
+            const [nameOrExpression, expressionOrCallback] = argArray;
+
+            if (typeof nameOrExpression !== 'string' || typeof expressionOrCallback !== 'string') {
+              throw new Error(
+                "Automatic instrumentation of 'node-schedule' requires the first parameter of 'scheduleJob' to be a job name string and the second parameter to be a crontab string",
+              );
+            }
+
+            const monitorSlug = nameOrExpression;
+            const expression = expressionOrCallback;
+
+            return core.withMonitor(
+              monitorSlug,
+              () => {
+                return target.apply(thisArg, argArray);
+              },
+              {
+                schedule: { type: 'crontab', value: replaceCronNames(expression) },
+              },
+            );
+          },
+        });
+      }
+
+      return target[prop];
+    },
+  });
+}
+
+/** Methods to instrument cron libraries for Sentry check-ins */
+const cron = {
+  instrumentCron,
+  instrumentNodeCron,
+  instrumentNodeSchedule,
+};
 
-exports.httpIntegration = http.httpIntegration;
-exports.nativeNodeFetchIntegration = nodeFetch.nativeNodeFetchIntegration;
-exports.consoleIntegration = console.consoleIntegration;
-exports.nodeContextIntegration = context.nodeContextIntegration;
-exports.contextLinesIntegration = contextlines.contextLinesIntegration;
-exports.localVariablesIntegration = index.localVariablesIntegration;
-exports.modulesIntegration = modules.modulesIntegration;
-exports.onUncaughtExceptionIntegration = onuncaughtexception.onUncaughtExceptionIntegration;
-exports.onUnhandledRejectionIntegration = onunhandledrejection.onUnhandledRejectionIntegration;
-exports.anrIntegration = index$1.anrIntegration;
-exports.expressErrorHandler = express.expressErrorHandler;
-exports.expressIntegration = express.expressIntegration;
-exports.setupExpressErrorHandler = express.setupExpressErrorHandler;
-exports.fastifyIntegration = fastify.fastifyIntegration;
-exports.graphqlIntegration = graphql.graphqlIntegration;
-exports.mongoIntegration = mongo.mongoIntegration;
-exports.mongooseIntegration = mongoose.mongooseIntegration;
-exports.mysqlIntegration = mysql.mysqlIntegration;
-exports.mysql2Integration = mysql2.mysql2Integration;
-exports.nestIntegration = nest.nestIntegration;
-exports.postgresIntegration = postgres.postgresIntegration;
-exports.prismaIntegration = prisma.prismaIntegration;
-exports.hapiIntegration = index$2.hapiIntegration;
-exports.setupHapiErrorHandler = index$2.setupHapiErrorHandler;
-exports.getDefaultIntegrations = init.getDefaultIntegrations;
-exports.init = init.init;
-exports.getAutoPerformanceIntegrations = index$3.getAutoPerformanceIntegrations;
-exports.defaultStackParser = api.defaultStackParser;
-exports.getClient = api.getClient;
-exports.getSentryRelease = api.getSentryRelease;
-exports.makeMain = api.makeMain;
-exports.createGetModuleFromFilename = module$1.createGetModuleFromFilename;
-exports.makeNodeTransport = http$1.makeNodeTransport;
-exports.NodeClient = client.NodeClient;
-exports.getCurrentHub = hub.getCurrentHub;
-exports.cron = index$4.cron;
-exports.getActiveSpan = opentelemetry.getActiveSpan;
-exports.startInactiveSpan = opentelemetry.startInactiveSpan;
-exports.startSpan = opentelemetry.startSpan;
-exports.startSpanManual = opentelemetry.startSpanManual;
-exports.withActiveSpan = opentelemetry.withActiveSpan;
-exports.DEFAULT_USER_INCLUDES = utils.DEFAULT_USER_INCLUDES;
-exports.addRequestDataToEvent = utils.addRequestDataToEvent;
-exports.extractRequestData = utils.extractRequestData;
 exports.Hub = core.Hub;
 exports.SDK_VERSION = core.SDK_VERSION;
 exports.SEMANTIC_ATTRIBUTE_SENTRY_OP = core.SEMANTIC_ATTRIBUTE_SENTRY_OP;
@@ -88,26 +3623,32 @@ exports.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE
 exports.Scope = core.Scope;
 exports.addBreadcrumb = core.addBreadcrumb;
 exports.addEventProcessor = core.addEventProcessor;
+exports.addIntegration = core.addIntegration;
 exports.captureCheckIn = core.captureCheckIn;
 exports.captureConsoleIntegration = core.captureConsoleIntegration;
 exports.captureEvent = core.captureEvent;
 exports.captureException = core.captureException;
 exports.captureMessage = core.captureMessage;
+exports.captureSession = core.captureSession;
 exports.close = core.close;
-exports.continueTrace = core.continueTrace;
 exports.createTransport = core.createTransport;
 exports.debugIntegration = core.debugIntegration;
 exports.dedupeIntegration = core.dedupeIntegration;
+exports.endSession = core.endSession;
 exports.extraErrorDataIntegration = core.extraErrorDataIntegration;
 exports.flush = core.flush;
 exports.functionToStringIntegration = core.functionToStringIntegration;
+exports.getActiveSpan = core.getActiveSpan;
 exports.getCurrentScope = core.getCurrentScope;
 exports.getGlobalScope = core.getGlobalScope;
 exports.getIsolationScope = core.getIsolationScope;
+exports.getRootSpan = core.getRootSpan;
+exports.getSpanDescendants = core.getSpanDescendants;
 exports.getSpanStatusFromHttpCode = core.getSpanStatusFromHttpCode;
 exports.inboundFiltersIntegration = core.inboundFiltersIntegration;
 exports.isInitialized = core.isInitialized;
 exports.linkedErrorsIntegration = core.linkedErrorsIntegration;
+exports.metrics = core.metricsDefault;
 exports.parameterize = core.parameterize;
 exports.requestDataIntegration = core.requestDataIntegration;
 exports.rewriteFramesIntegration = core.rewriteFramesIntegration;
@@ -121,7 +3662,54 @@ exports.setMeasurement = core.setMeasurement;
 exports.setTag = core.setTag;
 exports.setTags = core.setTags;
 exports.setUser = core.setUser;
+exports.startInactiveSpan = core.startInactiveSpan;
+exports.startSession = core.startSession;
+exports.startSpan = core.startSpan;
+exports.startSpanManual = core.startSpanManual;
+exports.withActiveSpan = core.withActiveSpan;
 exports.withIsolationScope = core.withIsolationScope;
 exports.withMonitor = core.withMonitor;
 exports.withScope = core.withScope;
+exports.continueTrace = opentelemetry.continueTrace;
+exports.DEFAULT_USER_INCLUDES = utils.DEFAULT_USER_INCLUDES;
+exports.addRequestDataToEvent = utils.addRequestDataToEvent;
+exports.extractRequestData = utils.extractRequestData;
+exports.NodeClient = NodeClient;
+exports.anrIntegration = anrIntegration;
+exports.consoleIntegration = consoleIntegration;
+exports.contextLinesIntegration = contextLinesIntegration;
+exports.createGetModuleFromFilename = createGetModuleFromFilename;
+exports.cron = cron;
+exports.defaultStackParser = defaultStackParser;
+exports.expressErrorHandler = expressErrorHandler;
+exports.expressIntegration = expressIntegration;
+exports.fastifyIntegration = fastifyIntegration;
+exports.getAutoPerformanceIntegrations = getAutoPerformanceIntegrations;
+exports.getClient = getClient;
+exports.getCurrentHub = getCurrentHub;
+exports.getDefaultIntegrations = getDefaultIntegrations;
+exports.getSentryRelease = getSentryRelease;
+exports.graphqlIntegration = graphqlIntegration;
+exports.hapiIntegration = hapiIntegration;
+exports.httpIntegration = httpIntegration;
+exports.init = init;
+exports.localVariablesIntegration = localVariablesIntegration;
+exports.makeMain = makeMain;
+exports.makeNodeTransport = makeNodeTransport;
+exports.modulesIntegration = modulesIntegration;
+exports.mongoIntegration = mongoIntegration;
+exports.mongooseIntegration = mongooseIntegration;
+exports.mysql2Integration = mysql2Integration;
+exports.mysqlIntegration = mysqlIntegration;
+exports.nativeNodeFetchIntegration = nativeNodeFetchIntegration;
+exports.nestIntegration = nestIntegration;
+exports.nodeContextIntegration = nodeContextIntegration;
+exports.onUncaughtExceptionIntegration = onUncaughtExceptionIntegration;
+exports.onUnhandledRejectionIntegration = onUnhandledRejectionIntegration;
+exports.postgresIntegration = postgresIntegration;
+exports.prismaIntegration = prismaIntegration;
+exports.setupExpressErrorHandler = setupExpressErrorHandler;
+exports.setupFastifyErrorHandler = setupFastifyErrorHandler;
+exports.setupHapiErrorHandler = setupHapiErrorHandler;
+exports.spotlightIntegration = spotlightIntegration;
 //# sourceMappingURL=index.js.map