OverOps locates the exact cause of critical exceptions in your app with the changing status for the context. Armed with this information, you do not have to spend countless hours on detective work sorting your logs or APM to understand what happened to your app and what exactly needs to be fixed.
For example, a programmer usually sees an exception with the associated stack tracking as follows. The cartridge tracking does not show you much information that will help pinpoint what and why an exception was dropped in your application. In some cases you may be lucky enough to record the relevant information in your log file, but in most cases it is unlisted or irrelevant.
OverOps provides you with all the information you may need to solve the actual problem.
- Without any foresight (no need to add additional registration statements, change code, add debugging statements)
- No need to redeploy your app for troubleshooting purposes
- There is no need to increase your registry or try to figure out how to recover from the problem
- Fits your existing processes and tools – and ultimately actually improves your processes by enforcing a quality gateway before code promotion
This is what the stack monitor screen in OverOps looks like:
from left to right:
- God Trace cartridge With indicators of your point of entry, where the exception was thrown and where it was caught
- Shows the source code, Frame by frame
- God Condition varies For each of the frames. Sensitive information deleted
In the pattern of stack tracking above, an exception / stack tracking complained about an inoperable date. Looking at it in OverOps, you can see that the code checks a different date format than what is displayed in your dateString variable.
When OverOps is integrated with your database system (Github, Gitlab, Bitbucket) we can even tell you which commit statement and which lines of code have been modified and by whom.
When exposing the changing data, we provide a full set of out-of-the-box data processing features that can be customized and enhanced to meet your needs. As such, no sensitive information is available or can be shared.
Regardless of your registry level settings, we capture all of your registry statements. So even if the registry is off in your production environment, you can see them in OverOps. This illustrates an excellent level of insight into what your app is doing, without having to pay the typical performance tax when registration is enabled.
Sometimes the problem is not related to the code but is related to the environment. We provide access to all information related to the environment without you having to make any changes to your code or application.
We capture all exceptions including non-perceived and swallowed exceptions and classify them accordingly. It also allows you to see exceptions that are usually hidden from you and which may cause problems that you are not even aware of.
Are you wondering how many NullPointerExceptions, IndexOutOfBoundExceptions or IllegalArgumentExceptions you have and what causes them? Now you can find out.
We also capture all the relevant statistical information about the events, including:
- How many times do these problems occur
- The error rate of each event
- When was it first seen and last seen
- What a layout presented these events.
You may be surprised at how often certain errors may occur in your production system. We’ve seen where certain errors occur 100+ million times in 24 hours and a billion times in a week!
Even if you do not have more than 100 million errors, in general you need to keep an eye on the impact that higher volume errors may have on your resources (CPU, memory, disk – when registering – AKA “performance”). The associated costs, especially when operating in the cloud.
If you are used to troubleshooting through your journal files and use journal aggregates, OverOps provides you with “tiny links” in your journal entries. These allow you to jump straight to an event within OverOps. The link provides you with the whole context around this diary entry to help you solve your problems much faster than using traditional methods.
When a new version is deployed, we can show which events never occurred before that version. It tells you that these events were presented with this new version so you can quickly review them and determine what is causing them. This way, you can fix them before they can affect any of your customers.
This is a great feature when using OverOps in your pre-prod environments or as part of your CI / CD piping process. You can even cause your construction process to fail if this happens to ensure you release good quality code to your production environments. Be sure that Provide deployment information To use this feature!
OverOps can also be integrated into your CI / CD solution like Jenkins. You can add OverOps Quality Gates to your process that will allow, for example, failure to build based on criteria like some new errors encountered. All of these thresholds are configurable.
If you use a static code analysis tool such as SonarQube, OverOps can be integrated with it so that you get a complete view of your code through static analysis (for example, SonarQube) and dynamic (i.e. runtime with OverOps). Beyond static code analysis of your code, OverOps adds context to issues driven by runtime data issues in your code. You will never get this insight in static code analysis alone.
OverOps allows you to continue to accelerate innovation, without sacrificing quality. If you have any further questions, please contact us here for a guided tour or for advice. And learn how companies like Comcast and British Telecom rely on OverOps to ensure their customer-facing applications remain reliable.