Blog

FR7 represents a massive step forward for FusionReactor, includes 20 completely new core features and around 100 major improvements and bug fixes. Our primary goals for this release have been to enhance the array of system, application and JVM metrics available, as well as build upon and extend the core functionality within FR Ultimate Edition.

Our mission is to provide developers, DevOps and I.T. professionals unparalleled depth of insight, transparency and interpretation into what applications are doing at the point where things are going wrong! Why? So, that they can isolate issues and performance problems faster than with any other tool.

FR7 has significantly increased the array of supported metrics available. Ranging from complete JMX MBean metrics, to enhanced framework (ColdFusion and Java) support to NoSQL data stores and current streaming platforms, such as Apache Kafka™.

The other major focus of this release has been to enhance FR Ultimate Edition – which adds a completely new definition to the meaning of application monitoring. FR Ultimate combines the most useful components and features from the most used error detection and performance analysis tools available to developers: the code debugger, application profiler and with the launch of FR7, the memory profiler. These tools can all be used safely, securely and most importantly with MINIMAL OVERHEAD in your production environment.

The complexity of today’s distributed, service based, containerized, ephemeral environments, combined with unprecedented quantities of data means that re-producing production issues is virtually impossible. The error detection features built into FR Ultimate completely change how issues would be investigated, removing the need to try and reproduce defects in a test environment or scouring through log files in the hope of finding a clue. FR Ultimate enables you to interact with issues as they unfold, directly in production. It is the only product on the market which offers such capabilities.

The whole team is extremely proud of FusionReactor 7 and we hope that you enjoy using it and that it continues to be your #1 tool to monitor, detect issues and protect your applications and servers.

David Tattersall

CEO Intergral – makers of FusionReactor

New in FusionReactor 7.0.0, we added the ability to monitor your applications usage of Apache Kafka.

Firstly, what is Apache Kafka. Apache Kafka is a publish-subscribe service that allows for multiple system to publish to a given topic and for multiple system to create from a topic. It is commonly used to build real time data pipelines because it is reliable, fast and scalable. To find out more about Apache Kafka visit there website: https://kafka.apache.org/

There are two major aspects of using Kafka the consumers and producers. In this post we are going to talk about how FusionReactor can monitor consumer applications.

Consumer Transactions

When you start your application with FusionReactor (see Install Guide) we will automatically detect and start tracking calls to the Kafka brokers. These calls are then tracked into transactions and displayed in the Transaction History page.

These transaction track the topic that is being polled and the partition that was polled, as well as the number of records returned and the consumer group used. From these transactions we also graph the activity and execution time into the normal transaction graphs in FusionReactor.

In addition to the standard graphs in FusionReactor if you are using an Enterprise or Ultimate license you will also have access to the ‘Framework Source’ page this page will aggregate the Kafka metrics into a selection of graphs to show how the Kafka usage breaks down by, Broker, Topic and Partition.

Consumer Metrics

When you have a Java application connected to Kafka, there are various metrics available from the driver library. FusionReactor is able to track these metrics and display them over time in a collection of graphs. FusionReactor provides two pages of these graphs Kafka Metrics and Kafka Node Metrics, each page is then displayed based on the selected consumer.

Kafka Metrics

The Kafka Metrics page is intended to give a general overview of the state of the applications use of Kafka, so on this page you will see metrics including:

• Records consumed
• Incoming/Outgoing Bytes
• Commit Rate
• Heartbeat Rate
• And many more..

Kafka Node Metrics

The Kafka Node Metrics include metrics for each consumer that is running in the JVM, split down to each node that is providing the data. These metrics include:

• Incoming/Outgoing Bytes
• Latency
• Request Size
• And many more..

For more information about what these metrics are please visit the Apache Kafka documentation

DZone have just published the 2017 Guide to Java: Development and Evolution and FusionReactor are featured in it. The 2017 Guide to Java explores upcoming features of Java 9, how to make your apps backwards-compatible, a look into whether Microservices are right for you, and using the Futures API in Java.

You can download it for free from the Dzone website.

We are Sponsoring Velocity Conference, San Jose,CA 2017: Build & Maintain Complex Distributed Systems. Come and meet us at our booth #718. We will be showing off the latest FusionReactor developments and features to help Java developers fix problems faster! You can read more about our event attendance here.

If you cannot wait to meet us get started with a free trial of FusionReactor Java application Monitor or visit our webinars page to see FusionReactor in action. With both new webinars to sign up to and prerecorded webinars to watch.

