There are a lot of great solutions out there that do fantastic things to help improve application performance and quickly get to the root cause of application performance issues.
Some of the great features typically available in APM tools are:
- Monitor your code in production to show you areas for improvement
- Track transactions across tiers to show where bottlenecks exist
- Detect long running SQLs within your databases
- Get intelligent advance alerting when different thresholds are exceeded or are about to be exceeded
- And many more…
There are obviously many reasons that you would like to improve your application, know when things go wrong, where they went wrong, etc.
The main question is – How does that help me assure my application performance?
Sadly – it doesn’t.
At the end of the day, if we crossed a threshold it means that something is already broken in the application. Even if we know the line of code that needs to be fixed, it is usually impossible to immediately fix it and role it to production.
We mentioned before the root problem with the threshold based alerting approach. We’ve also discussed the complexity of tuning the application control knobs. The good news is that there are things that you can fix immediately, even inside the application space. Typically configurations such as heap size, thread pool size, etc.
In release 5.0 we introduced a new approach towards Application Performance. Application Performance Control. Our Application Control Module enables you to take actions that assure application performance in real time. Taking into consideration not only what the application server demands but also what the underlying infrastructure is capable of supplying in order to meet that demand.
For example, VMTurbo recommends increasing the thread pool and the heap size for a specific application server:
But is that safe? If I increase the thread pool, the application server will consume more CPU from the virtual machine it is running on. VMTurbo recognizes that and knows that it should provide more vCPUs to the VM:
But is that safe? VMTurbo recognizes that the current physical machine the VM is sitting on does not have enough compute power to meet the demand from the VM but a different physical machine in the environment does. Hence it moves other CPU demanding VM from the current host, to another one, where the CPU is available freeing up resources for the demanding application and assuring performance:
And this goes on... all the way to the chassis this physical machine is sitting on.
Which brings up an interesting point – how can you make decisions on the application without understanding the underlying infrastructure that the application is running on? Should you really increase the heap size if there is not enough memory available in your environment to support the change? Your application won’t even come up… An OutOfMemoryError is significantly worse than running slow.
A typical problem in the virtualized world is right sizing JVMs. Read all about it here. Typically to right size VMs you use Active Memory. In the case of JVMs, this might give you the wrong decisions. Using VMTurbo, you can understand the actual memory demand of a JVM and make sure you do not undersize your VMs to the point of performance problems, while at the same time you do not overprovision memory and waste resources in the system.
To summarize, using VMTurbo’s Application Control Module you can extend control into the application layer to:
1. Take real time actions to make sure your application server has the resources it needs to operate
2. Make decisions based on demand and supply from the application down to the underlying infrastructure
3. Right size your VMs running JVM application servers
The application layer, like many others, is another dimension that helps refine the desired state of your datacenter – where application performance is assured while efficiency is maximized. VMTurbo is the only control system for the virtualized data center that will continuously drive your environment to a healthy state.
Read more about application performance challenges here.