Application performance management (APM) is the practice of monitoring and managing the performance, availability, and capability of modern software applications. APM doesn't have an explicit, dictionary definition, but is rather an industry-created term that encompasses nearly everything to do with monitoring and managing code, application performance, transaction times, and end user experience.
The overall goal of application performance management is to detect, diagnose, and assist in resolving complicated application performance problems, in order to maintain a pre-determined "minimal level of service." Of course, every organization and application will have a different definition of what that minimal level of service can be. However, by following a basic set of overall application performance management principles, a team and project of virtually any size should be able to implement a workable and beneficial monitoring solution.
In this article, we'll explore the basic principles of application performance management, along with a handful of the best tools and techniques for implementing these principles into your own project. Let's take a look!
In late 2016 Gartner Research, one of the world's leading technology research groups, proposed the latest iteration of their APM Conceptual Framework specification, which proposes five fundamental application performance management principles. By working to implement and abide by these principles, most APM models should be stable enough to provide ample coverage against all potential pitfalls.
Commonly referred to as real-time application monitoring the goal of the end user experience principle is to ensure that communication between a client/user request and a server/remote response is efficient and effective. Passive monitoring is the first of two components that make up the end user experience, and should perform an agentless monitoring of ports and services used within the application (such as HTTP requests, database queries, and so forth). Active monitoring, on the other hand, uses explicit agents that should each actively probe and test systems, while the system is performing basic business transactions.
As the name suggests, the overall goal of tracking the end user experience is to maximize responsiveness to actual users, regardless of the incoming traffic or application activity at that particular moment in time. Proper APM practices should give your team insight into the application's performance and the end user experience at all times of day.
This principle aims to ensure bottom-up monitoring is active and functional, which provides a direct and measurable correlation between the topology of the network and your application's architecture. Ideally, you should implement some form of automated transaction mapping, in order to track each of the application's infrastructure components and see how each interaction that said components perform is carried out, relative to the rest of the application infrastructure. With such capabilities in place, your team can better perform impact assessment for upcoming features, releases, and other major system changes.
The goal here is to try to categorize the multitude of potential detailed transactions your application may be capable of making into a smaller, more manageable high-level categories. For example, consider the many different URL endpoints an application might have related to the /user domain:
/user/create/user/#id/user/#id/delete/user/#id/feed/user/#id/message/user/#id/subscribe/users/Modern applications will likely have dozens if not hundreds of potential endpoints (and, therefore, transactions) that each resource can perform, so keeping track of these can be difficult, even using the best application monitoring tools. Therefore, it is generally beneficial to try to categorize this large assortment of transactions into broader categories, which can then be monitored and more easily referenced in reports and other business communications. In the example above, a resource-based user category may serve as a good starting point for all user-related transactions.
Through the use of explicit agents and tools, your monitoring solution should be capable of providing real-time feedback of the particular language-specific application stack your software is using, and relate to the team how each component within said stack is connected to and performs user-defined business transactions. Ideally, the result should show a clear, traceable path traversing from source code execution up through the component stack and back to the final source of the transaction request (i.e. from the client/user). Since this piece should involve everything from the local program runtime to any application middleware, the benefits include better code reviewing, more accurate quality assurance and testing, and overall performance insights.
The final and perhaps most important component of a successful application performance management model is adequate and robust analytics reporting. This involves first determining what common set of metrics should be collected and reported within the application, or even for each individual component of said application. From there, you'll need to establish a standardized view for how the data should be presented, so everyone on the team is on the same page when viewing or discussing said data.
In most cases, it is better to have too much source data than not enough -- collect as much raw data as possible, and from there you and your team can decide what useful insights can be pulled from that dataset to actually create useful reports and analytics.
Creating insightful, useful, and visually appealing APM reports can be a massive challenge unto itself. Not only are there a million ways to approach the actual gathering of raw data, but combining data into a useful collection that can provide actionable feedback is a major undertaking.
Thankfully, many different tools exist to aid your team with application perform management implementations. In general these fall into a few broad categories of tools, including tools aimed at helping developers with actual code creation, tools aimed at helping administrators handle server infrastructure management, and tools aimed at helping everyone monitor the results of a production application.
Code profilers allow developers (and other team members) to quickly analyze written or executing source code, in order to detect potential bottlenecks, stack issues, or other performance related problems specific to the code itself. There are dozens of powerful and popular tools, but below are a handful listed for various common languages and platforms.
dotTrace code profiler, dotMemory memory profiler, and dotCover unit test runner and code coverage tool. Code style and formatting functionality with fine-grained, language-specific settings will help you get rid of unused code and create a common coding standard for your team. You can instantly navigate and search in the whole solution. Jump to any file, type, or type member, or navigate from a specific symbol to its usages, base and derived symbols, or implementations.pstats module.Once your application is actually up and running an application monitoring tool or service will help your team keep track of critical health metrics within the app, such as transaction traces, database and server responsiveness, cloud resource performance, mobile telemetry, and much more. Again, there are a multitude of powerful services and tools available, so we've highlighted just a few of the most established and powerful options below.