FusionReactor Java Performance Monitor: Blog

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.

INTERGRAL SOFTWARE END USER LICENSE AGREEMENT (“EULA”)

THE FOLLOWING EULA APPLIES TO FUSIONREACTOR VERSION 7 AND ITS MINOR/MICRO UPDATES ONLY

IMPORTANT: CAREFULLY READ THE FOLLOWING LICENSE AGREEMENT. THIS
END USER LICENSE AGREEMENT (“EULA”) IS A LEGAL AGREEMENT BETWEEN
YOU (EITHER AN INDIVIDUAL OR, IF PURCHASED OR OTHERWISE ACQUIRED
BY OR FOR AN ENTITY, AN ENTITY) AND INTERGRAL. YOU ACCEPT AND
AGREE TO BE BOUND BY THE TERMS OF THIS AGREEMENT BY SELECTING THE
“ACCEPT” OPTION OR DOWNLOADING THE SOFTWARE OR BY INSTALLING,
USING, OR COPYING THE SOFTWARE. IF YOU DO NOT AGREE TO BE BOUND
BY THESE TERMS THEN DO NOT INSTALL, COPY, DOWNLOAD OR OTHERWISE
USE THE SOFTWARE. THIS EULA SHALL APPLY ONLY TO THE SOFTWARE
SUPPLIED BY INTERGRAL HEREWITH REGARDLESS OF WHETHER OTHER
SOFTWARE IS REFERRED TO OR DESCRIBED HEREIN.

Definitions

“INTERGRAL” means INTERGRAL Information Solutions GmbH and its
licensors, if any.

“Developer Version” means a version or edition of the Software to
be used only for design, development and evaluation purposes.

“Free Version” means a version or edition of the Software that
may have limited features, and may stop operating after a given
amount of time.

“Trial Version” means a version or edition of the Software to be
used only for review, demonstration and evaluation purposes. The
Trial Version may have limited features, and may stop operating
after a given amount of time.

“Full Version” means a version or edition of the Software that is
not a Developer Version nor a Trial Version of the Software nor a
Free Version of the Software.

“Accessible Code” means source code that is unprotected and
accessible.

“Protected Code” means any source code that is protected against
access by INTERGRAL or a third party and is not accessible under
this EULA.

“Fees” mean all fees and expenses payable by the Licensee to
INTERGRAL in acquiring the Software and as applicable any
Subscription or User Licenses.

“Software” means only the INTERGRAL software and third party
software programs, in each case, supplied by INTERGRAL together
with this EULA, including its Accessible Code and Protected Code
and any corresponding documentation, online or electronic
documentation, printed materials, and associated media. Any
updates to such Software that you are entitled to receive and
that have been provided to you by INTERGRAL shall also mean
Software for purposes of this Agreement.

License Grant
The Software is subject to the terms and conditions of this
Agreement. INTERGRAL hereby grants, and you accept, the right and
license to install and use the Software provided that you do not
use, copy, or install the Software on more than the number of
computers permitted by license, or permit the use, copying, or
installation by more users on more computers than the number
permitted by the license.

You may make one copy of the Software in machine-readable form
solely for backup purposes. You must reproduce on any such copy
all copyright notices and any other proprietary legends on the
original copy of the Software.

The Software is protected by copyright laws and international
copyright treaties, as well as other intellectual property laws
and treaties. INTERGRAL reserves all intellectual property
rights, including copyrights and trademark rights. Your license
rights under this EULA are non-exclusive.

License Restrictions

Restrictions on Use
Other than as expressly set forth above, you may not make or
distribute copies of the Software, or electronically transfer the
Software from one computer to another or over a network.

You may not decompile, “reverse-engineer”, disassemble, or
otherwise attempt to derive the source code for the Software.

You may not use the database portion of the Software in
connection with any software other than the Software.

