This add-on is operated by New Relic
Monitor, troubleshoot, and tune production web applications.
Table of Contents
New Relic for Web Apps is an add-on for on-demand web application performance management. New Relic offers seamless integration with the Heroku platform, enabling immediate and automatic access to New Relic’s comprehensive capabilities for monitoring, troubleshooting and tuning web applications.
Adding the New Relic add-on for Web Apps to an application provides insight into:
- Customer satisfaction, via real-time end user experience monitoring
- Health and availability of your entire application, via application monitoring
- Web server resource data for Windows and Linux, via server monitoring
Supported languages and frameworks
The New Relic add-on is available for:
If you’re using Ruby, the add-on will work with any Rack app, including Rails and Sinatra.
To install the add-on, run the following command with the appropriate plan level:
$ heroku addons:add newrelic:stark
The example uses Stark. The other plan levels are: Wayne, Hawke, Drake, Murdock, Parker, West, Kent, Banner, and Marko. See the New Relic add-on plans page for details.
Installing the add-on will automatically point you to the integrated Heroku/New Relic account. The add-on automatically creates a private New Relic account, and configures access for Heroku servers. New Relic will begin monitoring application performance, end user experience, and server performance collected after the add-on is installed.
Upgrading from an existing New Relic installation
If New Relic for Web Apps is already installed, simply install the add-on using the steps above to upgrade.
To start seeing data from your application after installing the New Relic add-on you need to install and configure the Ruby agent gem.
- Add the Ruby agent gem to your Gemfile, bundle and commit your changes.
- Copy newrelic.yml to config/newrelic.yml.
- Set your application name using a heroku environment variable.
1. Add the New Relic gem to your Gemfile:
Add this line to your Gemfile
Make sure this line is outside any groups in your Gemfile (e.g. development or test). After adding the gem, bundle install and commit your changes to Gemfile and Gemfile.lock.
If you are using Unicorn you will need the
preload_app true directive in your unicorn.rb.
When starting Unicorn you must manually specify the path to your configuration file in order for it to take effect. To do this, pass the
-c <path> option to the unicorn invocation you use to start your server. This will be in your
2. Copy newrelic.yml into your application
Download newrelic.yml and save it at config/newrelic.yml, or run this curl command from the root of your application.
$ curl https://gist.githubusercontent.com/rwdaigle/2253296/raw/newrelic.yml > config/newrelic.yml
3. Set your application name
Set the name of your application as it will appear on the New Relic dashboard.
$ heroku config:set NEW_RELIC_APP_NAME="YOUR APP NAME GOES HERE"
Using New Relic from a Rack app
If you are using New Relic with a standard Rails app, you do not need to follow the steps in this section.
When using New Relic with a non-Rails app, you need to manually install the plugin into your code repo. For example, in a Sinatra app, add the
newrelic gem to your
Gemfile, then add the following code to your app:
configure :production do require 'newrelic_rpm' end
Next, specify your application environment:
$ heroku config:set RACK_ENV=production
Finally, commit and push to Heroku:
$ git commit -m "Added New Relic Plugin" $ git push heroku master
We do not install the New Relic plugin if we detect “newrelic_rpm” gem in your Gemfile.
Heroku will automatically configure your Ruby app with the latest New Relic plugin on your next
git push. This is the same as running:
$ script/plugin install git://github.com/newrelic/rpm.git
We autoconfigure your
config/newrelic.yml file with the proper access keys.
Customizing the Bamboo configuration
New Relic allows you customize certain settings by editing your configuration file. Heroku automatically writes this out, so you can’t directly edit the file. By setting certain configuration variables, you can change how the configuration file is generated.
Currently we support setting a custom apdex score, enabling parameter capture, and customizing the error collector.
$ heroku config:set NEW_RELIC_APDEX=0.4 $ heroku config:set NEW_RELIC_CAPTURE_PARAMS=TRUE $ heroku config:set NEW_RELIC_ERROR_COLLECTOR_ENABLED=false $ heroku config:set NEW_RELIC_ERROR_COLLECTOR_CAPTURE_SOURCE=false $ heroku config:set NEW_RELIC_ERROR_COLLECTOR_IGNORE_ERRORS=ActionController::RoutingError
Non-Maven Java apps
Download the latest Java agent .zip and unzip it into the root of your project.
This will create a directory called newrelic with the necessary files. Add it to your project with
$ git add newrelic.
Enable it by adding
-javaagent:newrelic/newrelic.jar to your
Add the New Relic agent as a Maven dependency
If your Java application is using Maven, you can add New Relic as a managed dependency. In your
pom.xml, add the
newrelic-agent dependency as shown below but replace X.X.X with the latest version. You can find the latest Java agent version in Maven Central.
<dependency> <groupId>com.newrelic.agent.java</groupId> <artifactId>newrelic-agent</artifactId> <version>X.X.X</version> <scope>provided</scope> </dependency>
Customize the build section so it always names the
<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <version>2.6</version> <executions> <execution> <id>copy-new-relic</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <includeGroupIds>com.newrelic.agent.java</includeGroupIds> <includeArtifactIds>newrelic-agent</includeArtifactIds> <stripVersion>true</stripVersion> </configuration> </execution> </executions> </plugin> </plugins> </build>
Create a New Relic configuration file
newrelic.yml file next to your
pom.xml. Use the template as a starting point. This should be checked into your repo. If you want to put it elsewhere, the location can be changed with a System Property or the
NEWRELIC_HOME environment variable.
$ git add newrelic.yml
Push these changes to your application:
$ git commit -m 'add newrelic' $ git push heroku master
Adding the New Relic Add-on will set the following config vars on your app:
These will override corresponding values from
Enable the Java agent
Add the following flag to your JAVA_OPTS config var on Heroku:
You can get the current value of your config var with:
$ heroku config ... JAVA_OPTS => -Xmx384m -Xss512k -XX:+UseCompressedOops ...
Copy the value, add the Java agent flag and app name :
Make sure to enter your own app name in this example.
$ heroku config:set JAVA_OPTS='-Xmx384m -Xss512k -XX:+UseCompressedOops -javaagent:target/dependency/newrelic-agent.jar' NEW_RELIC_APP_NAME="YOUR APP NAME GOES HERE" Adding config vars: JAVA_OPTS => -Xmx384m -Xss512.../newrelic-agent.jar
Add the New Relic agent as a Scala+SBT/Play 2 dependency
To use the New Relic API class or annotations:
Make sure the newrelic.yml file is at the root level of your project.
Add the New Relic agent as a Scala/Play dependency
Add this line (replacing x.x with the correct version) to the appDependencies method in your application’s project/Build.scala file:
"com.newrelic.agent.java" % "newrelic-agent" % "2.x.x"
This also includes the API, so the newrelic-api dependency is optional.
Make sure JAVA_OPTS is specified on execute line of the Procfile.
Push your changes to Heroku.
Update your JAVA_OPTS config.
When setting the Java agent flag, you will need specify the version number. Your heroku config command should look similar to this:
$ heroku config:set JAVA_OPTS="-XX:MaxPermSize=128m -Xmx334m -Xss512k -XX:+UseCompressedOops -Dnewrelic.bootstrap_classpath=true -javaagent:target/staged/newrelic-agent-2.X.X.jar"
As above, you can get the current value of your config var by running
heroku config with no arguments.
To install the Python package for the New Relic agent, create or edit the
requirements.txt file, adding the line
Deploying your app will now install the New Relic agent.
Modify the web entry in your
Procfile to start with
newrelic-admin run-program. The following example runs Django with a
run_gunicorn management command:
web: newrelic-admin run-program python hellodjango/manage.py run_gunicorn -b "0.0.0.0:$PORT" -w 3
Updating the Python agent
Heroku will cache packages and will not detect when a newer version of the Python agent is available. To force an upgrade to a newer version, explicitly list the version against the package name in the ‘requirements.txt’ file and push your application. Use this syntax:
Replace A.B.C.D with the version of the New Relic Python agent. When you change the version string to a newer version pip will perform the update.
Overriding the application name
Previously, Heroku would set
NEW_RELIC_APP_NAME when the New Relic add-on was setup to be the unique application name Heroku created for your site. This is no longer done for new deployments.
Application data from the Python agent will be reported to New Relic against the application name ‘Python Application’. The display name for this can be changed in the New Relic UI, however, it is recommended that it be changed to a unique unchanging value from the agent side.
Doing this is a requirement if you intend running multiple distinct sites under the one Heroku account and wish to have the data reported separately.
The application name can be overriden by using the Heroku toolbelt command:
$ heroku config:set NEW_RELIC_APP_NAME='Web Site (Production)'
Once done, you can verify that the configuartion has been updated by running the following, which will report the value assigned to
$ heroku run env | grep NEW_RELIC
Node.js agent on Heroku
This describes special considerations for using Heroku as a hosting service with New Relic’s Node.js agent. All of the configuration variables in newrelic.js have counterparts that can be set as environment variables. You can freely mix and match variables in the configuration file.
Note: Environment variables override your configuration file’s variables. For more information, see Configuring Node.js with environment variables.
Here is an example of using the command line to set environment variables.
$ heroku config:set NEW_RELIC_LICENSE_KEY=<your license key> $ heroku config:set NEW_RELIC_APP_NAME=<your production app name> $ heroku config:set NEW_RELIC_APDEX=<0.010>
To confirm your settings from the command line:
$ heroku config
If you’re using Leiningen 2.x and not using an uberjar-based deploy setup, you can add a
:java-agents entry to
project.clj to allow New Relic to instrument your app:
:java-agents [[com.newrelic.agent.java/newrelic-agent "2.19.0"]]
You can find the latest version of New Relic’s agent by searching the Central repository. Once you’ve added that, simply add
newrelic.yml to your codebase by downloading the template and setting
license_key, the latter of which can be found by running
heroku config:get NEW_RELIC_LICENSE_KEY. Commit this file and deploy.
View your performance data
You must enter New Relic through Heroku interface, otherwise it will not report correctly.
Click on the New Relic icon in your list of Add-ons. You will be redirected via SSO to your account on the New Relic site.
- From your dashboard, select the app for which you have installed the New Relic add-on.
- Select New Relic from your list of add-ons.
- See the New Relic documentation site for more information on working with New Relic.
Interpreting New Relic request queueing
For Ruby and Python apps, the New Relic dashboard shows an app server response time component labeled “Request Queuing”. “Request Queuing” is the time elapsed from a router receiving a request to a Rails controller action or Python app code initiating processing of the request. During this time, the request goes through the following stages:
- Processing in the router
- Traveling over the network to a dyno
- Queuing in the TCP socket backlog on the dyno
- Processing by the web server (eg. Unicorn, Gunicorn, mod_wsgi)
- Processing by Rack middleware configured for the app
All of the above count towards “Request Queuing” when New Relic displays where time was spent processing a request. Time spent in Django middleware is not included in the request queue time but is captured as ‘Python Time’ in the overview graph. For more details on how to interpret the request queuing metric, check out the New Relic Request Queuing documentation.