newrelic vs logrocket vs rollbar vs trackjs vs raygun vs sentry
Error Tracking and Monitoring Tools Comparison
1 Year
newreliclogrocketrollbartrackjsraygunsentrySimilar Packages:
What's Error Tracking and Monitoring Tools?

Error tracking and monitoring tools are essential for web development as they help developers identify, diagnose, and resolve issues in their applications. These tools provide insights into application performance, user interactions, and error occurrences, allowing teams to enhance user experience and maintain application reliability. By integrating these tools, developers can proactively monitor their applications, receive alerts for issues, and analyze error reports to improve overall software quality.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
newrelic927,0699732.22 MB606 days agoApache-2.0
logrocket364,625-331 kB-a month agoMIT
rollbar357,6265754.2 MB86a year agoMIT
trackjs46,125127137 kB3a year agoSEE LICENSE IN LICENSE.md
raygun15,74031112 kB0a month ago-
sentry8,861---13 years ago-
Feature Comparison: newrelic vs logrocket vs rollbar vs trackjs vs raygun vs sentry

Error Reporting

  • newrelic:

    New Relic provides comprehensive error reporting with detailed stack traces, user sessions, and performance metrics, enabling developers to pinpoint the root cause of issues quickly.

  • logrocket:

    LogRocket captures errors along with session replays, allowing developers to see exactly what users experienced before an error occurred. This context helps in diagnosing issues more effectively.

  • rollbar:

    Rollbar provides real-time error tracking with contextual information about the error, including the user’s actions leading up to the error, which aids in faster resolution.

  • trackjs:

    TrackJS focuses on JavaScript errors, providing real-time error reporting with stack traces and user context, making it easy to identify and fix client-side issues.

  • raygun:

    Raygun offers real-time error reporting with detailed diagnostics, including the affected users, environment, and stack traces, making it easy to understand and fix issues promptly.

  • sentry:

    Sentry captures unhandled exceptions and provides detailed error reports, including stack traces, breadcrumbs, and user context, allowing for efficient debugging and issue resolution.

Performance Monitoring

  • newrelic:

    New Relic excels in performance monitoring, offering insights into application performance, response times, and throughput, making it ideal for optimizing application efficiency.

  • logrocket:

    LogRocket also tracks performance metrics, such as load times and API response times, giving developers a holistic view of application performance alongside error tracking.

  • rollbar:

    Rollbar provides performance insights related to error occurrences, helping teams understand the impact of errors on overall application performance.

  • trackjs:

    TrackJS does not focus heavily on performance monitoring but provides basic insights into JavaScript execution times and error occurrences.

  • raygun:

    Raygun includes performance monitoring features that allow developers to track application speed and user experience, helping identify performance bottlenecks.

  • sentry:

    Sentry offers performance monitoring features that allow developers to track transaction performance, identify slow transactions, and optimize application responsiveness.

Integration and Setup

  • newrelic:

    New Relic offers extensive integrations with various platforms, but its setup can be more complex due to the depth of monitoring it provides.

  • logrocket:

    LogRocket is straightforward to integrate with various frameworks and libraries, requiring minimal setup to start capturing user sessions and errors.

  • rollbar:

    Rollbar is designed for easy integration with modern development workflows, offering SDKs for various languages and frameworks, making setup quick and efficient.

  • trackjs:

    TrackJS is very easy to set up, requiring just a few lines of code to start tracking JavaScript errors, making it ideal for quick implementations.

  • raygun:

    Raygun provides easy integration with popular frameworks and languages, allowing teams to get started quickly with error tracking and performance monitoring.

  • sentry:

    Sentry supports a wide range of programming languages and frameworks, providing easy-to-follow documentation for quick integration into existing projects.

User Experience Insights

  • newrelic:

    New Relic focuses more on performance metrics than user experience insights, making it less suitable for understanding user interactions directly.

  • logrocket:

    LogRocket provides session replay features that allow developers to watch user sessions, offering insights into user behavior and experience, which is invaluable for debugging.

  • rollbar:

    Rollbar provides contextual information about users affected by errors, but it does not offer session replay features like LogRocket.

  • trackjs:

    TrackJS focuses primarily on error tracking and does not provide user experience insights beyond error occurrences.

  • raygun:

    Raygun offers insights into user sessions and error occurrences, helping teams understand how users are affected by errors in real-time.

  • sentry:

    Sentry provides user context for errors, allowing developers to see which users encountered issues, but lacks session replay capabilities.

