Problem pattern detection

Overview

Many applications suffer from the same or similar performance, scalability and architectural issues. Using AppMon to detect and analyze them over time reveals common patterns that can be categorized as types of performance issues.

AppMon 6.5 and later analyzes every PurePath against these automatically detected common patterns. The AppMon Web PurePath view lets you easily find PurePaths within a particular pattern, and shows related performance patterns. Patterns show as PurePath categories with customizable buckets indicating the performance issue severity for that category.

Categories display also as top findings, which let you see potential transaction problem areas at a glance, giving insight into resolving performance issues and finding optimization areas in the application. These display in both AppMon Web and in the AppMon Client, so the insights are readily available as you perform analysis.

Purepaths in the AppMon Web PurePath view cover all transactions, which are tagged with these common problem pattern categories:

Problem pattern categories

Response time

Default Bucket Thresholds: Very Fast (<100ms); Fast (100 ‐ 500ms); Normal, (500 ‐ 1000ms); Slow (1-4s); Very Slow (> 4s)

This analysis looks at speed of PurePaths. Among other ways to analyze using this category, you can analyze very slow transaction by comparing them with the same requests on the same URL that went really fast, since AppMon captures all transactions all the time. This lets you quickly spot slow transactions and compare them method by method with similar fast transactions.

State

Default Bucket Thresholds: No Errors (transaction has zero errors); Detected Errors (one or more non-failing errors detected); Transaction Failed (one of more errors led to a transaction failure)

This category focuses on detected errors in transactions. An error is an unexpected event that happens while a user interacts with a system. Common errors include resources that cannot be found on a web server, HTTP 500 response codes sent by a web service, or application exceptions. This category lets you get straight to root cause analysis by selecting a transaction and stepping through the errors that were detected on method calls of the transaction.

Database

Default Bucket Thresholds: DB Chatty (> 100 SQL Executions); Single Long SQL (1 SQL taking > 80% of SQL Total); N+1 Query Problem (Same SQL executed > 10 times); Overall DB time too high (JDBC/ADO.NET/PDO time > 80% of Total Exec Time).

Database access is the most common application problem pattern. AppMon analyzes database access and marks your PurePaths that show strange patterns. Even if response time of the application is fast, this category can reveal whether a pattern has been added that can cause problems with increased traffic on the system or a larger database. This type of analysis also only works if you always capture every single transaction with all details.

You can also use this data to compare the same business transaction that shows a bad access pattern with a transaction that does not. A classic example is a bad search query that causes lots of database queries. For that to know you need to have the good and the bad transaction available and compare them.

Web service

Default Bucket Thresholds: High payload (Request + Response Size > 500k); Chatty (> 50 Service Calls per Request); Slow (1 Service Call > 80% of Total WS Time); N+1 Pattern (same Service call more than once); High Web Service Time (> 80% Total Time)

Services have always been used by applications, even more so with the popularity of MicroServices and many frameworks that make it easy to write and consume services. This practice potentially creates a lot of bad web service access patterns.

For example, a PurePath that shows a high number of the same service calls that consume more than 80% of the total execution time can potentially indicate a problem.

This example shows how the Web Service category quickly identifies PurePaths with potential problematic web service access. The PurePath /special-offers.jsp tops the list of recent Purepaths in the N+1 calls sub-category. The Transaction Flow drilldown shows 30 calls to the same service, taking over 93% of the execution time, indicating a problem PurePath.

Threading

Default Bucket Thresholds: Heavy (> 5 Threads per Path); Acceptable (< 5 Threads per Path); Normal (<=2 Threads per Path)

Many transactions use a lot of background threads to parallelize work. Transactions using a high number of threads have a high potential for inefficient coding and poor synchronization. Also, the more threads involved, the more resources consumed on the App Server, which can directly affect system complexity.

Use this category to focus on the total number of threads involved in processing a single transaction.

HTTP response

Default Bucket Thresholds: 4xx, 5xx

This category helps you focus on requests that return a certain HTTP Status Code and analyze failing requests that return an HTTP 5xx. This category also helps to more easily reveal transactions with bad redirects or authentication issues.

Complexity

Default Bucket Thresholds: Complex (> 10 Agents or > 1000 Nodes); Medium (< 10 Agents or < 1000 Nodes); Normal (< 3 Agents or < 100 Nodes)

Sorting PurePaths by size (number of nodes) typically lets you quickly see the more complex transactions. These are typically transactions with a greater likelihood for issues.

Use this category to understand the impact that the number of tiers have on a transaction's efficiency for larger sized Purepaths. A transaction that spawns more than 10 tiers usually is a highly complex transaction where the potential for problems rises. The Complexity category helps you streamline analysis of these PurePaths.

Async

Default Bucket Thresholds: Heavy (Duration > 10x of Response Time); Normal (has async activity); No Async

Response Time is good to optimize, but can result in initially fast responding transactions that end up running indefinitely in the background. For that reason, AppMon also captures PurePath duration, which includes all asynchronous activity triggered by the initial request. An unusually long Duration as compared to the Response Time is usually a sign of potential issues with the transaction.

Threshold Adjustment

AppMon comes with predefined thresholds that can be adjusted for each System Profile. If needed, you can adjust the thresholds in the applicable System Profile configuration xml file, located in <DT_HOME>/server/conf/profiles.

The following graphic shows where to adjust your preferred thresholds.

Note

You must restart the AppMon server for any changes made to a System Profile configuration file to take effect.

Problem Pattern Detection Webinar