CAT | .NET
Let me guess: you’re probably expecting AppDynamics to be “another monitoring solution” for Windows Azure. You’re expecting it to show you basic server metrics like CPU, memory and disk I/O, along with a few CLR counters thrown in for good measure. Well, I’m sorry to disappoint you–but these metrics in isolation are about as useful as a chocolate teapot for monitoring your applications and business in the Cloud.
When end users interact with your Windows Azure application, they don’t experience servers, Azure roles, CPU, or CLR counters. Rather, they experience business transactions. Monitoring infrastructure metrics in the cloud is probably the worst KPI for managing Quality-of-Service (Qos) and application performance. Another problem in the cloud is application architectures, which have become virtual, dynamic and distributed. Applications are no longer just an app server and database. SOA design principles and cloud application services mean that business transaction logic now executes across many distributed application tiers and services.
For example, the Windows Azure PaaS platform has several services that allow organizations to run their mission-critical applications in the Cloud. Azure Compute provides web and windows services, Azure AppFabric provides messaging, security and caching, and SQL Azure and Azure Storage provides data management capabilities.
A major challenge for organizations is gaining end-to-end visibility of how their business (transactions) perform in the Azure Cloud. AppDynamics was founded in 2008 to address this problem, and it’s a key reason why Microsoft announced AppDynamics as a partner to help their customers manage application performance within Windows Azure. For AppDynamics, it’s an enormous privilege and responsibility to be selected by Microsoft, given Windows Azure is a huge strategic play as Microsoft looks to dominate the Cloud Computing market.
So what’s the big deal with AppDynamics in Azure? Let’s take a look at what unique capabilities AppDynamics offers for Windows Azure customers:
Application Mapping for Windows Azure Roles and Services
AppDynamics is able to automatically discover, map, and visualize the living topology and performance of a production application running inside Windows Azure. This allows organizations to understand the application tiers, Azure roles, and service dependencies inside the Azure Cloud so they can rapidly isolate which components are responsible for slow performance or poor QoS. For example, take a look at the following screenshot of an application hosted inside Windows Azure:
Business Transaction-centric Monitoring
What’s unique about AppDynamics production monitoring is that our key unit of measurement is business transactions–rather than, say, web pages, servers, or CLR metrics. AppDynamics can auto-discover the business transactions that end users are experiencing in the application. This gives IT Operations and development teams the context and visibility they need to monitor and manage the end user experience, along with understanding how transactions flow across and inside each application tier, Azure Role, and Services.
For example, take a look at this screenshot, which shows what business transaction monitoring looks like in AppDynamics:
Deep Diagnostics for Rapid Root-Cause Analysis
For situations where end users experience poor QoS, slow downs, or outages, it’s possible for organizations to pinpoint the root cause of issues in minutes using AppDynamics. AppDynamics uses intelligent analytics to self-learn and baseline the normal performance of every business transaction in an application. When performance deviates, AppDynamics captures complete diagnostic snapshots of business transactions that breach their performance baseline. Snapshots represent the complete distributed flow and code execution of slow business transactions as they execute across and inside each application tier, Azure role and service. This means IT Operations and developers see right down to the line of code responsible for issues in production that impact their end users and QoS. Root cause is therefore only minutes away.
Here is a screenshot of how a single user business transaction executes within Windows Azure:
Here is the code execution of that same user business transaction within the 2nd Application Tier “LowValueOrders” worker role:
Auto–Scaling for provisioning Windows Azure resource on-the-fly
A key benefit of Cloud is resource elasticity – the ability for an application to leverage additional computing resource on-the-fly, so it’s able to scale up and down all by itself. For auto-scaling to happen in Windows Azure, the application needs to know when to scale up and when to scale down. AppDynamics provides a comprehensive policy wizard that can auto-scale an application in Windows Azure based on business transaction KPI like end user response time or throughput. For example, if order throughput in your application were to drop due to increased load on your application, you might want to spin up more Azure compute (web/worker roles) to compensate for the additional demand until throughput stabilizes or load reduces.
For example, here’s a screenshot of the AppDynamics Azure auto-scaling policy wizard:
If you want to try AppDynamics for Windows Azure you can sign-up at the marketplace right here.
App ManLink to this post:
A week has passed since we officially launched our free version of AppDynamics Lite for .NET to the public, and so far its been garnering attention and positive reviews from the APM community. For example, someone from a major Canadian telecommunications company downloaded .NET Lite and informed us on how quickly they were able to gain value from using it.
We’re equally impressed and delighted that they’re heavily pushing our Lite product internally and on the path to becoming an AppDynamics Pro user. Even though we hear praises from customers often, it’s always satisfying to hear about our products delivering real, quantifiable results in under 24 hours.
We also received this blog review from another .NET Lite user just the other day. They deployed AppDynamics Lite to monitor their overall site performance called Everymarket.ru – an open e-commerce market that connects resellers with a community of buyers for products that are discounted when purchased in bulk. The users of Lite are also able to monitor the outbound web service calls to VK.com which is Russia’s version of Facebook to ensure outbound requests to the social site are responsive.
EveryMarket.ru Describes the Entire .NET Lite Experience
AppDynamics Lite looks nice and catchy. Right after installation we started to obtain information about our application and performance metrics immediately. The following screenshot nicely illustrates that there are some hidden errors occurring for three of the business transactions in the following list. We have actually seen these errors before, but it was quite hard to estimate their frequency and severity. Now it can be easily understood from this view here and on the Business Transactions view, though it is limited to only 20 transactions.
The first thing I did after the installation, I decreased the snapshot frequency from 100 to 50. It was more out of curiosity without much purpose. It’s nice to see the historical information about errors and requests presented on one screen. We then changed the default sorting “By timestamp” in order to see errors as they happened by recency.
In this case, the error in question didn’t involve a SQL query. The Bad Request details were quite simple and repeated what we could find in a set of stack trace logs. However, the main advantage for us is that AppDynamics can catch these errors and notify our team immediately by email. Once inside the tool, the information is well organized for faster root cause diagnosis.
In general I found it very useful that AppDynamics operates with business transaction logic. The semantic of transaction is easy to understand and one can have a detailed overview of a precise transaction. And of course the “red bar” matters. In case of many errors it is straightforward that “more red” means “look first”.
From two examples you can see that our .NET Lite users are able to install and run our product with ease while gaining insight into their application’s health and performance bottlenecks to improve upon for faster runtime. If you have a success story using AppDynamics Lite, please let us know!
Link to this post:
A frustrated user calls to inform you that your .NET application is running slow in production. Pop quiz hotshot, what do you do?
The most obvious choice would be to check system resource of your IIS web servers that run your application. For example, Performance Monitor (Perfmon) in Windows gives you visibility of how an application consumes server resource like CPU, memory, disk I/O and database connection pools. Unfortunately, Windows metrics and CLR counters simply tell you how resource is being consumed by an application, they don’t tell you what application component is responsible for that consumption. Application monitoring visibility must therefore go beyond traditional server metrics and health, they need to expose what application components are responsible for poor performance.
In addition to Perfmon you might also check:
- Windows Event Viewer
- Log files
- SQL Profiler
- Visual Studio Profiler
Visual Studio is the only viable option that really provides visibility into an application and its performance. The only limitation is that Visual Studio is really a profiler/debugger for development and test environments, it was never designed for production usage. Its safe to say there’s been a lack of free or commercial tools that will monitor .NET application performance out-of-the-box, in production. That is until now.
Introducing AppDynamics Lite for .NET
Today, we’re announcing AppDynamics Lite for .NET – the first completely free .NET application monitoring solution for production. This, in addition to our commercial solution AppDynamics Pro for .NET, which has already experienced significant success since its launch in July 2011.
Why release a free monitoring solution for .NET? Because we wanted to prove that monitoring .NET application performance in production can be simple, thru software that was designed to auto-discover, configure and monitor whats relevant in your .NET application, without you lifting a finger. Our mission at AppDynamics is to deliver maximum monitoring visibility thru minimal effort.
For example, 2 minutes after downloading and installing AppDynamics Lite for .NET you might see something like this:
Application Mapping, Business Transaction Monitoring and Diagnostics for Free!
Instead of looking at Server metrics, Events and SQL profiles, AppDynamics Lite will automatically discover and visualize your .NET application. Showing all IIS web server interactions (e.g. Web services, databases, LDAP and message queus), business transactions (user requests) and associated performance metrics. End users experience business transactions, with AppDynamics Lite you now have complete business transaction context to monitor and troubleshoot what your end users experience.
For example, in the screenshot above we can drill-down on the “Update Orders” business transaction to see why it was taking 7.9 seconds:
After drilling down we now see a view showing all bad requests (known as snapshots) that were captured by AppDynamics Lite. Snapshots represent an individual execution of a business transaction that relates to a user. You can see the response time of snapshots shown in the above screenshot differ. This means some user requests were OK, some threw exceptions (red icons) and others stalled (exclamation icons).
From the above snapshots view its possible to drill-down on any snapshot to understand its code execution and latency, as well as identifying the actual root cause behind slow performance:
In the above screenshot, AppDynamics Lite provides a view showing the code execution latency (call graph) of application classes and methods that were invoked by the slow snapshot (business transaction). Its worth stating that this visibility is available in production with minimal impact to the application running. Notice that the majority of total response time spent in this “Update Order” business transaction was spent on two ADO.NET calls which took ~3.5 seconds each.
From the above view we can see the associated SQL calls by either clicking on the ADO.NET link (next to each call) or by clicking the “SQL Calls” tab to the left of the call graph. Here we see the two SQL statements responsible for the 7.5 second response time. We can now confirm that the root cause of “Update Orders” business transaction taking 7.5 seconds was data access and two offending SQL queries.
Pro-Active Alerting for Free!
AppDynamics Lite also has pro-active dashboard and alerting capabilities. This means you can continuously monitor the performance of your application and business transactions in real-time, and be alerted via email when performance deviates from its normal baseline or threshold. For example, below is a screenshot showing a simple dashboard which has been created with four alerts (Overall App Response Time, Overall App Errors/min, Get Product Response Time and Login Response Time). You can see that the Overall App Response Time is breaching its 1 second threshold, in this scenario an alert would be fired to development or operations so they can begin troubleshooting.
All these features are completely free and will run all day in production 24/7! AppDynamics Lite is limited to a single IIS web server, with AppDynamics Pro becoming the choice for applications that are distributed across multiple IIS web servers and services.
App Man.Link to this post:
There are many technical articles/blogs on the web that jump straight into areas of .NET code you can instantly optimize and tune. Before we get to some of those areas, it’s good to take a step back and ask yourself, “Why am I here?” Are you interested in tuning your app, which is slow and keeps breaking, or are you looking to prevent these things from happening in the future? When you start down the path of Application Performance Management (APM), it is worth asking yourself another important question – what is success? This is especially important if you’re looking to tune or optimize your application. Knowing when to stop is as important as knowing when to start.
A single code or configuration change can have a dramatic impact on your application’s performance. It’s therefore important that you only change or tune what you need to – less is often more when it comes to improving application performance. I’ve been working with customers in APM for over a decade and it always amazes me how dev teams will browse through packages of code and rewrite several classes/methods at the same time with no real evidence that what they are changing will actually make an impact. For me, I learned the most about writing efficient code in code reviews with peers, despite how humbling it was. What I lacked the most as a developer, though, was visibility into how my code actually ran in a live production environment. Tuning in development and test is not enough if the application still runs slow in production. When manufacturers design and build cars they don’t just rely on simulation tests – they actually monitor their cars in the real world. They drive them for hundreds of thousands of miles to see how their cars will cope in all conditions they’ll encounter. It should be the same with application performance. You can’t simulate every use case or condition in dev and test, so you must understand your application performance in the real world.