You shall not (A) in the aggregate, install or use more than one
copy of the Trial Version of the Software, (B) download the Trial
Version of the Software under more than one username, (C) alter
the contents of a hard drive or computer system to enable the use
of the Trial Version of the Software for an aggregate period in
excess of the trial period for one license to such Trial Version,
(D) disclose the results of software performance benchmarks
obtained using the Trial Version to any third party without
INTERGRAL’s prior written consent, (E) use the Trial Version for
any application deployment or ultimate production purpose, or (F)
use the Trial Version of the Software for a purpose other than
the sole purpose of determining whether to purchase a license to
a Full Version or a Developer Version of the software; provided,
however, notwithstanding the foregoing, you are strictly
prohibited from installing or using the Trial Version of the
Software for any commercial training purpose.

You shall not use the Developer Version for any application
deployment 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.

You shall not use the Software to develop any application having
the same primary function as the Software.

Subject to the terms and conditions of this Agreement you must at
all times ensure that the Software is not used for rental,
timesharing, subscription service, hosting, outsourcing, or as
part of a service or consulting practice to a third-party,
without first obtaining the express written consent of INTERGRAL.

Restrictions on Alteration
You may not alter, merge, adapt, translate or modify the Software
or create any derivative work of the Software or its accompanying
documentation. Derivative works include but are not limited to
translations. You may not alter any files or libraries in any
portion of the Software. You may not reproduce the database
portion or create any tables or reports relating to the database
portion.

Restrictions on Copying
You may not copy any part of the Software except to the extent
that licensed use inherently demands the creation of a temporary
copy stored in computer memory and not permanently affixed on
storage medium. You may make one archival copy which must be
stored on a medium other than a computer hard drive.

Restrictions on Transfer
Without first obtaining the express written consent of INTERGRAL,
you may not assign your rights and obligations under this
Agreement, or redistribute, encumber, sell, rent, lease,
sublicense, or otherwise transfer your rights to the Software.
You may not sell or transfer any Software purchased under a
volume discount. You may not sell or transfer any Trial Version
or Free Version of the Software.

Permitted Fixes
Notwithstanding anything else in this EULA but subject to the
terms and conditions contained herein, the Licensee is permitted
to modify the Accessible Code in the Software to develop bug
fixes, customizations or additional features solely for their
internal purposes of using the Software.

Upgrades
If this copy of the Software is an upgrade from an earlier
version of the Software, it is provided to you on a license
exchange basis. You agree by your installation and use of this
copy of the Software to voluntarily terminate your EULA with
respect to such prior license to the Software and that you will
not continue to install or use such prior license of the Software
or transfer it to another person or entity.

Ownership
The foregoing grants of rights give you limited license to use
the Software. Except as expressly provided in this Agreement,
INTERGRAL remain the owner of all right, title and interest in
the Software. All rights not specifically granted in this EULA
are reserved by INTERGRAL.

Fees
The Licensee must pay all Fees by their due date. Failure to pay
Fees by the due date will result in the immediate termination of
the licenses granted under this EULA.

You are responsible for reviewing the Software’s website for
changes in the fees, including, but not limited to, subscription
fees and payment terms.

TERMINATION
Without prejudice to any other rights and in addition to any
other termination rights in this EULA, INTERGRAL may terminate
this EULA if the Licensee fails to comply with the terms and
conditions of this EULA. Immediately upon termination of a
license granted under this EULA, the Licensee must at its own
cost remove all copies of the Software including all Accessible
Code from its computer systems and provide INTERGRAL with written
certification that it has destroyed all copies of the Software
including all Accessible Code in its possession, custody or
control.

LIMITED WARRANTY AND DISCLAIMER
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW IN THE
JURISDICTION IN WHICH THE SOFTWARE IS PROVIDED, INTERGRAL
PROVIDES THE SOFTWARE AS IS AND WITH ALL FAULTS, AND EXCEPT
OTHERWISE EXPRESSLY CONTAINED IN THE EULA, HEREBY DISCLAIM ALL
OTHER WARRANTIES AND CONDITIONS, WHETHER EXPRESS, IMPLIED OR
STATUTORY.