David Tattersall the CEO of Intergral (makers of FusionReactor) talks on the ColdFusion Alive podcast with host Michael Smith. On Why It is Different to other APM tools and what is new in version 7 & the CLOUD

See the full podcast here: http://teratech.com/podcast/fusionreactor-application-performance-monitor-why-its-different-than-other-apm-tools-and-whats-new-in-version-7-the-cloud-with-david-tattersal/

This year we are back at Velocity Conference San Jose – You can visit us at booth #718 we will be showing off the latest FusionReactor developments and features to help developers fix problems faster! To celebrate this we are giving away a free ticket for Velocity Conference, San Jose, California.

The Prize is for one Bronze 2-Day Pass which Includes:
– All sessions (Wed & Thu)
– All keynote and plenary presentations
– Sponsor Pavilion and all events held there
– All on-site networking events
– Lunch (Wed & Thu)

There are Two ways to enter the draw:
1) ON TWITTER : Follow us and retweet this tweet it is that simple! If you are already following us then just retweet this.

OR (You can do both to double your chances of winning).

2) ON FACEBOOK : Just Like us on Facebook – and leave us a comment – “I want to go to Velocity”
We will be announcing the winner on, Friday 9th June, this will give the winner enough time to organise flights and accommodation.

If you do not win, please do not worry you can still save 25% on the entry price by using our Discount Code: FusionReactor25

The situation is a common one when you’re a Java developer: you know there’s an application issue; you know it’s degrading performance and negatively impacting your customers; but you’re having trouble finding the root cause and you’re using valuable time that should be focused on the next deliverable. Today’s distributed application environments and architectures are more complex than ever and this only adds to the difficulty when trying to pinpoint software problems. In the recently published DZONE Guide to Performance & Monitoring, it was found that the most time consuming part of fixing performance issues is finding the root cause followed closely by being able to reproduce the performance issue.

The first tool most developers reach for when investigating problems are the application and database logs. Logs are an invaluable resource when looking for the key to an issue but searching through them takes time. They also might not give the developer a clear picture of what is causing the software to run slowly or throw exceptions. Many developers do not have access to production environments and often these logs are their only view into how the application is running.  However, the logs may not contain the information they need or the logs may not even be available. Metrics are also useful but in many cases they don’t provide the kind of detailed information a developer can use to narrow in on the most likely cause of application slowness. It also takes time to collect and inspect all the data that might provide clues as to what is going on within the application. Is it a poorly written SQL query? A memory leak? A null pointer exception? It could be one or more of these issues and it may take hours or days to fully understand what is causing the problem.

Tweaking and adjusting the code for applications to make them run as efficiently as possible is important, but what do you do when something breaks without warning? Defects in code can be harder to locate than a performance issue because they occur much more infrequently and can be difficult to reproduce. Logs may show that an error occurred but if you don’t know exactly what the application was doing at that specific time under those specific conditions you may not be able to figure out what happened.

At this point you may be nodding your head because you’ve dealt with similar situations and have used the same procedures to address performance issues or come up with an emergency break-fix solution to get your application back up and running. Traditional application performance management (APM) tools provide some information and can be set to alert when something is wrong but they don’t give you the whole picture. This is where FusionReactor comes in with a whole new way to monitor your code and how it functions as it’s running in production. Instead of grepping through your logs, diving into the heap, tallying object instances, running stack traces over and over, guessing at some breakpoints, or including debug data into your code after an issue has arisen, FusionReactor allows you to interact and debug your production application as it is running. FusionReactor was designed to give developers the information they need along with powerful production-safe tools like the Production Debugger and the low-impact Profiler. This means that instead of spending time collecting data and attempting to reproduce the problem, you can look at your code as it executes to see where the problem starts and learn exactly what is causing the issue so that you can start to work on a solution as fast as possible.

Developers have long been taught that debugging code while it’s running in production is a bad idea for many reasons including high overhead, having to spend time watching and waiting on the debugger while it runs, and the potential for a breakpoint to halt the entire application.

The FusionReactor uses JVMTI to bind directly into the built in debugger in the JVM, thus requiring no protocol overhead. The debug features are only enabled when the user wants to run them. The normal impact of having FusionReactor’s Debugger installed is zero (unless you use java 1.6.0._21 or earlier due to a bug in Java) apart from the memory used to load the library into memory.

