# Browser Profiling | Sentry for React Router Framework

Browser Profiling is currently in beta. Beta features are still in progress and may have bugs. We recognize the irony.

The browser profiling integration is built using the [JS Self-Profiling API](https://wicg.github.io/js-self-profiling/) and will likely only move out of beta once the specification progresses and gains adoption. See [platform status](https://chromestatus.com/feature/5170190448852992).

Note that since the profiling API is currently only exposed in Chromium, profiles collected only include that demographic. We hope that as the API gains adoption, other browsers will implement it as well.

With [profiling](https://docs.sentry.io/product/explore/profiling.md), Sentry tracks your software's performance by sampling your program's call stack in a variety of environments. This feature collects function-level information about your code and enables you to fine-tune your program's performance. Sentry's profiler captures function calls and their exact locations, aggregates them, and shows you the most common code paths of your program. This highlights areas you could optimize to help increase both the performance of your code and user satisfaction.

In a browser environment, profiling can help you pinpoint causes of UI jank, surface why values like interaction to next paint (INP) are performing poorly, or why a long task was keeping the browser from repainting the screen and causing frame drops. All of this information enables you to fix real world performance issues and deliver a snappier user experience to your users.

## [Prerequisites](https://docs.sentry.io/platforms/javascript/guides/react-router/profiling/browser.md#prerequisites)

To get started with JavaScript browser profiling, you'll need to:

* Install the `@sentry/react-router `SDK, minimum version 7.60.0
* Configure the document response header to include `Document-Policy: js-profiling`
* Configure the SDK to use the `BrowserProfilingIntegration` and set `profilesSampleRate`

## [Step 1: Install the <!-- -->React Router Framework <!-- -->SDK](https://docs.sentry.io/platforms/javascript/guides/react-router/profiling/browser.md#step-1-install-the--sdk)

Install our <!-- -->React Router Framework <!-- -->SDK using either `yarn` or `npm`, the minimum version that supports profiling is **7.60.0**.

```bash
npm install @sentry/browser --save
```

## [Step 2: Add Document-Policy: js-profiling header](https://docs.sentry.io/platforms/javascript/guides/react-router/profiling/browser.md#step-2-add-document-policy-js-profiling-header)

For the JavaScript browser profiler to start, the document response header needs to include a `Document-Policy` header key with the `js-profiling` value.

How you do this will depend on your server. If you're using a server like Express, you'll be able to use the [response.set](https://expressjs.com/en/4x/api.html#res.set) function.

```javascript
app.get("/", (request, response) => {
  response.set("Document-Policy", "js-profiling");
  response.sendFile("index.html");
});
```

## [Step 3: Configure the <!-- -->React Router Framework <!-- -->SDK](https://docs.sentry.io/platforms/javascript/guides/react-router/profiling/browser.md#step-3-configure-the--sdk)

Configuration should happen as early as possible in your application's lifecycle. Once this is done, Sentry's JavaScript SDK will capture all unhandled exceptions and transactions.

```javascript
import * as Sentry from "@sentry/browser";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  integrations: [
    // Add browser profiling integration to the list of integrations
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],

  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  tracesSampleRate: 1.0,
  // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],

  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
});
```

Alternatively, instead of a `profilesSampleRate` your can also provide a `profilesSampler` function:

```javascript
const Sentry = require("@sentry/browser");

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  integrations: [
    // Add browser profiling integration to the list of integrations
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
  tracesSampleRate: 1.0,

  // This function will be called for every sampled span
  // to determine if it should be profiled
  profilesSampler: (samplingContext) => {
    return 1.0;
  },
});
```

## [The Difference Between DevTools & Sentry's JavaScript Browser Profiler](https://docs.sentry.io/platforms/javascript/guides/react-router/profiling/browser.md#the-difference-between-devtools--sentrys-javascript-browser-profiler)

What does Sentry's JavaScript browser profile offer that Chrome DevTools does not?

* Sentry's JavaScript profiler runs in production and captures real user data, showing real-world performance. DevTools runs locally and only shows profiles of what's running on your machine.
* Sentry runs at a lower sampling rate of 100Hz with a 10ms sample period versus a sampling rate of 1000Hz and a 1ms sample period for DevTools.
* Sentry supports deobfuscation, making it so that all the function names in your code are correct. Typically, when you run JavaScript code, it's minified, meaning that all the function names are replaced with machine-generated abbreviations.

Please note, that since the browser profiling API is currently only implemented in Chromium-based browsers, the profiles collected with Sentry's JavaScript browser profiling will inherently be biased toward that demographic. This is something that you'll need to consider if you're basing your decisions on the data collected.

We hope that as the JavaScript browser profiling API gains adoption, other browsers will implement it as well. If you find the browser profiling feature helpful and would like to see it gain further adoption, please consider supporting the spec at the official WICG repository.