INTERGRAL MAKES NO WARRANTY THAT THE SOFTWARE WILL MEET YOUR
REQUIREMENTS OR OPERATE UNDER YOUR SPECIFIC CONDITIONS OF USE.
INTERGRAL MAKES NO WARRANTY THAT OPERATION OF THE SOFTWARE WILL
BE SECURE, ERROR FREE, OR FREE FROM INTERRUPTION. YOU MUST
DETERMINE WHETHER THE SOFTWARE SUFFICIENTLY MEETS YOUR
REQUIREMENTS FOR SECURITY AND UNINTERRUPTABILITY. YOU BEAR SOLE
RESPONSIBILITY AND ALL LIABILITY FOR ANY LOSS INCURRED DUE TO
FAILURE OF THE SOFTWARE TO MEET YOUR REQUIREMENTS. INTERGRAL WILL
NOT, UNDER ANY CIRCUMSTANCES, BE RESPONSIBLE OR LIABLE FOR THE
LOSS OF DATA ON ANY COMPUTER OR INFORMATION STORAGE DEVICE.
INTERGRAL DISCLAIM ALL OTHER WARRANTIES AND REPRESENTATIONS,
WHETHER EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING THE WARRANTIES
OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. THE
SOFTWARE IS NOT DESIGNED, INTENDED OR LICENSED FOR USE IN
HAZARDOUS ENVIRONMENTS REQUIRING FAIL- SAFE CONTROLS, INCLUDING
WITHOUT LIMITATION, THE DESIGN, CONSTRUCTION, MAINTENANCE OR
OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR
COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, AND LIFE SUPPORT OR
WEAPONS SYSTEMS. INTERGRAL SPECIFICALLY DISCLAIMS ANY EXPRESS OR
IMPLIED WARRANTY OF FITNESS FOR SUCH PURPOSES.

INTERGRAL PROVIDES NO REMEDIES OR WARRANTIES, WHETHER EXPRESS OR
IMPLIED, FOR THE TRIAL VERSION AND THE FREE VERSION OF THE
SOFTWARE. THE TRIAL VERSION AND THE FREE VERSION OF THE SOFTWARE
ARE PROVIDED “AS IS” AND WITH ALL FAULTS AND HEREBY DISCLAIM ALL
OTHER WARRANTIES AND CONDITIONS, WHETHER EXPRESS, IMPLIED OR
STATUTORY.

UNLESS OTHERWISE EXPLICITLY AGREED TO IN WRITING BY INTERGRAL,
INTERGRAL MAKES NO OTHER WARRANTIES, EXPRESS OR IMPLIED, IN FACT
OR IN LAW, INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES
OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OTHER THAN
AS SET FORTH IN THIS AGREEMENT OR IN THE LIMITED WARRANTY
DOCUMENTS PROVIDED WITH THE SOFTWARE.

IF APPLICABLE LAW REQUIRES ANY WARRANTIES WITH RESPECT TO THE
SOFTWARE, ALL SUCH WARRANTIES ARE LIMITED IN DURATION TO THIRTY
(30) DAYS FROM THE DATE OF DELIVERY.

NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY INTERGRAL, ITS
DEALERS, DISTRIBUTORS, AGENTS OR EMPLOYEES SHALL CREATE A
WARRANTY OR IN ANY WAY INCREASE THE SCOPE OF ANY WARRANTY
PROVIDED HEREIN.

LIMITED REMEDY
YOUR REMEDY FOR A BREACH OF THIS AGREEMENT OR OF ANY WARRANTY
INCLUDED IN THIS AGREEMENT IS THE CORRECTION OR REPLACEMENT OF
THE SOFTWARE. SELECTION OF WHETHER TO CORRECT OR REPLACE SHALL BE
SOLELY AT THE DISCRETION OF INTERGRAL. INTERGRAL RESERVES THE
RIGHT TO SUBSTITUTE A FUNCTIONALLY EQUIVALENT COPY OF THE
SOFTWARE AS A REPLACEMENT. IF INTERGRAL IS UNABLE TO PROVIDE A
REPLACEMENT OR SUBSTITUTE SOFTWARE OR CORRECTIONS TO THE
SOFTWARE, YOUR SOLE ALTERNATE REMEDY SHALL BE A REFUND OF THE
PURCHASE PRICE FOR THE SOFTWARE EXCLUSIVE OF ANY COSTS FOR
SHIPPING AND HANDLING.