Typically, you would set a breakpoint then step through your code and wait for a breakpoint to fire. The point being, you need to actually attend to the debugger as it’s running, which is very time consuming.  FusionReactor does away with this need, by sending out an email as soon as the breakpoint is hit. The email response can be configured one of two ways. In the first case, the breakpoint will fire, the stack trace and variable information is captured, and an email is sent to the developer. This is a non-invasive approach that allows the developer time to look at the data without any impact to the code running in production. In the second case, the breakpoint fires, stack trace and variable information is captured, and an email is sent however the thread where the breakpoint fired remains open for either a defined period of time or indefinitely, depending on how it has been configured. The developer can click on a link in the email which brings up the debugger at the point in the application where the breakpoint fired.  So when some problem occurs at 3:00 am, FusionReactor will capture the state, capture the thread and essentially freeze it, until you come into the office and start debugging it.

FusionReactor Debugger was designed with enhanced control mechanisms in mind to allow for safe production debugging:

• Set how many times a breakpoint fires so that only those threads are affected.
• Set a limit on the number of threads that can be paused in the debugger at any one time or how many threads a single breakpoint can pause.
• Set a parameter on how long a thread can be paused. Once the time limit has been reached the thread will be released to allow the end user to continue.
• Have a breakpoint send an email with the stack and variable information while it holds the thread for the predetermined time period.

It goes without saying that any production debugging should be done with caution so as not to affect other threads or the overall application, however FusionReactor’s Debugger allows you to target only what is needed to quickly investigate the issue.

The low-impact Java Profiler offers the ability to watch your code as it executes, enabling you to pinpoint bottlenecks in production. You can profile any request or transaction running on the JVM such as Tomcat, Glassfish, or Jboss. The Profiler can be run manually or configured to start when a particular condition has been set. This is a huge advantage in that you can leave the Profiler ‘on’ and set it to activate automatically when a request takes longer than expected instead of having to watch and wait for the event to happen. You can also limit the number of profile samples to control the accuracy of the sample. This information is then stored so that later you can drill down into the details to see how your code is running. The Profiler shows how much time is spent in each section of code as well as the overall percentage of it that makes up the transaction or request.

Performance tuning and troubleshooting will always be a part of development but hours or days of time spent searching through log files, running stack traces over and over, and trying to reproduce a production issue can be a thing of the past with FusionReactor. Being able to quickly solve issues results in less downtime, more stability, faster applications, happier customers, and less stressed developers!

To get start with a FREE trial of FusionReactor go here to Download FusionReactor and Start your trial.

We are thrilled to announce that FusionReactor has been accredited with the “FeeFo Gold Trusted Merchant” 2017 award!

Feefo is an independent feedback service that are dedicated to collecting trusted reviews. The Gold Trusted Merchant award is only given to businesses that have an average positive Service Rating of between 95% and 100%.

The whole FusionReactor team would like to thank everyone who filled out feedback for us – we really appreciate it!

The award shows that FusionReactor is a leading tool for Java Application Performance monitoring – designed to help Developers and Devops improve their applications and get to the root of the problem as fast as possible.

Using the Feefo feedback service has been a fantastic way for us to see how FusionReactor is being utilized by our customers. As well as highlighting any issues they may be facing. We always aim to provide the best possible service for our customers.

You can read more about our Customer reviews here: https://www.fusion-reactor.com/customer-reviews/
And see some interviews with our customers: https://www.fusion-reactor.com/customers/

“The Trusted Service award is a recognized symbol of trust – helping customers click with confidence.”. From everyone on the FusionReactor team thank you and have a great year!

Intergral GmbH Makers of FusionReactor Java Application Monitor Wins Feefo Review Feedback Reward

Read more about this in our latest press release here

Our “typical” FusionReactor customer is generally a techie, usually a software programmer who is either developing on, or is responsible for an application.  About 25% of the time, our customers come from IT management, operations or DevOps positions.    What we hear time and time again, is how useful FusionReactor is at pinpointing issues, whether it be performance bottlenecks, memory problems or some weird almost impossible to find issue which is causing their application to crash, seemingly at random – yes, FusionReactor can find those issues too.   Customers praise the product for its ability to provide “real-time” insight into what’s happening, as it’s happening.     Perfect.  This is exactly what we wanted and was always the original intention of the product.    When we very first built FusionReactor, we wanted a tool to help us discover what was really going on inside our production application, inside the ColdFusion black box, so that we could get to the root of the problem and fix it.   In fact, the slogan for FusionReactor – “Find it, Fix it, Prevent it” is a relevant today, as it was in 2005 when FusionReactor was first released.

