Get Into End User Experience with Real User Monitoring
by October 12, 2012

Filed under: Performance Monitoring

AppNeta no longer blogs on DevOps topics like this one.

Feel free to enjoy it, and check out what we can do for monitoring end user experience of the apps you use to drive your business at

We have always focused on helping our users track down and solve problems in the server side of web applications. Often, the most pernicious, expensive and difficult-to-optimize performance problems occur on the server side.

However, whenever we talked about our Full-Stack Application Tracing solution, we secretly had a broader vision—tracing is a means to an end, and the true end is helping developers optimize the end user experience. So, while much of the challenge may lie on the server side, in reality for well-functioning websites, most of the total latency actually occurs in end users’ browsers.

It was only a matter of time before our distributed tracing technology made the leap across the firewall and into the client browser, and we are excited to be on the verge of launching this for our customers!

Let’s take a look at both synthetic and real user monitoring in more detail.

Full stack Application Tracking 1

Getting Browser Visibility: The Synthetic Approach

There are many excellent tools available to examine client-side performance from a developer’s perspective on individual pageloads. Some of these tools include:

  • Built-in browser tools, like Chrome Inspector, that allow you to inspect, edit and debug the HTML, CSS and Javascript in a web page
  • Online tools, such as, that provide full analysis of you website’s speed

But for more in-depth insight into client-side performance, our own AppView Web solution provides detailed webpage test-style metrics coupled with full network analysis.  Find out if requests from the client to critical page resources are being held up by network problems on the path between you and your users.

All of the tools I’ve mentioned so far use synthetic monitoring — they require new requests to be generated from known environments. While they provide great detail for the pageloads they observe, they’re missing one very interesting item: real users.

Real User Browser Performance Data

Real user data helps web application owners and developers understand what their users are experiencing, where they are experiencing it and on which platforms. But how do you get that insight? The server-side TraceView approach of instrumenting the application environment — in this case web browsers — is probably not going to fly. But fortunately there’s a better way, and it involves JavaScript-based instrumentation.

The path has been paved by tools like Steve Souders’ Episodes and Yahoo’s Boomerang. With simple tags injected into end user pages, we can get performance data and much more. It’s been done before, but the value lies in the implementation, and ultimately in the data analysis. The best part is that in combination with our existing full-stack tracing, we can now stitch together a single request through the entire stack — from the browser all the way down into your database!

What Will I Learn With TraceView Real User Monitoring?

Here’s a few of the questions we’re answering for our early adopters right now:

  • What pages perform poorly — and is the latency in the server, network or browser?
  • How is my performance on mobile clients?
  • Are there browsers my application is not supporting well?
  • How does performance vary by region, and why?

We can’t wait to officially announce the launch of our RUM capabilities for TraceView, so keep an eye out for that over the next week!