Pricing and Plans

  • newrelic:

    New Relic has a more complex pricing structure based on usage, which can be beneficial for larger teams but may be costly for smaller projects.

  • logrocket:

    LogRocket offers a tiered pricing model based on the number of sessions recorded, making it flexible for different project sizes and budgets.

  • rollbar:

    Rollbar has a free tier for small projects and tiered pricing based on the number of errors tracked, making it suitable for startups and larger teams alike.

  • trackjs:

    TrackJS has a straightforward pricing model based on the number of tracked errors, making it affordable for smaller projects.

  • raygun:

    Raygun offers competitive pricing with various plans based on the number of errors tracked and users monitored, making it accessible for small to medium-sized teams.

  • sentry:

    Sentry offers a generous free tier with pricing based on usage, making it a good choice for teams looking for a cost-effective solution.

How to Choose: newrelic vs logrocket vs rollbar vs trackjs vs raygun vs sentry
  • newrelic:

    Select New Relic if you require a robust application performance monitoring (APM) solution that offers deep insights into your application's performance metrics, including response times, throughput, and error rates. It is ideal for large-scale applications where performance optimization is critical.

  • logrocket:

    Choose LogRocket if you need a comprehensive session replay tool that helps you understand user behavior and experience in addition to error tracking. It provides insights into how users interact with your application, which can be invaluable for debugging and improving user experience.

  • rollbar:

    Choose Rollbar if you need real-time error tracking with a focus on deployment tracking and detailed error context. It is particularly useful for teams that frequently deploy updates and need to monitor the impact of changes on application stability.

  • trackjs:

    Choose TrackJS if you are looking for a lightweight JavaScript error tracking solution that provides simple integration and real-time error monitoring. It is ideal for smaller projects or teams that need a straightforward tool without extensive overhead.

  • raygun:

    Opt for Raygun if you want a user-friendly interface with powerful error tracking and performance monitoring capabilities. It provides real-time error reporting and detailed diagnostics, making it suitable for teams looking for quick insights and easy integration.

  • sentry:

    Select Sentry if you want a versatile error tracking tool that integrates well with various programming languages and frameworks. It offers detailed error reports, performance monitoring, and release tracking, making it suitable for diverse development environments.

README for newrelic

New Relic Open Source community plus project banner.

New Relic's Node.js agent

npm status badge Server Smoke Tests Node Agent CI codecov

This package instruments your application for performance monitoring with New Relic.

In order to take full advantage of this package, make sure you have a New Relic account before starting. Available features, such as slow transaction traces, will vary based on account level.

As with any instrumentation tool, please test before using in production.

Installation

To use New Relic's Node.js agent entails these three steps, which are described in detail below:

  1. To install the agent for performance monitoring, use your favorite npm-based package manager and install the newrelic package into your application:

    $ npm install newrelic
    
  2. Then, copy the stock configuration file to your program's base folder:

    $ cp ./node_modules/newrelic/newrelic.js ./<your destination>
    
  3. Now, add your New Relic license key and application/service name to that file:

    /* File: newrelic.js */
    'use strict'
    /**
     * New Relic agent configuration.
     *
     * See lib/config/default.js in the agent distribution for a more complete
     * description of configuration variables and their potential values.
     */
    exports.config = {
      app_name: ['Your application or service name'],
      license_key: 'your new relic license key',
      /* ... rest of configuration .. */
    }
  1. Finally, run your program with the newrelic module loaded first by using node's -r/--require flag.
 $ node -r newrelic your-program.js

If you cannot control how your program is run, you can load the newrelic module before any other module in your program.

    const newrelic = require('newrelic')

    /* ... the rest of your program ... */

Next.js instrumentation

Note: The minimum supported Next.js version is 12.0.9. If you are using Next.js middleware the minimum supported version is 12.2.0.

The New Relic Node.js agent provides instrumentation for Next.js The instrumentation provides telemetry for server-side rendering via getServerSideProps, middleware, and New Relic transaction naming for both page and server requests. It does not provide any instrumentation for actions occurring during build or in client-side code. If you want telemetry data on actions occurring on the client (browser), you can inject the browser agent.

Here are documents for more in-depth explanations about transaction naming, and segments/spans.

Setup

Typically you are running a Next.js app with the next cli and you must load the agent via NODE_OPTIONS:

NODE_OPTIONS='-r newrelic' next start

If you are having trouble getting the newrelic package to instrument Next.js, take a look at our FAQs.

Next.js example projects

The following example applications show how to load the newrelic instrumentation, inject browser agent, and handle errors:

Custom Next.js servers

If you are using next as a custom server, you're probably not running your application with the next CLI. In that scenario we recommend running the Next.js instrumentation as follows.

node -r newrelic your-program.js

ECMAScript Modules

If your application is written with import and export statements in javascript, you are using ES Modules and must bootstrap the agent in a different way.

The New Relic Node.js agent includes experimental support for ES Modules. The agent is reliant on an experimental feature in Node.js in order to appropriately register instrumentation. Until the Node.js API for ES Module Loaders is stable, breaking changes may occur when updating Node.js. Lastly, the ESM loader does not follow the same supported Node.js versions as the agent. The minimum supported version of Node.js is v16.12.0.