As you may be aware, with the release of FusionReactor 6 we introduced a new Edition – Ultimate, which featured the Production Debugger, Production Profiler and will soon include a production safe Memory Analyzer.   These tools are ‘not’ typically associated with a monitoring solution – in fact, I don’t believe there is any other monitoring tool on the market which boasts a debugger as part of its feature set.    So why did we decide to ‘include’ these capabilities as part of our monitoring solution?   Well, when something breaks in production, we believe that developers need real-time insight and transparency into what the application is actually doing at the point that it’s breaking – in production.    FusionReactor caters to this need by means of the Stack Trace, which highlights the method and line of code where the application is currently “stuck”.   This is extremely useful – but it’s not as useful as being able to debug or profile the code.   In order to rapidly pinpoint production issues we believe developers need additional tooling which is actually closer to what they would use in their development/test environments i.e. a debugger, profiler and memory analyzer.   All these tools are integrated into FusionReactor Ultimate.

FusionReactor Ultimate Edition is designed to give the level of detail software engineers need to get to the actual root of the issue and the additional low-overhead production-grade tools will give engineers access to detailed information they need to “deep-dive” & quickly figure out the hard stuff developers need to fix.

With the introduction of FusionReactor Developer Edition, we’re providing a tool which can be used in development and test environments (*) to help you to pinpoint issues and performance bottlenecks before applications are deployed to production.    The Developer Edition is available as an annual subscription license, which means that you’re entitles to all updates and upgrades of the product.   Click here to read more or here to purchase.

(*) FusionReactor Developer Edition enables you to develop, test, evaluate and analyze applications which are running in a non-production environment.  The Developer Edition may not be used to monitor an application which is running in a live or stand-by production environment or staging environment, in each case, including, without limitation, in any environment accessed by application end- users, including, but not limited to, servers, workstations, kiosks, and mobile computers.

This example will show how to set a conditional break point in a ColdFusion loop using the FusionReactor Production Debugger.

Code Example – pdloop.cfm

Setting a conditional breakpoint

In this example, we are going to set a breakpoint when a condition has been met within the aArray variable.   The condition which we would like to set the breakpoint is when:

Setting this in the Edit Breakpoint form, will look like this.

Field	Value	Meaning
Breakpoint Trigger	Source File/Line Number	We are selecting to set a breakpoint within a specific source file and a specific line number
Source Code Filename	pdloop.cfm	Name / location of the file where the code is stored
Source Line Number	3	This is important.    If we are checking the value of a variable, then this variable must have been set before this line number has been reached in order for the breakpoint to fire.
Condition	aArray[i] EQ "March"	This is the example condition which will cause the breakpoint to fire and execution of the page to halt
Fire Count	Always	This indicates that the breakpoint will ALWAYS fire.   If we set the Fire Count to a numeric value, e.g. 3  – then the breakpoint would fire 3 times.
Trigger Handler	Pause Thread	Will tell FusionReactor to pause the currently executing thread when the condition has been met
Pause Time	60	The thread will be paused for 60 seconds.   During this time, the breakpoint can be intercepted by clicking on the Production Debugger icon – or from within the Paused Threads menu item
Pause Execution	On every thread that fires the breakpoint	Will cause the engine to halt for every single thread in which the breakpoint condition fires.

When the breakpoint has been setup, you will see the following when you click on the Breakpoints menu item – If the page has not yet been executed – then we will see the State as being Pending

Seeing when a breakpoint fires

When the page pdloop.cfm is executed, the condition will fire and the page will halt execution.

In the Breakpoints menu, the breakpoint will be shown as follows – NOTE – the State now shows the ClassLoader information, as the page has actually been loaded and executed.

When the breakpoint fires, then the Debugger icon will appear in the top banner –

You can either click on the Debugger icon or click the Paused Threads link in the Debug Menu, you will then see the Paused Thread – together with the Timeout Countdown

To start the Production Debugger session, you need to click on the Debug Icon –

Working with the a debugger in the Thread View Page

The Thread View page shows the details of a specific thread once the thread has been paused in the interactive debugger.

Source Code Viewer

The source code viewer will show the source code for the location where the interactive debugger is currently paused – line 3 in our example.

The variables viewer shows the variables currently available on the thread at the specific location that the interactive debugger has paused.

As we have set the breakpoint to fire when aArray[i] EQ "March" – we would expect

We can also see the Variable values in the aArray variable

Modifying a variable value

We can now modify the value of a variable.   In this example, let us change the value of May to May in the Spring

You should now see the following when you expand

Once you have changed the variable value, hit the Resume icon to continue execution of the program.

The page results will then look like.