ANY CLAIM MUST BE MADE WITHIN THE APPLICABLE WARRANTY PERIOD. ALL
WARRANTIES COVER ONLY DEFECTS ARISING UNDER NORMAL USE AND DO NOT
INCLUDE MALFUNCTIONS OR FAILURE RESULTING FROM MISUSE, ABUSE,
NEGLECT, ALTERATION, MISAPPLICATION, PROBLEMS WITH DATA NETWORKS,
PROBLEMS WITH ELECTRICAL POWER, ACTS OF NATURE, UNUSUAL
TEMPERATURES OR HUMIDITY, IMPROPER INSTALLATION, DAMAGE TO MEDIA
OR DAMAGE DETERMINED BY INTERGRAL TO HAVE BEEN CAUSED BY YOU. ALL
LIMITED WARRANTIES ON THE SOFTWARE ARE GRANTED ONLY TO YOU AND
ARE NON- TRANSFERABLE.

YOU AGREE TO INDEMNIFY AND HOLD INTERGRAL HARMLESS FROM ALL
CLAIMS, JUDGMENTS, LIABILITIES, EXPENSES, OR COSTS ARISING FROM
YOUR BREACH OF THIS AGREEMENT AND/OR ACTS OR OMISSIONS. THIS
REMEDY IS THE SOLE AND EXCLUSIVE REMEDY AVAILABLE TO YOU FOR
BREACH OF EXPRESS OR IMPLIED WARRANTIES WITH RESPECT TO THE
SOFTWARE AND RELATED DOCUMENTATION.

LIMITATION OF LIABILITY
UNDER NO CIRCUMSTANCES SHALL INTERGRAL, ITS DIRECTORS, OFFICERS,
EMPLOYEES AND AGENTS BE LIABLE TO YOU OR ANY OTHER PARTY FOR
INDIRECT, CONSEQUENTIAL, SPECIAL, INCIDENTAL, PUNITIVE, OR
EXEMPLARY DAMAGES OF ANY KIND (INCLUDING LOST REVENUES OR PROFITS
OR LOSS OF BUSINESS) RESULTING FROM THIS AGREEMENT, OR FROM THE
FURNISHING, PERFORMANCE, INSTALLATION, OR USE OF THE SOFTWARE,
WHETHER DUE TO A BREACH OF CONTRACT, BREACH OF WARRANTY, OR THE
NEGLIGENCE OF INTERGRAL OR ANY OTHER PARTY, EVEN IF INTERGRAL IS
ADVISED BEFOREHAND OF THE POSSIBILITY OF SUCH DAMAGES. TO THE
EXTENT THAT THE APPLICABLE JURISDICTION LIMITS INTERGRAL’S
ABILITY TO DISCLAIM ANY IMPLIED WARRANTIES, THIS DISCLAIMER SHALL
BE EFFECTIVE TO THE MAXIMUM EXTENT PERMITTED. INTERGRAL’S
LIABILITY UNDER THIS AGREEMENT WILL NOT, IN ANY EVENT, EXCEED THE
LICENSE FEES YOU PAID FOR THE SOFTWARE, IF ANY.

Indemnification
To the maximum extent permitted by law, you agree to defend,
indemnify and hold harmless INTERGRAL, its directors, officers,
employees and agents from and against any and all claims,
actions, suits or proceedings, as well as any and all losses,
liabilities, damages, costs and expenses (including reasonable
attorneys fees) arising out of or accruing from (a) your use of
the Software, (b) any application you develop on the Software
that infringes any copyright, trademark, trade secret, trade
dress, patent or other intellectual property right of any person
or defames any person or violates their rights of publicity or
privacy, and (c) any non- compliance by you with this License
Agreement.

Confidentiality
The Software contains trade secrets and proprietary know-how that
belong to INTERGRAL and it is being made available to you in
strict confidence. ANY USE OR DISCLOSURE OF THE SOFTWARE, OR OF
ITS ALGORITHMS, PROTOCOLS OR INTERFACES, OTHER THAN IN STRICT
ACCORDANCE WITH THIS LICENSE AGREEMENT, MAY BE ACTIONABLE AS A
VIOLATION OF OUR TRADE SECRET RIGHTS.