Setup

  1. If you rely on a configuration file to run the agent, you must rename the file from newrelic.js to newrelic.cjs so it can be properly loaded. All the contents of the configuration file will behave the same once you rename. See CommonJS modules in ESM for more details.
$ mv newrelic.js newrelic.cjs
  1. To use the newrelic ESM loader, start your program with node and use the --experimental-loader flag and a path to the loader file, like this:
$ node --experimental-loader newrelic/esm-loader.mjs -r newrelic your-program.js

Note: Unlike the CommonJS methods listed above, there are no alternatives to running the agent without the --experimental-loader flag.

Custom Instrumentation

The agent supports adding your own custom instrumentation to ES module applications. You can use the instrumentation API methods. The only other difference between CommonJS custom instrumentation and ESM is you must provide a property of isEsm: true.

import newrelic from 'newrelic'
newrelic.instrument({ moduleName: 'parse-json', isEsm: true }, function wrap(shim, parseJson, moduleName) {
  shim.wrap(parseJson.default, function wrapParseJson(shim, orig) {
      return function wrappedParseJson() {
          const result = orig.apply(this, arguments)
          result.instrumented = true
          return true
      }
  })
})

We support the following custom instrumentation API methods in ES module apps:

  • newrelic.instrument
  • newrelic.instrumentConglomerate
  • newrelic.instrumentDatastore
  • newrelic.instrumentMessages
  • newrelic.instrumentWebframework

Note that we do not support newrelic.instrumentLoadedModule, for the same issue of immutability mentioned above.

If you want to see an example of how to write custom instrumentation in an ES module app, check out our examples repo for a working demo.

Getting Started

For more information on getting started, check the Node.js docs.

External Modules

There are modules that can be installed and configured to accompany the Node.js agent:

There are modules included within the Node.js agent to add more instrumentation for 3rd party modules:

Usage

Using the API

The newrelic module returns an object with the Node.js agent's API methods attached.

    const newrelic = require('newrelic')

    /* ... */
    newrelic.addCustomAttribute('some-attribute', 'some-value')

You can read more about using the API over on the New Relic documentation site.

Testing

These are the steps to work on core agent features, with more detail below:

  • Fork the agent
  • Install its dependencies
  • Run tests using npm
  1. Fork and clone this GitHub repository:

    $ git clone git@github.com:your-user-name/node-newrelic.git $ cd node-newrelic

  2. Install the project's dependencies:

    $ npm install

Then you're all set to start programming.

To run the test suite

  1. Install Docker
  2. Start the Docker services: $ npm run services
  3. Run all the tests using $ npm run test

Available test suites include:

$ npm run unit
$ npm run integration
$ npm run versioned
$ npm run lint
$ npm run smoke

Further Reading

Here are some resources for learning more about the agent:

Support

Should you need assistance with New Relic products, you are in good hands with several support channels.

If the issue has been confirmed as a bug or is a feature request, please file a GitHub issue.

Support Channels

Privacy

At New Relic we take your privacy and the security of your information seriously, and are committed to protecting your information. We must emphasize the importance of not sharing personal data in public forums, and ask all users to scrub logs and diagnostic information for sensitive information, whether personal, proprietary, or otherwise.

We define “Personal Data” as any information relating to an identified or identifiable individual, including, for example, your name, phone number, post code or zip code, Device ID, IP address and email address.

Please review New Relic’s General Data Privacy Notice for more information.

Roadmap

See our roadmap, to learn more about our product vision, understand our plans, and provide us valuable feedback.

Contribute

We encourage your contributions to improve the Node.js agent! Keep in mind when you submit your pull request, you'll need to sign the CLA via the click-through using CLA-Assistant. You only have to sign the CLA one time per project.

If you have any questions, or to execute our corporate CLA, required if your contribution is on behalf of a company, please drop us an email at opensource@newrelic.com.

A note about vulnerabilities

As noted in our security policy, New Relic is committed to the privacy and security of our customers and their data. We believe that providing coordinated disclosure by security researchers and engaging with the security community are important means to achieve our security goals.

If you believe you have found a security vulnerability in this project or any of New Relic's products or websites, we welcome and greatly appreciate you reporting it to New Relic through our bug bounty program.

If you would like to contribute to this project, review these guidelines.

To all contributors, we thank you! Without your contribution, this project would not be what it is today. We also host a community project page dedicated to New Relic Node Agent.

License

Except as noted below, the Node.js agent is licensed under the Apache 2.0 License.

The New Relic security agent is licensed under the New Relic Software License v1.0. The New Relic security agent module may be integrated like the New Relic Node.js agent.

The Node.js agent also uses source code from third-party libraries. You can find full details on which libraries are used and the terms under which they are licensed in the third-party notices document.