Our fundamental unit of performance data is the trace, an incredibly rich
view into the performance of an individual request moving through your web
application. Given all this data and the diversity of the contents of any
individual trace, it’s important to have an interface for understanding
what exactly was going on when a request was served. How did it get handled?
What parts were slow, and what parts were anomalous?
Over the past year, the TraceView team has been listening to your thoughts on
this topic as well as hatching some of our own. Today we get to share the
fruit of our labors: Trace Details, redesigned.
RUM, meet trace details.
Trace details and RUM are old friends, so it’s no surprise they’re here
together now. But there are a few details that might be surprising to you:
Using full-page caching (eg. Varnish, WP Super Cache, …)? Now you can
measure ... (more)
Are you using Celery to process Python back-end tasks asynchronously? Have
you wanted to get insight into their resource consumption and efficiency?
Here’s a few useful ways to get insight into Celery performance when
A simple celery task
For a quick review, Celery lets you turn any python method into an
asynchronous task. Here’s a simple one:
1 2 3 4 from celery.task import task @task def add(x, y): return x + y
Let’s trace Celery
We’ll start with the good stuff. In the latest release of our Python
instrumentation, oboeware-1.0, we have an updated API that makes ... (more)
In part 1 of this article, we covered writing web app load tests using
multi-mechanize. This post picks up where the other left off and will
discuss how to gather interesting and actionable performance data from a
load-test, using (of course) Traceview as an example.
The big problem we had after writing load tests was that timing data gathered
by multi-mechanize is inherently external to the application. This means it
can tell us the response times of requests when the app is under load but
doesn't identify bottlenecks or configuration problems. So we need to be
gathering a bi... (more)
We’re excited to announce three important changes to our TraceView pricing
First, and most importantly, we are launching a free tier! Project includes
all the data we collect on requests, hosts, service calls, JVMs and
everything else, and we’re giving it away, free forever. We want you to
have this, so we’ve packed everything you need into this version to help
you get as much visibility into production as possible.
Second, we’re changing the name of Tracelytics to TraceView. Since
Tracelytics joined AppNeta in June of last year, there has been a lot of work
under ... (more)
Many types of performance problems can result from the load created by
concurrent users of web applications, and all too often these scalability
bottlenecks go undetected until the application has been deployed in
production. Load-testing, the generation of simulated user requests, is a
great way to catch these types of issues before they get out of hand. Last
month I presented about load testing with Canonical's Corey Goldberg at
the Boston Python Meetup last week and thought the topic deserved blog
discussion as well.
In this two-part series, I'll walk through generating lo... (more)