“A man who says “I have learned enough and will learn no further” should be considered as knowing nothing at all.” – Haile Selassie I
Hey Mon! If you’ve been reading my blog for any length of time you know that I love free tools. That’s why I was excited to learn from Andreas Grabner during a recent TestTalks interview about the performance-monitoring tool Application Monitoring (AppMon) by Dynatrace. (Random thought: every time I type “Appmon,” I think “Hey Mon,” which makes me think of Bob Marley — hence the Jamaican reggae references)
Personal License for Free
Dynatrace Appmon offers a personal license you can use free for life in your local environment. This is awesome because you can use it to monitor the applications you’re developing or testing on your own workstation.
It’s also non-invasive in the sense that it uses on-the-fly instrumenting to hook into your application, which means no code changes are required to start using it.
Dynatrace Sees What’s Happening
Appmon leverages official interfaces like JVM, CLR, NodeJs engine, PHP engine and more. So you can simply drop a library onto that container and Appmon will automatically analyze the performance of your code execution.
Once you have deployed Dynatrace, you can actually see which requests are coming in from your application. It doesn’t matter how the requests are generated. Regardless of whether it’s from an automated test or a user manually interacting with your app, all the requests will be seen.
Appmon Tracing
Appmon is also able to trace your request through all the layers of your application. Rather than looking at just a total response time, it can actually identify which layer is taking the most time, making it much easier to troubleshoot.
This works by using the code path that captures the execution times of methods. It gives you information on your method arguments return values, SQL statements, etc.
You can also instrument all of your services, micro-services, and front and back end components. When analyzing or monitoring your application, you’ll be able to see how your application front end talks to the back end, and any other services or layers that your application touches.
Pure Path
This technique of being able to do such tracing is known as “tag and trace.” Tools like Dynatrace Appmon are able to trace a single request from a browser all the way back to a database whether it's a single tier, multi-tier, or micro-service application. This provides you greater insight into what is actually going on with your application performance.
Dynatrace calls their implementation of tag and trace Pure Path.
Finding Unknowns
You can uncover many things you might not have even been aware of, like dependencies on external services that may not be enabled in all your test environments. This is a pain to track down without using a monitoring solution like Appmon.
With Pure Path, Dynatrace Appmon is also able to see a new transaction coming in from a browser or on a web server, and by applying a unique tag ID to it it’s able to trace that request through all of your different application tiers.
Dynatrace Tagging
By taking this unique tag, Dynatrace is able to show the entry point as well as all the different protocols your application is using to communicate with the other tiers.
Some developers use a more primitive method called Logging to obtain this info. Basically, they log as much as possible then use a log analytics tool to stitch everything together to see what actually happened. This is time consuming, however, and not always accurate.
A better approach is to use a tool like Appmon that solves the problem by automatically capturing the methods that were employed, including execution times.
It also automatically brings in health metrics from the process itself. For example, if you’re using a Java process it will pull in JVM metrics like garbage collection activity, heap space, thread pools, etc.
One Performance View
Since all this data is being pulled in while you’re looking at the test data, you needn’t go to the database admin, system admin, developer or other members of your team asking for data. Even if you receive all the data, you still need to go through the tedious process of taking lots of information from multiple tools and try to make sense of it.
Using a tool like Dynatrace solves this by getting one consolidated view of all the information you need in order to analyze performance problems.
We be Jammin’ as We Shift-Left
It’s no surprise that the actionable advice Andreas offered on Test Talks was to encourage your developers to use their local stations to actually look at these performance metrics using a tool like Appmon.
By doing this your team can avoid performance issues by eliminating them before they get committed into your code base.
You’ll also get to know the potential impact of a code change and be able to fix the code to make it better before you actually committed to the CI environment.
Using this approach will help to shift your performance testing efforts left and help you to achieve performance awesomeness early in your software development life cycle.
[thrive_link color='red' link='http://testgu-21304.arnt-nyc.servebolt.cloud/cart?add-to-cart=247′ target='_self' size='big' align='aligncenter']REGISTER NOW[/thrive_link]
Discover More at PerfGuild
Sounds cool, right? Want to discover more? If so, be sure to register for this year’s PerfGuild, an online conference 100% dedicated to performance testing.
You’ll get to learn from the Dynatrace Appmon himself, Andreas Grabner. Andy’s session will be on Performance Engineering with Dynatrace AppMon. You’ll discover how application performance management tools like Dynatrace AppMon, AppDynamics and NewRelic, work, as well as how to install them in your environment and integrate them with your load testing tools (JMeter, Gatling, LoadRunner, Silk, etc). You’ll also hear how Andreas goes about analyzing data.
Andy will also reveal the most common performance problem patterns he sees, how he analyzes them and how you can do the same within minutes.
You don’t want to miss it! Register today.
