FusionReactor Blog - News and expert analysis for Java APM users.

Mandatory Tool for ColdFusion

“Mandatory Tool for ColdFusion”

What do you like best?

The metrics that FusionReactor provides are by far the most used feature. The ability to drill down and find out specific memory or database issues is invaluable.

What do you dislike?

Could use some additional visualizations.

Recommendations to others considering the product:

Test it out and check out all of the features. You’ll be sold.

What problems are you solving with the product? What benefits have you realized?

Solving database query issues, either hanging or taking too many resources. We’ve been able to focus in on problem queries or processes and get them fixed.

Start your free trial on up to 3 servers

See this review on G2

Has the technology to monitor performance level at a high level working to debug issues working against software

What do you like best?

Has the technology to monitor performance level at a high level working to debug issues working against software.

What do you dislike?

Software shows some grey areas in reference to processing time for performance to complete its initial check.

Recommendations to others considering the product:

N/A

What problems are you solving with the product? What benefits have you realized?

Clearing out software’s on computers or company software. Allow analysis to be done efficiently.

Read full review on G2

Start free trial

Reliable developer focused Java application performance monitor

What do you like best?

It has been able to help me analyse,diagnose and keep my servers alive.

What do you dislike?

Nothing, I dislike nothing about it and it has been a great experience.

Recommendations to others considering the product:

I recommend this to any company or organization that want to improve on their data base performance and monitoring.

What problems are you solving with the product? What benefits have you realized?

It has been able to help me monitor Java application server. It has also boost my application performance.

Read full review on G2

Start free trial

Maven Surefire Stack Trace Problem

For some months we have been having problems with maven-surefire-plugin showing very strange exception stack traces.

After some searching, I found out that maven-surefire-plugin has a trimStackTrace configuration option which is set to true by default. See http://maven.apache.org/surefire/maven-surefire-plugin/test-mojo.html#trimStackTrace

I have no idea who thought that removing part of the stack trace would be a good idea, but it’s caused us no end of problems. Especially with rare/random test failures as we don’t get the full stack trace to see what really failed.

To change this ‘feature’ you simply define surefire configuration in your pom.xml. E.g.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>${maven-surefire-plugin.version}</version>
    <configuration>
        <trimStackTrace>false</trimStackTrace>
    </configuration>
</plugin>

You should also be aware that maven-failsafe-plugin has the exact same option. The trimStackTrace is also set to true by default. See https://maven.apache.org/surefire/maven-failsafe-plugin/integration-test-mojo.html

You can disable this by adding the same configuration to the failsafe plugin. E.g.

<configuration>
    <trimStackTrace>false</trimStackTrace>
</configuration>

Asynchronous Transactions

FusionReactor is able to track asynchronous requests made with several different libraries, examples of which include:

  • Redisson
  • MongoDB
  • Kafka Java Clients
  • OkHttp
  • Apache HttpClient

How FusionReactor Displays this Information

The response to the asynchronous request is tracked with ‘Callback’ as the subflavour. This is attached as a linked transaction (indicated by the small linked chain icon) and can be viewed by clicking the drop down arrow on the request transaction. The callback transaction is also posted to the history list as a Root Transaction.

Some important things to note with asynchronous transactions:

  • The callback may be attached to the request after the request has already finished
  • The callback is usually tracked on a different thread than the request
  • The actual time taken to perform the request is tracked on the response
An example of asynchronous transactions in FusionReactor. This is a Redis GET command using the Redisson Java Client, triggered by a WebRequest to a JSP file.

FusionReactor: Use it every day to solve knotty problems or help guide tuning efforts

“Use it every day to solve knotty problems or help guide tuning efforts”

What do you like best?

Helps find issues quickly, easily, and safely; supporting complex or simple setups equally well. While its largest user base may be ColdFusion, it can be used to monitor any java application or application server, which I have done many times. And new features are added every few months making it ever-more capable. Finally, the company behind the product has shown rock-solid support for any issues I’ve seen brought to them for over 15 years

What do you dislike?

Some might quibble with the (low) cost, compared to free options, but it does so much more than those–and indeed more than many costing far more.

Recommendations to others considering the product:

