Application Performance Management (APM) is the management of software applications, typically from a high-level view, to ensure an expected level of availability and performance. Monitoring can help gain more granular visibility into a particular application.
The average company runs many applications. APM is necessary because the average environment is now too complicated for most administrators to independently monitor and detect the kinds of technical incidents that compromise service quality.
Let’s say that your company supports many end users. An issue that affects a comparatively large number of people might still disappear into the noise on your monitoring screens. APM tools are designed to bring these issues to your attention and correlate them with related infrastructure failures.
For example, a group of your users may be experiencing increased latency – and at the same time, one of your e-commerce plugins is showing decreased throughput. APM will flag both issues for you, which helps point you in the right direction. APM tools tend to focus on the broader scope of issues that affect your end users, such as increased load time, price glitches, abandoned transactions and more. Each issue can then hopefully be matched with a failure in your application stack.
One drawback of APM is that it isn’t particularly granular. It will show you if there’s a problem with your application, but won’t identify where the actual problem lies. Narrowing down your outage to a single application isn’t necessarily going to fix your problem as fast as you might want. If you need to mitigate an outage before customers start noticing, you’re going to need application performance monitoring in addition to APM.
Application Performance Monitoring
App performance monitoring takes a narrower approach than APM itself. APM looks at your entire application stack, while a monitoring solution focuses on a single application.
Let’s say for example that you need to drill down from a single application within your application stack to a single module or plugin within that application. Unfortunately, your application might make this difficult to do. Applications have sprawling runtime architectures and dozens if not hundreds of components. More recent applications are built on microservices or containerized architectures, which are designed to be ephemeral. The application you’re trying to monitor might not be on the same host if you check it at different times.
App performance monitoring tools essentially instrument an application to make it easier for analysts and developers to hunt down faults. Monitoring can either simulate user transactions to understand where faults lie or passively monitor user transactions to understand when they deviate from an established benchmark or SLA. Monitoring tools can also follow transactions through the code, application, and VM layers to find bottlenecks, slowdowns and errors.
Some tools can even provide code-level analysis. Code errors are often at the root of common issues. For every 1,000 lines of code a developer writes, 15 errors get shipped to the customer. Lastly, monitoring tools can even delve into the application infrastructure, highlighting problems that occur with program memory, storage or compute power.
To summarize, app performance monitoring tools can observe the application at a granular level, while general APM tools observe all of your applications at once. Below are a few ways that organizations use these tools together in order to achieve success.
Adding Monitoring to Your APM Workflow
Right now, it can take hours for companies that use traditional monitoring and analytics to trace and solve a systemic issue. By using a combination of APM and monitoring, organizations can significantly reduce the amount of time an outage will last.
Here’s a quick example. Imagine a company that makes its revenue by charging users a monthly fee. The company has recently drawn fire for an error in which it charged some users twice in the same month – and as of now, it’s not even sure which users were specifically overcharged.
With more granular monitoring in place, the company could have avoided the wrath of its consumers. First, APM would have recorded an unexpected increase in revenue from auto-billing, without any correlated growth in its customer base. The monitoring tool would’ve investigated the auto-billing application by monitoring customer transactions or performing a synthetic transaction. It might notice an anomaly, such as customers getting billed twice in one month. Using this information, the company would have been able to identify and rectify the error before its consumers noticed something was amiss.
By integrating APM with monitoring, users can receive granular information about their entire application ecosystem. This helps companies create a proactive strategy that enables them to quickly find and fix anomalies and avoid costly delays.