Publicity Rights
Licensee grants INTERGRAL the right to include Licensee as a
customer in Software promotional material. Licensee can deny
INTERGRAL this right at any time by submitting a written request
via email to SALES@INTERGRAL.COM, requesting to be excluded from
Software promotional material. Requests made after purchasing may
take thirty (30) calendar days to process.

Use of Decompiler
The Software includes decompiling functionality (“Decompiler”)
that enables reproducing source code from the original binary
code. You hereby acknowledge that the binary code and source code
may be protected by copyright, trademark and other laws
which may prohibit you from decompiling them and/or using
Decompiler. Before using Decompiler, you should make sure that
the decompilation is not prohibited by any applicable license
agreement of the application and/or original binary code
(except to the extent that you may be expressly permitted
under applicable law) or that you have obtained permission to
decompile the code from the copyright owner. Using Decompiler is
entirely optional. INTERGRAL does neither encourage nor condone
the use of the Decompiler and disclaims any liability for your
use of Decompiler in violation of applicable laws.

Use of Debugger
The Software includes debugging functionality (“Debugger”)
that enables debugging programs that may contain binary code,
source code and intellectual property protected by copyright,
trademark, patent and other laws which may prohibit you
from debugging them and/or using Debugger. Before using Debugger,
you should make sure that debugging is not prohibited by any
applicable license agreement of the program and/or original
binary code (except to the extent that you may be expressly
permitted under applicable law), or by other protecting laws,
or that you have obtained permission to debug the program from all
legal protection owner(s). Using Debugger is entirely optional.
INTERGRAL does neither encourage nor condone the use of the
Debugger and disclaims any liability for your use of Debugger
in violation of applicable laws.

FusionReactor Cloud Service
Use of the FusionReactor Cloud Service is governed by the terms
and conditions that accompanies or is included with the
FusionReactor Cloud Service. By accepting this EULA, you are also
accepting the additional terms and conditions when using the
Software with the FusionReactor Cloud Service.

Third Party Software
Any software provided along with the Software that is associated
with a separate license agreement is licensed to you under the
terms of that license agreement. This license does not apply to
those portions of the Software. Copies of these third party
licenses are included in all copies of the Software. By accepting
this EULA, you are also accepting the additional terms.

RESTRICTIONS
United States: If the Software is acquired by the Licensee in the
United States, the Licensee acknowledges: (a) the Software is
subject to U.S. export jurisdiction and agrees to comply with all
applicable international and national laws that apply to the
Software, including the U.S. Export Administration Regulations,
as well as end-user, end- use, and destination restrictions
issued by U.S. and other governments and notwithstanding the
above; and (b) the provisions of the USA Uniform Computer
Information Transaction Act do not apply to this EULA.

General: The export of the Software from the country of original
purchase may be subject to control or restriction by applicable
local law. Licensee is solely responsible for determining the
existence and application of any such law to any proposed export
and for obtaining any needed authorization. Licensee agrees not
to export the Software from any country in violation of
applicable legal restrictions on such export.

Governing Law, Jurisdiction and Costs
This EULA is governed by the laws of Baden-Wuerttemberg, Germany
without regard to Baden-Wuerttemberg’s conflict or choice of law
provisions. Exclusive jurisdiction and place of performance is
Boeblingen, Germany, as long as permitted by applicable law. The
United Nations Convention for the International Sale of Goods
shall not apply.

Changes to the License Agreement
INTERGRAL may make changes to the License Agreement as it
distributes new versions of the Software. When these changes are
made, INTERGRAL will make a new version of the License Agreement
available on the website where the Software is made available.

Entire Agreement and Severability
This EULA is the entire agreement between INTERGRAL and you, and
supersedes all prior or contemporaneous agreements or
understandings, whether oral or written any other communications
or advertising with respect to the Software; this EULA may be
modified only by written agreement signed by authorized
representatives of both you and INTERGRAL. No INTERGRAL dealer or
agent is authorized to make any amendment to this EULA.