Certainly give the free trial a go. It was just updated recently to allow up to 3 servers, so you can see how easily it installs, how readily it helps you see what’s really going on, and even across monitoring of multiple servers (including dynamic containers like Docker).

What problems are you solving with the product? What benefits have you realized?

Finding reasons for crashes, being warned of crashes; finding what’s going on now, or went on in the past; finding reasons for slow request, slow queries; finding all this and more for a single server or across a cluster of them

Start your free trial on up to 3 servers

See this review on G2

Great Java performance monitoring tool

Automated Root Cause Analysis. Provide deep level insight (source code, scope variables, stack traces) whenever a problem, such as an exception or thread latency occurs. Snapshots are triggered automatically.

What do you dislike?

I do not like the Enterprise Dashboard, for monitoring multiple servers in a single window

Recommendations to others considering the product:

Great monitoring tool

What problems are you solving with the product? What benefits have you realized?

The agent enables FusionReactor to instrument any information which is available within the Java container, including CPU, memory, thread information (stack traces) and JD

Read full review on G2

Stat free Fusionreactor trial

FusionReactor Is Perfect for CFML Troubleshooting

FusionReactor Is Perfect for CFML Troubleshooting

“FusionReactor Is Perfect for CFML Troubleshooting”

What do you like best?

Being able to troubleshoot long-running web requests and SQL queries. Having access to the actual SQL that was generated is extremely helpful in diagnosing problems. Finally, enabling code test coverage is a fantastic edition for developers!

What do you dislike?

It’s a little pricey, but for most organizations where performance matters, it is well worth it.

Recommendations to others considering the product:

If you’re having issues with slow CFML requests, I definitely recommend giving FusionReactor a try. The interface is intuitive and the support staff is very responsive and willing to help train you how to use the software to optimize your web applications.

What problems are you solving with the product? What benefits have you realized?

As a developer, I am able to quickly view requests that take too long to run so I can decide whether I need to either optimize my CFML code or make adjustments to the database server (adding indexes, etc). For my clients, I can quickly see the JVM health of their production servers and diagnose any possible memory leaks or performance bottlenecks.

Start your free FusionReactor trial

See full review on G2

Amazing account manager service

What do you like best?

Andy McAuliffe answered my original query and persevered with a really positive outcome for the company. He regularly followed up with me to ask how things were going and to check if we had any issues.

What do you dislike?

I am not in the technical team so cannot answer this fully but from what i understand this was easy to set up

What problems are you solving with the product? What benefits have you realized?

I am not in the technical team so cannot answer this fully but from what i understand this was easy to set up

See full review on G2

Start free FusionReactor trial

Microservice support in FusionReactor 8.2.0

In FusionReactor 8.2.0 we have added support for the Java application Frameworks okHTML, Spring Boot and Micronaut.  This brings the list of supported Java application frameworks to; Spring framework, Spring Boot, okHTML, Micronaut, Struts 2, Play, Vaadin, JSF, Vertx, Grizzly and Jersey.

In this blog, we look at why Microservices are beneficial to organizations, things to consider when using microservices and how different Microservices are tracked in FusionReactor.

Why tracking Microservices is important?

Software architecture using Microservices divides a system into a number of smaller and simpler services. These services are independent of each other and typically communicate with each other through REST calls. These independent services can use different languages, Frameworks and environments making the infrastructure very flexible.

Using Microservices breaks down the monolithic applications you currently run into more maintainable apps. While initially converting applications to Microservices can be time-consuming the long term benefits are definitely worth it in most cases.

There are many benefits to using a Microservice-based architecture, with the 5 biggest benefits being

Building and maintaining your environment is quicker and easier

 As the code of a service is smaller and less complex, creating the base functionality required for the application a very simple process. Often a template can be created and reused so bootstrapping a new service takes minutes.

You are not limited to a specific language or Framework and do not have to worry about the libraries or databases used in this service being incompatible with libraries or databases of a separate service.

Structured around the needs of an organisation, not a speciality in a particular language

With Monolithic projects, it is common that one team will own and manage the development of an entire project. Any work required for this product must be done by a single team, which can quickly cause delays in features being available.

