What is APM?
Once the application has been deployed into production, there should be means to monitor the application’s performance to identify any potential bottlenecks. Though there are strategies like instrumentation of source code these are not without constraints. Developers need to code the application in such a way that the instrumentation is possible in a non-intrusive way. This complexity increases with the complexity of the application typically spanning through various layers like UI, server side UI code, services, data layers etc. What is needed is a non-intrusive way of monitoring an application without having to change the code. APM tools provide this capability.
Application Performance Management (APM) is also considered as the science of understanding all the factors that impact application performance.
Why do we need APM?
Here are some of the pain-points when it comes to an application that is built in an enterprise scattered with different topography, landscape details and agile mode of development:
- business demands are increasing
- applications are rapidly changing
- there are too many development/test iterations
- it takes too long to deliver and repair apps.
From an application performance monitoring perspective, there are few specific criteria’s or attributes which are very important for any business to monitor and serve the end users with a better experience :
- Application Availability (i.e. what is the frequency of the users’ transaction getting completed and resolved)
- Application Response Time (i.e. how long the business user has to wait for the transaction to complete)
- Transaction Time (i.e. the sum of the parameters like Client Delay + Network Delay + Server Delay)
Based on the above sets of parameters there are different schools of thoughts on monitoring (based on the type of business scenario) like
- Transaction based monitoring (i.e. time taken between submission of request and getting the confirmation page)
- Throughput based monitoring (i.e. the throughput bytes/sec seen on the UI)
- Streaming based monitoring (i.e. %age of time the application kept the playback buffer)
If we take the real-time scenario, this is what we feel we have created for the End user:
But the end-user comes across screens like “Search in Progress”, “Loading…”, “Page cannot be rendered”, “Error 404 – Page not Found” etc. These can actually act as bait to Test the Patience of the end user. We all have experienced it and face it in our day-to-day life (Bank Transaction, Bill Payment, Online shopping etc..)
The “THING” the Business does not see but we know the pain and the effort we have spent in creating the Business-Backbone i.e. the underlying hidden complexity of the Application. I cannot say the response will take 3-5 seconds because, multiple external systems are involved and it all depends on the current state and availability of the systems based on the data exchange. Here is a snapshot of the Hidden Complexity of an application
When do we use APM?
For the disastrous application performance and slowness of the system for which the end user gets furious – there could be “N” number of factors responsible or a combination of all. It could be:
- network factors such as errors (link errors or duplex mismatch, server downtime)
- congestion (which causes discards), and
- high network latency (due to network topology or slow firewalls)
- internal service calls and external system availability
- memory issues (CPU utilization, memory leaks, disk space, garbage collection)
- query data too high
- cache was not thread safe
- object locking issue
- …and many more
In order to counteract the different issues and risks in an application APM comes to the rescue helping the developer, testers and everyone in the Team in identifying, troubleshooting and debugging the issue.
How do we use APM in an end-to-end solution?
Whenever we move a code from DEV to TEST and from TEST to PROD, we always deploy the code and push it to the new environment with our fingers crossed. So, that we do not get any surprises. Everyone likes surprises but not when it comes to issues and bugs 🙂
APM Tools actually provide features like :
- Application performance dashboard (number of errors, policy breach, stall requests and graphical representations)
- Defining Business Policies (that were breached and that are within limits – eg: Garbage collection has taken place on time or the Memory Leak is within limits)
- Defining Thresholds (e.g: lets say the business needs an avg response time of 2ms and anything above this number can be considered as a slow performance)
- Configuring Alerts and Notifications (it more like sending a email notification or trigger when a policy or threshold is breached)
- Taking snapshots of the system on a timely basis
- Populating the Stall and Outlier requests that needs to be analyzed and troubleshooted
- Define Business Rules and Conditions
- Integrating with all the external systems(like : LDAP, mainframes, TIBCO, Pega, Email Server, HTTP request, Oracle, Cassandra etc..)
Intro to AppDynamics :
AppDynamics is one such APM tool in the market and is rated highly on Gartner’s Magic Quadrant for APM.
Source : Gartner (AppDynamics Site) http://info.appdynamics.com/APMmagicquadrant.html
Following are the features :
- Monitoring Machine (System CPU utilization, garbage collection, network I/O)
- Monitoring Web Applications (latency, response time number of calls, thresholds breach, policies breach)
- Monitoring Modern Systems (NOSQL database and many other external systems like Cassandra, LDAP, mainframes, Tibco, etc.. even we can have our own custom connectors)
- Configuring Policies and Thresholds for alerts and outliers
- Analyzing Issues and Debugging/Troubleshooting
- Configuring cloud instances
AppDynamics Deployment Architecture:
AppDynamics is composed of a central Controller or management server that communicates with two kinds of agents, an Application Server Agent (App Agent) and a Machine Agent. The Controller UI is the performance monitoring interface. The Controller can be easily deployed on-premise or hosted by AppDynamics using a SaaS delivery model.
The App Agent is deployed on the machine where the application to be monitored is deployed. The App Agent sends the application level information related to the request, processing times etc. to the controller. The controller uses an internal database (mySql) for storing all the data that is fed. Based on the statistics and data availability, it generates the necessary graphs, charts, tables and performance indicators. Similarly, the Machine Agent sends all the Machine/System health level information like Garbage Collection state, CPU Utilization, Disk space, and other Network I/O updates.
Advantages Business Benefits of using APM Tools :
- Better Visibility of the end-to-end solution
- Performance Dashboard – providing a one-stop place for the Health of the Application
- Proactive Alerting and Notifications which helps to keep the Issues under control
- Troubleshooting, Analyzing and Debugging made easy
- Faster Resolution of Issues
- Automating Tasks to reduce manual intervention and effort
- Reports and Data snapshots for reference and audit trail
Concluding Thoughts :
APM is definitely not a mandate for any Application, but having said that, with the growing trends in the way we knit of applications involving on-premise systems, external systems, cloud based systems, mobile applications and many other hunky dory systems in an enterprise landscape. It becomes a nightmare when an issue or a show-stopper pops up. Where to to start with and What to proceed with. This is where life becomes easy with a APM Tool which takes the burden of identifying the culprit in the application and showcasing it to us on a dashboard. Here is a snapshot of the Current and the Future Trends of application build :
List of some APM Products in the Market :
Please feel free to add your valuable thoughts and inputs 🙂
Happy Learning 🙂