This release adds improved support for PostgreSQL 8.0+ with jdbc3+. All of these versions now include support for explain plans.
This release adds improved support for PostgreSQL 8.0+ with jdbc3+. All of these versions now include support for explain plans.
The agent now identifies external calls when Spray Client is used. You will see your Spray Client calls with the hostname and port of the destination. The calls also have support for Cross Application Tracing, and are shown in Service Maps and Transaction Maps.
The agent now tracks Futures started in Spray routes.
The agent now identifies transactions when spray-can is used without spray-routing.
The agent now tracks async activity created by Typesafe/Lightbend's functional-relational-mapper, Slick. If the underlying database driver is supported by the agent the database activity will be traced.
Improvements for JDBC
The Java agent’s JDBC instrumentation now provides more consistent and complete data for supported JDBC drivers. The Java agent supports the following drivers:
Note Previous versions of the Java Agent had partial “generic” support for other JDBC drivers. The new, improved JDBC instrumentation replaces the “generic” JDBC instrumentation.
Fixed a bug where CXF would name transactions based on auto-generated proxy classes. The agent now normalizes CXF transaction names.
Fixed a bug in EJB instrumentation that could cause a NullPointerException in application code.
Fixed a bug where the EJB instrumentation erroneously set transaction names. In this version, the agent records a metric.
Fixed a bug in the Cross Application Tracing API that caused Application Response time to be attributed to other transaction time, and prevented linking of transaction traces when doing CAT.
Fixed a bug in request queueing calculations where queueing time could show up as a steadily increasing value instead of the correct time.
Fixed a bug that prevented HttpURLConnection External metrics from reporting on the IBM J9 JVM.
With Spray routing, fixed a bug that incorrectly set the transaction name of similar route names or set them to "Unknown Route".
Fixed a bug where some transaction traces would report external segments for non I/O calls in Apache HttpClient.
The Java Agent will now read Cross Application Tracing HTTP header names regardless of case.
Fixed a bug that could cause cross application tracing between the New Relic Java Agent and non-Java New Relic Agents to fail.
This release does not contain support for some versions of the PostgreSQL jdbc3 drivers supported in previous releases. We recommend that you use 3.26.1.
The Java agent now starts up to 50% faster. Your applications will be available that much sooner.
falsecould inadvertently disable Netty instrumentation.
Fixed in 3.29.0
Applications that use Play and Ning AsyncHttpClient may miss transactions.
The thread profiler may not report data while profiling certain Scala classes.
Fixed in 3.28.0
NullPointerExceptioninto customer code.
Fixed in 3.27.0
Fixed an issue where the agent treated HTTP headers as being case sensitive, causing CAT to miss under certain conditions.
Fixed various issues related to the proper handling of multibyte character encoding.
Fixed in 3.26.x
CXF instrumentation can name transactions based on auto-generated proxy classes. Later agents now normalizes CXF transaction names.
EJB instrumentation may cause a
NullPointerException in application code, and erroneously set transaction names. In later versions, the agent records a metric.
The Cross Application Tracing API caused Application Response time to be attributed to other transaction time, and prevented linking of transaction traces when doing CAT.
Request queuing calculations could show queuing time as a steadily increasing value instead of the correct time.
HttpURLConnection External metrics may not report on the IBM J9 JVM.
Transaction traces may report external segments for non I/O calls in Apache HttpClient.
The Java agent will now read Cross Application Tracing HTTP header names regardless of case.
Fixed a bug that could cause cross application tracing between the New Relic Java agent and non-Java New Relic agents to fail.
The Java agent now reports synchronous calls to the Mongo Java Driver 2.12 through 3.1. You will see the Mongo operations in breakdowns in the Applications Overview chart, entries in the Databases tab, and segments in transaction traces. Note: The asynchronous driver is not supported.
Akka HTTP and Spray
The Java agent now reports and names transactions received through Akka HTTP 1.0, Akka HTTP 2.0 and Spray. Transactions are named intuitively based on route DSLs. This instrumentation also supports Cross Application Tracing from calling systems. With our previously released support for Akka, your Akka HTTP and Spray applications will now include activity of those transactions all the way through your actor systems.
This release contains support for versions 1.0.2 through 1.4 of the Hystrix framework. You will now see timing information related to each Hystrix Command's run and getFallback methods. Chained Hystrix commands will be linked into one transaction.
This release fixes a bug in New Relic's Cross Application Tracing (CAT) that could cause incorrect service and transaction maps.
The problem would happen when non-identical applications, with identical transaction names, would appear to be communicating (in the Transaction / Service maps), when in fact, they were not.
Note: Using a combination of pre-3.23.0 and 3.23.0+ can result in external calls between the old and new agents to not show up in the map. To fix this, upgrade all of your agents to 3.23.0+ at the same time
Resolved an issue where an application running on Tomcat and containing a large number of static JSPs (5000+) could cause a memory leak within the agent.
Fixed an issue that caused Ning's AsyncHttpClient WebSockets requests to fail, or the application not to start.
Fixed an issue that could cause an extra transaction to be created, a background transaction named NettyDispatcher.
Removed the deprecated bootstrap.classpath configuration, as it could result in the Java agent's instrumentation failing to load.
Play Framework 2.4 Instrumentation, and Play Framework 2 Improvements
Previous Java Agent releases supported the Play Framework up to version 2.3. This release includes instrumentation for Play 2.4.x. This release provides more insight than ever before for all versions of Play 2, including improved segment names, and better signal-to-noise ratio in transaction details.
This instrumentation also takes advantage of the new response time line in the New Relic UI. Because Play is a reactive framework that encourages concurrent activity, your total time for transaction components will often be greater than the response time. If the total time is less than response time, it may indicate resource exhaustion. By separating the total time from the response time, you get a clear picture of when you are getting the benefit of concurrency.
If you have used the Java Agent to monitor Play before this release, you may see a decrease in response time. The new response time metric more accurately reflects the time from initial request to response.
We support Play applications written in Java or Scala 2.9.3 - 2.11.x.
Note: The deprecated
-Dnewrelic.bootstrap_classpath system property can result in missing instrumentation and should not be used.
Netty 3.4 - 4.x Instrumentation
This release updates our Netty support to include versions from 3.4 to 4.x. Previous release supported up to Netty 3.9. The agent will start transactions for server inbound I/O. The agent will instrument Netty HTTP methods to enable cross application tracing (CAT) in Netty transactions.
AsyncHttpClient Instrumentation 1.0.2 - 1.9.x
In this release, you will see the time spent in external service calls made using AsyncHttpClient (also known as Ning Http Client). If the external service is also running New Relic, you will see cross application tracing (CAT) details as well. This includes external calls made from Play WSAPI, which uses AsyncHttpClient.
Note: As in previous releases, Play 1 applications will not report AsyncHttpClient activity.
Akka Instrumentation 2.0 - 2.4
This release enhances our Akka instrumentation by linking an actor message sender to an actor message receiver in the same transaction. In order to avoid over-instrumentation, our Akka instrumentation does not actually start transactions. If you would like a given actor call to mark the beginning of a transaction, you will need to use the
@Trace(dispatcher=true) annotation, or some other form of custom instrumentation.
This release supports core Akka, not all Akka extensions. In particular, it does not identify transactions that have been routed by Spray, Akka HTTP, or Akka Streams. We have heard from customers that these frameworks are important, and we expect to support them soon! Stay tuned to the Java agent incubator, since we may provide an early access instrumentation module for these frameworks before we release them in the agent.
Advanced Analytics for APM Errors
With this release, the agent reports TransactionError events. These new events power the beta feature Advanced Analytics for APM Errors (apply here [external link] to participate). The error events are also available today through New Relic Insights [external link] .
Advanced Analytics for APM Errors lets you see all of your errors, with granular detail. Filter and group by any attribute to analyze them. Take action to resolve issues through collaboration.
The Java Agent now collects the following information for web transactions:
This release contains a bug in New Relic's Cross Application Tracing (CAT) that can cause incorrect service and transaction maps.
The problem happens when non-identical applications, with identical transaction names, would appear to be communicating (in the Transaction / Service maps), when in fact, they were not.
Using a combination of pre-3.23.0 and 3.23.0+ can result in external calls between the old and new agents to not show up in the map. To fix this, upgrade all of your agents to 3.23.0+ at the same time.
The Java Agent now instruments the JCache API. The instrumentation times cache operations of implementations of the JCache API.
To get additional information about your operations in the Databases page, enable com.newrelic.instrumentation.jcache-datastore-1.0.0 in your newrelic.yml. This will incur additional overhead.
class_transformer: com.newrelic.instrumentation.jcache-datastore-1.0.0: enabled: true
Circuit Breaker alerts now better align with data displayed in JVMs tab.
In some cases the Java Agent's HttpURLConnection instrumentation could report incorrect external response time metrics
The Java Agent's MongoDB instrumentation no longer reports errors due to runtime exceptions that are caught and handled by applications.
Fixed an issue where Guice dynamic proxies could be instrumented, potentially causing MGI issues.
In rare cases a deadlock would occur at startup on some WebSphere applications.
Fixed an issue that could cause missing Cross Application Tracing information on WebLogic 12 when using HttpURLConnection.
In some cases JBoss 4.x could fail to start due to a NullPointerException.
In some cases Dropwizard appservers could fail to start due to a ClassCastException during log initialization.
The agent’s Redis instrumentation is now more efficient.
In some cases the HttpClient 3 instrumentation could overstate the external call count.
In rare cases the agent would report errors that it was configured to ignore.
Some line numbers did not display correctly in stack traces.
Updated Jetty instrumentation to support Jetty 9.3.
Added support for Apache Thrift 0.8 and greater. This instrumentation automatically adds timing to Thrift calls and sets transaction names based on Thrift method names. It can be disabled in the newrelic.yml by adding:
com.newrelic.instrumentation.thrift-0.8: enabled: false
The New Relic Resin Instrumentation now reports errors as HttpErrors, allowing them to be ignored.
A new heap utilization metric has been created for alerting purposes. This metric tracks the percentage of heap in use as a number between 0 and 1, where 0 means no heap usage and 1 means a full heap. The new metric is: Memory/Heap/Utilization
Exception messages for allow list
Java exception messages will now be obfuscated when high security mode is enabled. If specific exception messages should be allowed through, they can be added to your allow list with the following configuration property:
strip_exception_messages: whitelist: 'java.lang.NullPointerException,java.lang.IllegalStateException'
The allow list is a comma-delimited string of exception class package + class name. This can be enabled or disabled independently of high security mode with the following property:
strip_exception_messages: enabled: true
Websphere Liberty Profile
The Java agent now provides instrumentation for WebSphere Liberty Profile. This includes web transaction visibility, Cross Application Tracing, and app server stats.
The Java agent now starts more quickly so applications are available sooner. This release also reduces agent overhead at run time.
Customize hostname displayed in APM
A new configuration setting has been added: process_host.display_name. When set in the newrelic.yml configuration file, the display name identifies the host in the APM UI, along with the hostname that the agent automatically captures.
process_host: display_name: hostname
In addition, the display name can be set using the
NEW_RELIC_PROCESS_HOST_DISPLAY_NAME environment variable. This property can be viewed in all Insights transaction events.
WebLogic and WebSphere instance name available
The instance name for WebLogic and WebSphere application servers is now available in transaction traces, traced errors, and Insights transaction events.
Custom instrumentation of transaction attributes is disabled by default
Custom attributes defined using the Instrumentation tab in the UI are now disabled by default. In order to enable these attributes, you must have High Security mode disabled and you must place the following text in the
common: block of your newrelic.yml:
reinstrument: attributes_enabled: true
Spring AOP instrumentation is now disabled by default. It was exercising a bug in certain versions of Java 8 that caused the JVM to crash. To re-enable, include the following in your newrelic.yml:
com.newrelic.instrumentation.spring-aop-2: enabled: true
RabbitMQ metrics could double-report for some versions of RabbitMQ. This was introduced in Java agent version 3.16.1 and is fixed in this version.
Added support for the Jedis client versions 1.4.0 or higher. You can now see your Redis calls in breakdowns in the overview chart, entries in the Databases tab, and segments in transaction traces.
Updated RabbitMQ instrumentation to support RabbitMQ 3.5 and higher.
Cross Application Tracing API
Use the cross application tracing API when the agent does not provide cross application tracing support for your application. See the documentation
Play 2 Framework
Improved instrumentation for Play controller classes.
Starting in this release, the New Relic Java agent detects when memory is nearly exhausted and trips a “circuit breaker” that limits the agent’s memory usage. The agent won’t report transactions while the circuit breaker is tripped, so throughput will be understated. In the rare case that the circuit breaker trips, the New Relic UI will provide more information. For more details, see the documentation.
Added configuration to disable Deadlock Detection
Under very heavy load conditions with many threads, the Deadlock Detector service may slow response time. You can now disable this feature with the following setting:
deadlock_detector: enabled: false
Reduced the memory overhead of the Java agent
Play 2 Framework
The Java Agent now honors the
segment_limit setting for async traces, and can now handle much deeper async traces. This is useful to decrease if you're experiencing slower response time or high memory overhead when executing large async transactions.
Cross-application requests from other New Relic-instrumented applications will reliably appear in the App and Transaction maps.
The proxy_host name is no longer sent to New Relic.
Fixed issue where external transactions were reported twice when using HttpURLConnection. Previously, this caused throughput to appear doubled.
The New Relic Java agent now supports the ability to apply labels to applications, so that you can easily sort, filter, and page through all of the applications on your account's Applications list.
Configuration can be done in the newrelic.yml file:
labels: Server:One;Data Center:Primary
More information on using labels to categorize your applications can be found in the New Relic APM documentation.
Prior to this version, some thread profiles would time out and not display. Thread profiles will now complete reliably.
The Java Agent now works around IBM JVM bug IV25688. The agent will scale back a small amount of its instrumentation on old IBM JVMs to avoid inducing the bug. The workaround should leave most customers unaffected. Loss of instrumentation caused by the workaround can be fixed by upgrading the JVM to the latest service release.
Synthetics transaction tracing
New Relic Synthetics monitors your site from around the world. When you use Synthetics to monitor your Java application, up to 20 detailed transaction traces will now be captured every minute when the application is probed from Synthetics. To learn more about this feature, visit our documentation
EJB Session Beans
The Java agent now monitors Enterprise Java Beans (EJB) 3.0 session beans. The agent instruments @Stateless and @Stateful EJBs, and those that extend java.ejb.SessionBean. The agent traces methods declared by corresponding interfaces annotated with @Remote and @Local.
Unified view for SQL database and NoSQL datastore products.
The response time charts in the application overview page will now include NoSQL datastores, such as Cassandra and MongoDB,and also the product name of existing SQL databases such as MySQL, Postgres, Oracle, etc. For existing SQL databases, in addition to the existing breakdown of SQL statements and operations, the queries are now also associated with the database product being used. For NoSQL datastores, such as Cassandra and MongoDB, we have now added information about operations performed against those products, similar to what is being done for SQL databases.
This new unified Databases page will enable the filtering of metrics and operations by product, and includes a table listing all operations.
Because this introduces a notable change to how SQL database metrics are collected, it is important that you upgrade the agent version on all hosts.If you are unable to transition to the latest agent version on all hosts at the same time, you can still access old and new metric data for SQL databases, but the information will be split across two separate views.
Datastax Cassandra client
Added support for the Datastax Cassandra client versions 2.1.2 or higher. This will include breakdowns in the overview chart, entries in the Databases tab, and segments in transaction traces. Note: uses of the client's async API will not be captured in transaction traces.
Added support for MongoDB client versions 2.12.0 up to but not including 3.0+. This will include breakdowns in the overview chart, entries in the Databases tab, and segments in transaction traces.
API Reported Errors
API reported errors can now be prioritized on a transaction over tracer reported errors. Add the following config to allow prioritizing:
error_collector: ignoreErrorPriority: false
The Java Agent may now capture traces for transactions that resulted in an error (4xx or 5xx response code). Prior to this release, the agent would only capture traces for successful responses.
Updated default newrelic.yml to use transaction_events.max_samples_stored instead of deprecated analytics_events.max_samples_stored property.
JBoss dispatcher reports correctly for clustered environments where jboss.home and jboss.home.dir are not set.
Resolved a bug which caused certain Jetty configurations to stop sending metric data.
Under very light load, the Agent could send incorrect transaction timestamps.
Fixed parsing error in log_file_count setting. Prior to this release, this setting produced one more log file than expected.
Custom Insights events API
In addition to attaching custom attributes to the events that the Java agent generates automatically for each transaction, you can now record custom event types into Insights with the new NewRelic.getAgent().getInsights().recordCustomEvent API.
The agent now captures and reports thread profiles in XRay Sessions for non-web transactions.