Microservices, on the other hand, can be developed by an engineer of any team. If additional functionality is required, rather than adding to an additional project they simply create a new service to supply the functionality they require.

Improved reliability and speed of bug resolution 

The large and more complex the applications are, the harder it is to track down issues. Having smaller and simpler apps means that writing automated and manual testing is more simple; often most unit tests can be autogenerated to some extent from your IDE.

Finding any issues is a quick process as there are hopefully no large functions that try to do too much in a single function.

Infinitely scalable

There is nothing worse than being limited to how and if you can scale your application. With a large application where you may have complex dependencies and threading models, scaling will be difficult to configure and sometimes impossible.

If all you have is a series of small apps that communicate with each other to access information, there are no dependency concerns. If the way you are currently scaling is no longer the best solution switching to a new approach has very little risk

It’s perfect for SCRUM

Scrum promotes Cross-functional small teams where any member of the team can do every required task. It does not matter if these teams are in the same location or other sides of the world.

When every developer is working on the same application and often the same module of the application it can get messy, but if everything is independent of the components around it you can be truly cross-functional and not get in each other’s way.

Considerations when using Microservices

When using microservices you can gain a lot, but there are certain things you should keep in mind when implementing Microservices in your infrastructure.

Documentation is vital

When you have hundreds of potential APIs that are running, knowing the available routes for each API and the restrictions in place for that route is something that must be documented.

When creating routes, naming conventions and versioning of APIs must be carefully thought out to keep the service simple and understandable. A route should have one task only and if a change is needed a new version should be created.

Automation is key

Automated testing and deploys will make or break a Microservice-based architecture. 

If new services are being created regularly and being worked on constantly, having unit tests capable the individual functions and integration tests to ensure the connectivity into the API is critical to ensuring the stability of your application.

Keeping your services on the most up to date version of the code as you scale up your environment can quickly become a challenge. At this point, having a staging environment and auto deployments to keep your services up to date becomes a priority.

Transparency is a must

Finding issues within microservices is a challenge, with the code being split into so many smaller components.

If a user reports an issue in your application, knowing exactly which service has an issue is not simple. In order to find these issues, you need to be able to see the traffic running on your server and any the reason for any errors that are occurring. 

You could use logs for this, but the best way to track your Microservice deployment is with an Application Performance Monitor (APM). An APM will give you metrics on the server traffic and tools to help you track down the root cause of errors.

Tracked framework examples

Spring Boot

Spring boot is the most commonly used framework in Java, it makes developing applications from web apps, to complex APIs very simple with it’s structured MVC layout. It’s JDBC extraction makes integrating with SQL and NoSQL DBs simple and it’s simple testability add ons that make automated testing quick and simple.

In FusionReactor Spring boot your request will be deconstructed into it their individual controller and hibernate calls.

In our example, we see a call to add an item to a shopping cart. We can see the addToCart method being called within the CartController and the individual JDBC calls made during the execution, as well as the final redirect call.

In the details of our request, we get a breakdown of each action in the execution of our request.

For requests with errors the full stack and an EventSnapshot is captured to get you to the root of your issue quickly

Micronaut

First Introduced in May 2018, Micronaut is a fairly new framework to be introduced to Java. It allows users to build scalable and performant applications in Java, Kotlin or Groovy. With its reactive HTTP server and client capabilities, efficient compile-time injection and well thought out features for microservice development. It is perfect for applications where heavier MVC frameworks are not an option.

With Mirconaut, the request and response are tracked as two different transactions. When the response transaction is complete the response object will be linked to the request object. For each transaction, you see the status code, protocol and request URL.

In each transaction, you see Headers and Cookies. Unfortunately, JSON tracking is not currently available for Micronaut, this is something we are working on but as of yet have not been able to implement.

OkHTTP

okHTTP is a popular alternative to the Apache HTTP Client for making HTTP / HTTPS calls from within your Java application. It is efficient with HTTP and HTTP2 clients, with advanced connection pooling and the ability to recover from common connection problems.

okHTTP request, you will see that each HTTP call is tracked as its own transaction. The transaction has a parent of the Web Request that contained the okHTTP call.

In the request we track any JSON data send and received in the response, as well as the headers and cookies of the request.