@sentry/react

What is @sentry/react?

The @sentry/react package is designed for error monitoring and performance tracking in React applications. It provides a comprehensive set of tools to capture exceptions, track performance issues, and improve the overall reliability of React applications. By integrating Sentry into a React project, developers can gain insights into errors and performance bottlenecks, allowing for quicker debugging and optimization.

What are @sentry/react's main functionalities?

Error Boundary

This feature automatically catches JavaScript errors anywhere in the child component tree of the Error Boundary and logs them to Sentry. It also displays a fallback UI instead of the component tree that crashed.

import React from 'react';
import * as Sentry from '@sentry/react';

const MyApp = () => (
  <Sentry.ErrorBoundary fallback={'An error has occurred'}>
    <YourApp />
  </Sentry.ErrorBoundary>
);

Performance Monitoring

Enables performance monitoring in your React application. By setting the `tracesSampleRate` to a value between 0 and 1, you can control the percentage of transactions sent to Sentry for performance analysis.

import * as Sentry from '@sentry/react';

Sentry.init({
  dsn: 'YOUR_DSN',
  tracesSampleRate: 1.0,
});

Custom Error Tracking

Allows for manual reporting of errors or exceptions to Sentry, giving developers the flexibility to capture specific issues that may not be automatically detected.

import * as Sentry from '@sentry/react';

Sentry.captureException(new Error('This is my custom error.'));

Other packages similar to @sentry/react

logrocket

LogRocket is a frontend application monitoring solution that provides session replay, performance monitoring, and error tracking. While it offers similar error tracking capabilities to @sentry/react, LogRocket distinguishes itself with its session replay feature, allowing developers to see exactly what users saw when an error occurred.

bugsnag

Bugsnag offers error monitoring and application stability management for various programming languages and frameworks, including React. Compared to @sentry/react, Bugsnag emphasizes application stability metrics and provides detailed error grouping and analysis, making it easier to prioritize and fix critical errors.

README

Official Sentry SDK for ReactJS

Links

• Official SDK Docs
• TypeDoc

General

This package is a wrapper around @sentry/browser, with added functionality related to React. All methods available in @sentry/browser can be imported from @sentry/react.

To use this SDK, call Sentry.init(options) before you mount your React component.

import React from 'react';
import { createRoot } from 'react-dom/client';
import * as Sentry from '@sentry/react';

Sentry.init({
  dsn: '__DSN__',
  // ...
});

// ...

const container = document.getElementById(“app”);
const root = createRoot(container);
root.render(<App />);

// also works with hydrateRoot
// const domNode = document.getElementById('root');
// const root = hydrateRoot(domNode, reactNode);
// root.render(<App />);

React 19

Starting with React 19, the createRoot and hydrateRoot methods expose error hooks that can be used to capture errors automatically. Use the Sentry.reactErrorHandler function to capture errors in the error hooks you are interested in.

const container = document.getElementById(“app”);
const root = createRoot(container, {
  // Callback called when an error is thrown and not caught by an Error Boundary.
  onUncaughtError: Sentry.reactErrorHandler((error, errorInfo) => {
    console.warn('Uncaught error', error, errorInfo.componentStack);
  }),
  // Callback called when React catches an error in an Error Boundary.
  onCaughtError: Sentry.reactErrorHandler(),
  // Callback called when React automatically recovers from errors.
  onRecoverableError: Sentry.reactErrorHandler(),
});
root.render(<App />);

If you want more finely grained control over error handling, we recommend only adding the onUncaughtError and onRecoverableError hooks and using an ErrorBoundary component instead of the onCaughtError hook.

ErrorBoundary

@sentry/react exports an ErrorBoundary component that will automatically send Javascript errors from inside a component tree to Sentry, and set a fallback UI.

app.js

import React from 'react';
import * as Sentry from '@sentry/react';

function FallbackComponent() {
  return <div>An error has occured</div>;
}

class App extends React.Component {
  render() {
    return (
      <Sentry.ErrorBoundary fallback={FallbackComponent} showDialog>
        <OtherComponents />
      </Sentry.ErrorBoundary>
    );
  }
}

export default App;

Profiler

@sentry/react exports a Profiler component that leverages the tracing features to add React-related spans to transactions. If tracing is not enabled, the Profiler component will not work. The Profiler tracks component mount, render duration and updates.

app.js

import React from 'react';
import * as Sentry from '@sentry/react';

class App extends React.Component {
  render() {
    return (
      <FancyComponent>
        <InsideComponent someProp={2} />
        <AnotherComponent />
      </FancyComponent>
    );
  }
}

export default Sentry.withProfiler(App);

Changelog

8.25.0

Important Changes

• Alpha release of Official Solid Start SDK

This release contains the alpha version of @sentry/solidstart, our SDK for Solid Start! For details on how to use it, please see the README. Any feedback/bug reports are greatly appreciated, please reach out on GitHub.

Other Changes

• feat(astro): Add bundleSizeOptimizations vite options to integration (#13250)
• feat(astro): Always add BrowserTracing (#13244)
• feat(core): Add getTraceMetaTags function (#13201)
• feat(nestjs): Automatic instrumentation of nestjs exception filters (#13230)
• feat(node): Add useOperationNameForRootSpan tographqlIntegration (#13248)
• feat(sveltekit): Add wrapServerRouteWithSentry wrapper (#13247)
• fix(aws-serverless): Extract sentry trace data from handler context over event (#13266)
• fix(browser): Initialize default integration if defaultIntegrations: undefined (#13261)
• fix(utils): Streamline IP capturing on incoming requests (#13272)