If any provision of this EULA shall be held to be invalid or
unenforceable, the remainder of this EULA shall remain in full
force and effect and an enforceable term will be substituted
reflecting our intent as closely as possible. All rights not
expressly granted in this agreement are retained by INTERGRAL.
To the extent any express or implied restrictions are not
permitted by applicable laws, these express or implied
restrictions shall remain in force and effect to the maximum
extent permitted by such applicable laws. The failure or delay of
INTERGRAL to exercise any of its rights under this EULA or upon
any breach of this EULA shall not be deemed a waiver of those
rights or of the breach. You agree that any varying or additional
terms contained in any purchase order or other written notification
or document issued by you in relation to the Software licensed
hereunder shall be of no effect.

INTERGRAL and other trademarks contained in the Software are
trademarks or registered trademarks of INTERGRAL Information
Solutions GmbH. Third party trademarks, trade names, product
names and logos may be the trademarks or registered trademarks of
their respective owners. You may not remove or alter any
trademark, trade names, product names, logo, copyright or other
proprietary notices, legends, symbols or labels in the Software.
This EULA does not authorize you to use INTERGRAL’s or its
licensors’ names or any of their respective trademarks.

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.

The FusionReactor Blog was selected as one of the Top 40 Java Blogs by FeedSpot. The whole FusionReactor team are proud to be part of this list. Have a look at some of the other top Java blogs featured in the list.

We also got this cool badge for being featured in the top 40 :

Remote debugging is not a new concept and you can find numerous articles explaining how to setup various IDE’s such as Eclipse, Netbeans or IntelliJ to perform remote debugging of a Java Application.   

If you’ve searched and found this article, you will have your reasons for why you want to be able to do this e.g. local debugging is not possible, the code you wish to debug is not running on your local machine or the problem you’re trying to isolate only occurs on another environment (usually production) etc.   OK, now it’s getting scary, did you ever think of debugging a remote java application which is running in production?     Maybe you’ve heard developers say, “We can’t reproduce the problem, it only ever occurs in production – If ONLY we could debug it”.   

Before we go any further though, let’s take a step back and look at the main reasons you may NOT want to debug a remote (production) application.  (Make sure to read on, to understand how FusionReactor addresses and solves these concerns though!)

• When you set a breakpoint – it could halt your whole application as the breakpoint would (theoretically) trigger on all threads at that point in the code.  Ouch – well you definitely don’t want that happening in production.
  
• When you use a debugger – you imagine sitting in-front of it and stepping through your code – i.e. you set a breakpoint – allow your application to run to that point in the code and then take a look at some variables.   However, what happens if you’re not in control of when the breakpoint fires?   What happens if your breakpoint would only fire in a rare corner case, which is what you’re actually trying to figure out.    Well, then you could be faced with a long wait before that breakpoint would ever fire – order the pizza, it could take a while….
  
• Attaching ECLIPSE or some other IDE is going to cause too much system overhead and it’s also fairly tricky to setup.    Or, you’re using an IDE which doesn’t even allow remote debugging.
• The core developer perception that you should not use a debugger in a production environment (very probably based on the reasons mentioned above).

Well, if you’ve got this far, then hopefully I’ve got you sufficiently enthralled to find out how FusionReactor can solve all of these production debugging related issues.    Read on – all will be revealed…

• Problem: Breakpoints affect all threads.   Solution: FusionReactor has implemented a suite of (patent pending) control mechanisms by which the debugger interacts with the environment it’s running on.  Examples of these control mechanisms are:
  • Fire once (or n times) for any breakpoint which means only 1 thread would ever be affected even when the break point fires.
  • Controlling the debugging capability from a specific IP address.
  • Rate limiting the number of threads which can be paused in the debugger at any 1 time or how many threads a single break point can pause.  If an application server has a thread pool of 16 you could say only 2 threads can be paused at once (either globally or per breakpoint)
  • Thread pause timeout : if you (the user) would not intercept a paused thread within a specific time then FusionReactor will release the lock and allow thread execution to continue.  This reduces the thread pause time to n seconds when debugging on a production server.  When used with the thread limits or file count limits this reduces the possible impact to 1 thread only 1 and only for n seconds.
    
