Andreas Grabner About the Author

Andreas Grabner has been helping companies improve their application performance for 15+ years. He is a regular contributor within Web Performance and DevOps communities and a prolific speaker at user groups and conferences around the world. Reach him at @grabnerandi

Application Performance and Architectural Problems You can Find in One Hour



When we get engaged with prospects that are interested in our performance management solution we walk them through a Proof of Concept. We let them install dynaTrace on their own prior to the actual POC. During the POC we ask them to exercise typical use cases on their application that show performance problems. We walk them through the different analysis options and add the findings to a final POC Presentation. In this blog I want to share some screenshots and findings of a typical Proof of Concept recently done in a heterogeneous .NET/Java Environment.

Out-of-the-Box Result Presentation

The screenshots are taken from the final POC Presentation that my colleague Francis pulled together after analyzing a one hour recorded dynaTrace Session with an Out-Of-The-Box dynaTrace Configuration.

1. Get a general performance overview of the application – where are my hotspots?

Different ways to get a high-level performance view of the capture data

Different ways to get a high-level performance view of the capture data

Read more on identifying Hotspots

 

2. What is going on between my application servers?

Transactional Flow Diagram allows us to drill into more details

Transactional Flow Diagram allows us to drill into more details

Read more on Tracing Distributed Applications

 

3. Sequence Diagram for individual transactions

Sequence Diagram giving us a high level performance overview of a slow running transaction

Sequence Diagram giving us a high level performance overview of a slow running transaction

The Sequence Diagram can also be used to see how tiers interact, where our bottlenecks are and where exceptions are thrown

The Sequence Diagram can also be used to see how tiers interact, where our bottlenecks are and where exceptions are thrown

More on analyzing architectural problems

 

4. Analyzing Database Activity

Analyze Database Activity per Transaction. Identify problems where SQL Statements are called multiple times with the same parameters

Analyze Database Activity per Transaction. Identify problems where SQL Statements are called multiple times with the same parameters

Analyzing slow SQL Query on WebLogic:

Several individual DB Queries had an execution time of > 4 seconds

Several individual DB Queries had an execution time of > 4 seconds

Read more database related blog entries.

 

5. Identifying slow Remoting calls

Identify slow remoting calls including full call context and the ability to trace into the server-side implementation of this call

Identify slow remoting calls including full call context and the ability to trace into the server-side implementation of this callRead more remoting related blog entriesInspecting asynchronous MessagesdynaTrace can follow asynchronous messages through your SOA infrastructure

 

6. Analyzing hidden exceptions

dynaTrace captures exceptions including full call stack. Drilling to the actual PurePath (Trace) gives more input on the actual call context

dynaTrace captures exceptions including full call stack. Drilling to the actual PurePath (Trace) gives more input on the actual call context

More exceptions caught on WebLogic:

Many internal exceptions that never made it to the application code indicating XML Format issues

Many internal exceptions that never made it to the application code indicating XML Format issues

 

7. Runtime Suspension (Garbage Collection) Impact Analysis

Identify the impact of Garbage Collection on response times of individual transactions

Identify the impact of Garbage Collection on response times of individual transactions

Read a blog post on the cost of exceptions

 

8. Details on Web Service Calls from .NET to Java

Details on Web Service Invocations such as input parameters, transfered bytes or the impact of the GC on the execution time

Details on Web Service Invocations such as input parameters, transferred bytes or the impact of the GC on the execution time

 

9. Lookup Source Code from your own or foreign code

Found a problematic method? Directly lookup the decompiled Java/.NET Code

Found a problematic method? Directly lookup the decompiled Java/.NET Code

Conclusion

As you can see – it is easy to get an overview of the performance hotspots. The typical problems that we always find are things like too many database statements, hidden exceptions or long-running remoting calls. Read my blog about the Top 10 Server-Side Performance Problems that we often find with our dynaTrace Installations.

Comments

  1. Didn’t thought that finding performance problems will be that easy :) we always has trouble to find out any memory leak or performance issue and has to spent countless hours. just wondering is your tool is only for web application or it works for simple java server running on Unix machine ?

    Javin
    How HashMap works in Java

  2. Hi
    dynaTrace works on ANY Java or .NET Application – regardless whether it runs in an AppServer or whether it is a Rich-Client App. dynaTrace also supports native apps as well as Web 2.0 Apps executing code in the browser. Check out this blog and our website – I am sure you will find enough information about our capabilities
    Andi

  3. I think databases are one of the most sensitive part in the application, load has direct effect on database performance, and DB’s are much more difficult to scale the the app itself.
    Xeround database is a scalable solution that ensures that database performance remain reasonable even under load.

  4. Hi,
    The top performance problem can exist in 3 layers.

    1. Client
    2. Business Logic
    3. Database.

    second and third one analyzed well in the above including remote calls.

    Actually there is another big issue handling objects ( for large scale applications). Especially poor handling collections with logic may lead significant performance issue in the distributed application where this article didn’t say anything.

  5. Ravi Petchimuthu says:

    Nice One. Probably 90% of the performance issues of an large application will be seized using this tool.

Comments

*


9 + = seventeen