---
title: "Troubleshooting"
description: "If you need help solving issues with your Sentry JavaScript SDK integration, you can read the edge cases documented below."
url: https://docs.sentry.io/platforms/javascript/guides/react-router/troubleshooting/
---

# Troubleshooting for React Router Framework

The SDK is not sending any data

If you set up the Sentry SDK and it's not sending any data to Sentry:

* Check that you have configured a DSN and that you are passing it to the `dsn` option in `Sentry.init()`.

  If you are using environment variables to pass the DSN, make sure the environment variables are set in all relevant environments. Additionally, if you are using environment variables inside a framework, check that the framework will include the environment variables in your bundle. Often this means you will have to prefix your environment variables with special prefixes defined by your framework (`NEXT_PUBLIC_` in Next.js, `NUXT_` in Nuxt, `VITE_` for Vite projects, `REACT_APP_` for Create React App, ...).

* Check that you have disabled any ad-blockers.

* Set `debug: true` in the `Sentry.init()` options and observe your console output when you start your application. The SDK may tell you why it is not sending any data.

* Check the [Stats](https://sentry.io/orgredirect/organizations/:orgslug/stats/) and [Subscription](https://sentry.io/orgredirect/organizations/:orgslug/settings/billing/overview/) pages in Sentry. You may have ran out of quota.

Updating to a new Sentry SDK version

If you update your Sentry SDK to a new major version, you might encounter breaking changes that need some adaption on your end.

Check out our [migration guide](https://docs.sentry.io/platforms/javascript/guides/react-router/migration/v10-to-v11.md) to learn everything you need to know to get up and running again with the latest Sentry features.

Debugging additional data

You can view the JSON payload of an event to see how Sentry stores additional data in the event. The shape of the data may not exactly match the description.

For more details, see the [full documentation on Event Payload](https://develop.sentry.dev/sdk/foundations/transport/event-payloads/).

Max JSON payload size

By default, `maxValueLength` is undefined and nothing is truncated, but you can change this value according to your needs if your messages are longer (for example, to `250`). Please note that not every single value is affected by this option.

CORS attributes and headers

To gain visibility into a JavaScript exception thrown from scripts originating from different origins, do two things:

1. Add a crossorigin=”anonymous” script attribute

```bash
 <script src="http://another-domain.com/app.js" crossorigin="anonymous"></script>
```

The script attribute tells the browser to fetch the target file “anonymously.” Potentially user-identifying information like cookies or HTTP credentials won’t be transmitted by the browser to the server when requesting this file.

2. Add a Cross-Origin HTTP header

```bash
Access-Control-Allow-Origin: *
```

Cross-Origin Resource Sharing (CORS) is a set of APIs (mostly HTTP headers) that dictate how files ought to be downloaded and served across origins.

By setting `Access-Control-Allow-Origin: *`, the server is indicating to browsers that any origin can fetch this file. Alternatively, you can restrict it to a known origin you control:

```bash
 Access-Control-Allow-Origin: https://www.example.com
```

Most community CDNs properly set an `Access-Control-Allow-Origin` header.

```bash
 $ curl --head https://ajax.googleapis.com/ajax/libs/jquery/2.2.0/jquery.js | \
 grep -i "access-control-allow-origin"

 Access-Control-Allow-Origin: *
```

Events blocked by Chrome's local network access prompt

If your users see a Chrome prompt asking to allow the page to access devices on their local network, or events never reach Sentry and the browser console shows failed requests to your Sentry or Spotlight URL, Chrome's local network access check may be blocking them.

Chrome groups network addresses into three address spaces, from least to most private: public, private network (for example `10.x.x.x` or `192.168.x.x`), and loopback (`localhost`). Since Chrome 142, a page needs the user's permission before it can send requests to a more private address space than the one it was loaded from.

| App runs on                  | Sends events to              | Result            |
| ---------------------------- | ---------------------------- | ----------------- |
| localhost                    | localhost                    | Allowed           |
| localhost or private network | public Sentry                | Allowed           |
| public                       | private network or localhost | Permission prompt |
| private network              | localhost                    | Permission prompt |

This affects a publicly hosted app reporting to a self-hosted Sentry that is only reachable on an internal address, and Spotlight enabled on a non-localhost page. To avoid the prompt, expose Sentry on a public hostname, or use a [tunnel](https://docs.sentry.io/platforms/javascript/guides/react-router/configuration/tunneling.md) to send events through your app's own origin.

Unexpected OPTIONS request

If your application started to misbehave because of performing additional OPTIONS requests, it is most likely an issue with unwanted `sentry-trace` request headers, which can happen when you are using too generic a configuration for our Tracing Integration in the Browser SDK.

To fix this, change the `tracePropagationTargets` option during SDK initialization. For more details, see [Automatic Instrumentation](https://docs.sentry.io/platforms/javascript/guides/react-router/tracing/instrumentation/automatic-instrumentation.md#tracePropagationTarget) in our Tracing documentation.

\`instrument.js\` Line Numbers for Console Log statements

If `instrument.js` displays in your console while debugging, add Sentry to your [Framework Ignore List](https://developer.chrome.com/docs/devtools/settings/ignore-list/#skip-extensions) by adding this pattern: `/@sentry/`

Chrome then ignores the SDK stack frames when debugging.

Dealing with Ad-Blockers

Ad-blocking or script-blocking extensions may block Sentry in two ways:

* They block requests to Sentry's ingest endpoints, so captured data never reaches [sentry.io](https://sentry.io). Send events through your own server to avoid this, as described in [Tunneling](https://docs.sentry.io/platforms/javascript/guides/react-router/configuration/tunneling.md).
* When you load the SDK from our CDN, they may prevent it from being fetched and initialized. Any call to the SDK's API then fails and may cause your application to behave unexpectedly. Any of the following solutions resolves this.

### [Using the NPM Package](https://docs.sentry.io/platforms/javascript/guides/react-router/troubleshooting.md#using-the-npm-package)

The best way to deal with script-blocking extensions is to use the SDK package directly through the `npm` and bundle it with your application. This way, you can be sure that the code will be always be there as you expect it to be.

### [Self-hosting CDN bundles](https://docs.sentry.io/platforms/javascript/guides/react-router/troubleshooting.md#self-hosting-cdn-bundles)

The second way is to download the SDK from our CDN and host it yourself. This way, the SDK will still be separated from the rest of your code, but you'll be certain that it won't be blocked since its origin will be the same as the origin of your website.

You can easily fetch it using `curl` or any other similar tool:

```bash
curl https://browser.sentry-cdn.com/5.20.1/bundle.min.js -o sentry.browser.5.20.1.min.js -s
```

### [Using the JavaScript Proxy API](https://docs.sentry.io/platforms/javascript/guides/react-router/troubleshooting.md#using-the-javascript-proxy-api)

The last option is to use `Proxy` guard, which will make sure that your code won't break, even when you call our SDK, which was blocked. `Proxy` is supported by all browser except Internet Explorer, though there are no extensions in this browser. Also if `Proxy` is not in any of your user's browser, it will be silently skipped, so you don't have to worry about it breaking anything.

Place this snippet immediately **above** the `<Expandable>` tag containing our CDN bundle. The snippet in a readable format presents like this:

```javascript
if ("Proxy" in window) {
  var handler = {
    get: function (_, key) {
      return new Proxy(function (cb) {
        if (key === "flush" || key === "close") return Promise.resolve();
        if (typeof cb === "function") return cb(window.Sentry);
        return window.Sentry;
      }, handler);
    },
  };
  window.Sentry = new Proxy({}, handler);
}
```

If you would like to copy and paste the snippet directly, here it is minified:

```html
<script>
  if ("Proxy" in window) {
    var n = {
      get: function (o, e) {
        return new Proxy(function (n) {
          return "flush" === e || "close" === e
            ? Promise.resolve()
            : "function" == typeof n
              ? n(window.Sentry)
              : window.Sentry;
        }, n);
      },
    };
    window.Sentry = new Proxy({}, n);
  }
</script>
```

Third party promise libraries

When you include and configure Sentry, our JavaScript SDK automatically attaches global handlers to *capture* uncaught exceptions and unhandled promise rejections. You can disable this default behavior by changing the `onunhandledrejection` option to `false` in your GlobalHandlers integration and manually hook into each event handler, then call `Sentry.captureException` or `Sentry.captureMessage` directly.

You may also need to manage your configuration if you are using a third-party library to implement promises. Also, remember that browsers often implement security measures that can block error reporting when serving script files from different origins.

Events with 'Non-Error Exception'

If you’re seeing errors with the message “Non-Error exception (or promise rejection) captured with keys: x, y, z.”, this happens when you a) call `Sentry.captureException()` with a plain object, b) throw a plain object, or c) reject a promise with a plain object.

You can see the contents of the non-Error object in question in the `__serialized__` entry of the “Additional Data” section.

To get better insight into these error events, we recommend finding where the plain object is being passed or thrown to Sentry based on the contents of the `__serialized__` data, and then turning the plain object into an Error object.

Capturing resource 404s

By default, Sentry does not capture errors when a resource (like an image or a css file) fails to load. If you would like it to do so, you can use the following code. (Note: We recommend loading Sentry as early as possible in any case, but this method in particular will only work if Sentry is loaded before other resources.)

```javascript
document.body.addEventListener(
  "error",
  (event) => {
    if (!event.target) return;

    if (event.target.tagName === "IMG") {
      Sentry.captureException(
        new Error(`Failed to load image: ${event.target.src}`),
      );
    } else if (event.target.tagName === "LINK") {
      Sentry.captureException(
        new Error(`Failed to load css: ${event.target.href}`),
      );
    }
  },
  true, // useCapture - necessary for resource loading errors
);
```

Remember to pass in `true` as the second parameter to `addEventListener()`. Without it, the event handler won't be called, since it's being added to the event target's ancestor rather than the event target itself, and unlike JavaScript runtime errors, `error` events resulting from load failures don't bubble, and therefore must be captured during the `capture` phase. For more information, see [the W3C spec](https://www.w3.org/TR/2003/NOTE-DOM-Level-3-Events-20031107/events.html#Events-phases).

SDK causes double invocations of \`addEventListener\` (e.g. duplicated click events)

In very rare cases, the SDK can cause callbacks added via `addEventListener` to an event target (such as a button) to be invoked twice. This is usually a sign of the SDK being initialized too late in the lifecycle of the page. If you can, try initializing the SDK earlier in your application.

If this is not possible or doesn't apply to your use case, set the `unregisterOriginalCallbacks` option in the [`browserApiErrors` integration](https://docs.sentry.io/platforms/javascript/guides/react-router/configuration/integrations/browserapierrors.md) to `true`.

Build errors with vite

If you're using the [Vite Bundler](https://vitejs.dev/) and a Sentry NPM package, and you see the following error:

```bash
Error: Could not resolve './{}.js' from node_modules/@sentry/utils/esm/index.js
```

This might be because the [`define`](https://vitejs.dev/config/shared-options.html#define) option in your Vite config is string-replacing some variable used by the Sentry SDK, like `global`, which causes build errors. Vite recommends using `define` for CONSTANTS only, and not putting `process` or `global` into the options. To fix this build error, remove or update your `define` option, as shown below:

```javascript
export default defineConfig({
   build: {
     sourcemap: 'hidden'
   },
-  define: {
-    global: {}
-  },
   plugins: [react()]
})
```

Missing module \`diagnostics\_channel\`

If you're getting build errors when using any of the JavaScript SDKs mentioning something along the lines of "Cannot find module diagnostics\_channel", try to configure your build tool to either externalize or ignore the `diagnostics_channel` module. The Sentry Node.js SDK uses this built-in module to instrument Node.js fetch requests. Some older Node.js versions do not have the `diagnostics_channel` API, which may lead to build errors when attempting to bundle your code.

Most bundlers have an option to externalize specific modules (like `diagnostics_channel`):

* [Externals in Webpack](https://webpack.js.org/configuration/externals/)
* [External in Vite](https://vitejs.dev/config/ssr-options.html#ssr-external)
* [External in esbuild](https://esbuild.github.io/api/#external)
* [External in Rollup](https://rollupjs.org/configuration-options/#external)

Terser plugin build errors

If you're using a custom webpack plugin that utilizes Terser or another minifier, you might encounter build errors due to a known webpack bug. This issue has been fixed in webpack version 5.85.1 and later.

For more details about this issue, see [webpack/terser-plugin build errors](https://github.com/getsentry/sentry-javascript/issues/14091).

If you need additional help, you can [ask on GitHub](https://github.com/getsentry/sentry-javascript/issues/new/choose). Customers on a paid plan may also contact support.

## Pages in this section

- [Supported Browsers](https://docs.sentry.io/platforms/javascript/guides/react-router/troubleshooting/supported-browsers.md)