• Problem: If you’re debugging, you usually have to wait for a breakpoint to fire – which could be a big problem if you’re waiting for that elusive issue to occur.   Solution: FusionReactor is capable of holding a single thread either for a period of time in hours, minutes, seconds – or indefinitely.   This removes the need for the developer to babysit the application waiting for the trigger to fire.   Essentially, it enables the debugger to run in an ‘Unattended’ fashion – rather than it would typically i.e. one would usually, always attend a debugger whilst using it.
  
• Problem: Setting up remote debugging is tricky and incurs too much overhead.   Solution: FusionReactor is simple to install and has its own built in IDE for debugging – FR is designed to be installed on production servers and has an overall impact of <1%.   For the debugging part, it uses the JVMTI library from the Java Virtual Machine.  This exposes a debug API to our debugger (this is the same method used by other IDE’s like Netbeans and Eclipse). Getting this configured in FusionReactor is simple.    The normal impact of having FR’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.   FusionReactor only enables the features in JVMTI when the user wants to use them.   So only when a break point is set will it start to process class load events to install break points into those classes.  Exception event hooks only become enabled when the exception breakpoint trigger is configured and enabled.    It’s a small price to pay for the benefits you get.

Here is an image of what the integrated debugger looks like (within FusionReactor).

As you can see, it’s very similar to most other IDE style integrated debuggers and this is completely built into FusionReactor.   The debugger includes the following features.

• Source code and line number specific breakpoints.
• Java Method Entry breakpoints.
• ColdFusion Function Entry breakpoints.
• Field access and modification breakpoints.
• Exception being thrown and exception caught breakpoints.
• Email alerts.
• Breakpoint samplers.
• Conditional breakpoints.
• Rate limiting.
• Interactive debugger.
  • View source code when configured in the Sources page
  • View decompiled code for classes without source.
  • Change variables at runtime.
  • Step into, out and over source code.

Installing the debugger and activating FusionReactor

Go get the latest version of FusionReactor from our download page – https://www.fusion-reactor.com/download/

Installation is very easy – you can install FusionReactor either using the automated installer or you can install it manually.   If you use the automated installer, then the debugger library will be automatically installed for you.   If you perform a manual installation – then you need to follow these steps.

Once installed you will need a trial license – which gives you 14 day access to all FusionReactor features (including the debugger) – you will be provided with a trial license from the download page.

Here are links to some resources to get you going…

• Installation Videos for FusionReactor
• Video Tutorials on using the debugger – from our YouTube Channel
• Debugger documentation
• Debugger examples

Well I hope that’s whet your appetite and you’re ready to start remotely debugging those production Java servers.

We are sponsoring Velocity Conference,  Amsterdam. You can visit us at booth #416, we will be showing off the latest version of FusionReactor and FusionReactor CLOUD. To celebrate this we are giving away a free ticket for Velocity Conference, Amsterdam.

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

There are Two ways to enter the draw:
1) ON TWITTER : Retweet this tweet and follow us 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 post us a Personal Message – “I want to go to Velocity Amsterdam”
We will be announcing the winner on,  Friday 21st October, 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

Win a Ticket for Adobe ColdFusion Summit – Las Vegas, 2016

The FusionTeam will once again be sponsors of this great event – make sure you join us and the Adobe ColdFusion Team! We will be showing off the latest version of FusionReactor and FusionCLOUD.

To celebrate this we are giving away a free ticket for the Adobe ColdFusion Summit.

The Prize is for one ColdFusion Summit registration which Includes:
– Admission to all keynote and breakout sessions
– Sponsor Pavilion.
– Attendee appreciation event
– Conference meals.

There are two ways to enter the draw:
1) ON TWITTER : Simply follow us and send us a Direct message saying ‘I want to go to CFsummit’

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

2) ON FACEBOOK: Just Like us on Facebook – and post us a Personal Message – ‘I want to go to CFsummit’

We will be announcing the winner on, Friday 23rd September, this will give the winner enough time to organise flights and accommodation.

If you do not win, please do not worry you can still get a ticket for $199 on the entry price by using our Discount Code: CF199Offer