The AppD Approach: One Size Agent Doesn’t Fit All

When it comes to deploying agents for your APM solution, a one-size-fits-all approach may sound tempting, but like most one-size solutions, they simply can’t hold up to the countless scenarios encountered in today’s enterprises.  We take a different approach at AppDynamics, providing intelligent agents tailored to your specific platform that provide a highly precise level of monitoring and analytics, and do so with much lower overhead. We’ve spent the last 10 years creating and perfecting agents that can easily be deployed and managed at the scale required by today’s enterprise.

The core of any APM solution is the agent. It’s responsible for collecting and reporting all relevant data and metrics. But in order for an agent to provide the deepest level of insights, it needs to be extremely intelligent. It must understand the platform with which it’s interacting, which data points are the most relevant, and how to obtain them. And these requirements and interactions will change from one platform to the next.

For example, Java has many frameworks which expose different entry points, is multithreaded, and supports a wide variety of message queues and databases. In contrast, Node.js is single-threaded, utilizing an event-loop to handle callbacks, and is often integrated with a different ecosystem of databases and message queues (though of course there are overlaps). Our Java and Node.js agents understand how to interact with each of these platforms, taking advantage of their unique interfaces to gather the most critical metrics from your applications. It’s these highly-intelligent agents that allowed us to help DirectTV adopt an APM solution covering 6,000 physical and virtual servers running a mix of Windows, Linux, and HP-UX, as well as applications built using Java, .NET, PHP, and Node.js.

Another crucial consideration when deploying APM agents is overhead, as it’s critical an agent not add costs by consuming too many resources and in turn be disruptive to production applications. This becomes even more crucial for enterprises where tens of thousands of agents might be deployed across thousands of servers. By utilizing an agent-level baseline, and continuing to monitor and update this baseline over time, AppDynamics’ agents are able to capture a small amount of standard data under normal circumstances, keeping the overhead extremely low. When a deviation is detected from what the agent considers to be normal, it dives deeper, capturing a detailed report of what is happening on the system at that moment to ensure your team will have everything required to troubleshoot and resolve the issue.

Today’s modern enterprises utilize every tool at their disposal to provide the best possible experience to their customers, and require an APM solution that works with all of them. AppDynamics understands this need and has built our agents to easily integrate into the latest deployment and management tools including Chef, Puppet, and Ansible, making it easy to deploy agents quickly. Consider Cisco (now our parent company but also one of our early customers) who was able to successfully deploy 15,000 AppDynamics agents across 2,000 physical servers and 5,000 virtual machines, serving more than 200 applications in 23 data centers – all in just one week!

We also know that security is extremely important, and that root access is something that SecOps teams tightly control. With this in mind, our agents are designed to perform their monitoring and information gathering without requiring root access.

Ready to find out the difference an intelligent APM agent can make for your business? Start a free trial today!

Rob is a Product Manager at AppDynamics, working with hundreds of customers over the last five years who use AppDynamics to gain visibility into their applications. Prior to AppDynamics, Rob worked in various roles at different technology companies like Akamai Technologies and Microsoft.

APM vs NPM. Round One.

Another three-letter acronym I see frequently mixed in with APM is NPM which stands for Network Performance Management. At first glance they look very similar. The distinction appears very subtle with just a one letter difference, but it speaks volumes because their core technologies and approaches to monitoring application performance are fundamentally different.

Application Performance Management tools typically use agents that live in the application run-time which capture performance details of how application logic computes across the application infrastructure.

In contrast, Network Performance Monitoring tools are agent-less appliances that sit on the network analyzing content and traffic by capturing packets flowing through the network. They can measure response times and find errors for your applications by understanding the wire protocols across the application tiers. Like agent based APM solutions, they can automatically discover your application topology, but NPM tools lack deep code-level diagnostics which is paramount to helping App Ops and Dev teams solve problems. Here’s why.

Imagine your application’s architecture is FedEx providing package delivery services to it’s customers in a timely manner. If you were to apply the concept of network monitoring to this analogy, using an NPM tool would help track how long it takes for packages to travel in transit from one hub to the next, examining it’s contents and the expected arrival time to it’s final destination.

Now let’s say that a package was being sent from Paris to Los Angeles but hit a snag at the London hub along the way. Operations at London came to a screeching hault for some inexplicable reason and your task is to figure out why and how to fix it ASAP so operations are running smooth again. In this case, APM is the favorable solution over NPM here. APM tools not only empower you with the ability to see how long it takes for your package to travel to different locations, but also how the package is processed at the facility and why operations came to a standstill. At this juncture, you probably wouldn’t even care to analyze the package’s contents since you already know what’s inside and it’s still in London.

When applying this concept to the world of business applications, NPM tools won’t provide you with visibility into application logic inefficiencies, especially when experiencing a performance issue or service level breach to key business transactions. NPM performance metrics are derived from captured packets and the network protocols the servers support, but if you’re making inefficient, iterative business logic calls in your code, how will capturing and analyzing packets help you triage the problem? Its the same story for identifying the root cause of memory leaks or thread synchronization issues; execution and visibility like this occurs at the application layer, not at the network layer. Thus, I would argue that NPM compliments APM but doesn’t serve as a viable replacement.

Now before I go enumerating my theories as to why I see this trend, let me just say while I respect their hustle, nice try but not quite. While scouring the web I found many NPM companies trying to crash the popular APM party by marketing their network performance monitoring utilities as an application monitoring and management solution. It can be confusing for a first time buyer trying to evaluate APM tools when you see NPM companies using phrases like, “network-based APM” or “gather data already on your network” in their product messaging.

One of the reasons for this messaging is because NPM is an immensely crowded market. Here’s a list of NPM tools compiled by some IT folks at Stanford. There’s over 300 network monitoring tools, and that’s only going back five years to 2007!! Take your pick. Second, applications and the tools to monitor their performance and availability speaks to customers at a higher level from a technical and business perspective. If I’m in charge of some transaction intensive application, my customers are directly interfacing with the Application Layer in order to complete business transactions which takes place at the highest layer on the stack. Customers aren’t 5-6 levels deep at the Network Layer interacting with packets or the routers and switches they pass through.

By the way, have you seen Gartner’s APM spend analysis? It’s a $2 billion market and growing. This most certainly is a valid reason why NPM solutions are now positioning themselves as an APM solution to customers.

If you have absolutely nothing to monitor any part of your applications infrastructure, then something is better than nothing. However, at some point you’ll need better visibility at the application layer regardless how fast packets are traveling through the pipes. NPM won’t necessarily provide the range of visibility your App Ops and Dev teams need to diagnose, troubleshoot, and idenfity problem root causes.

Those who live day in and day out the networking world will naturally gravitate to what they’re familiar with, but if you haven’t ventured out into the evolving APM market, I highly recommend it. Even though you can achieve some level of performance monitoring with NPM, you’ll find yourself running into limitations in application visibility pretty quick. But as the old saying goes, “If all you have is a hammer, then everything looks like a nail.”

I’m curious to know what are your thoughts are. Which class of tools would you choose? Why?


Agent Intelligence

How intelligent is your monitoring agent?

The agent should not do too much processing locally to ensure minimal impact to application performance by utilizing the smallest CPU and memory footprint possible. On the other hand, offloading some processing to the agent results in less network traffic and more scalability from the monitoring Mgmt Server.