Merge lp:~jcsackett/charmworld/better-stats-window into lp:~juju-jitsu/charmworld/trunk

[j.c.sackett]

Gets and displays review latency statistics in the review queue

This branch updates the review job and the charm-review view to calculate and
display latency information for review items.

charmworld/jobs/review.py
-------------------------
The review job has been altered in several ways.
* The global log has been done away with; the log created in `main` is passed
  into the other functions.
* A new function, `get_tasks_and_proposals` does the work of pulling items from
  Launchpad. Rather than pulling only those items to be displayed in the queue,
  it pulls all items so that latency can be properly calculated.
* The loops that created entries out of tasks and proposals first calculates the
  latency of any item created in the last 6 months as well as any item that is
  still open, even if it is older than 6 months. It then determines if an item
  is still in an "open" status and if so adds it to the review queue. These new
  rules supersede the "not in progress" rule used for juju doc proposals.
* Average, min, and max latency across all items is stored in a new collection,
  `review_queue_latency`. This collection is used to display the current queue
  latency as well as the trend in the charm-review view.

`get_tasks_and_proposals` is greedy--it grabs any possibly related proposal or
task. This is a tradeoff so we don't have to make two fetches for each sort of
item; one for anything created in the last six months, and another for anything
that is still open. In theory our greatest delay is connection time between
charmworld and launchpad--I'm open to arguments refuting that and altering this
to do fetches and create a set of all unique items found in the pair of each
requests from LP.

charmworld/views/tools.py
-------------------------
The charm-review view is still pretty simple, though it grabs a bit more data.
* The latency stats for the last six months are pulled from the new collection
  created in the review job. The most recent item is used to display the current
  min, max, and average. The set of data is used to display sparklines showing
  the 6 month history.
* A new function, `get_sparklines`, uses the stat data to create data strings
  that can be used by a new sparkline library.

charmworld/templates/review.pt and charmworld/static/jspark.js
--------------------------------------------------------------
The template has been updated to show the stats and the sparklines, and to
correct an odd oversight in showing the age of items.
* A new javascript file has been added--this is from resig's set of jquery
  tools. While D3 provides richer visualizations, it is very heavyweight and
  likley unecessary unless/until we're doing a lot more reporting on this site.
* The review queue loads the stats at the top of the listing, along with the
  currently displayed item count. The sparkline spans are automatically turned
  into graphics by jspark. If there is no data or insufficient data (i.e. only
  one data point) jspark removes the span.
* Age is now from date_created, not date_modified, for the entry. As an example
  of why, there is a 22 month old item that was being shown as only a few weeks
  old.

Other
-----
* test_tools.py has been moved into the test directory.
* The portion of `pretty_timedelta` that actually creates a human readable display
  has been broken out as `prettify_timedelta`; this is used both in
  `pretty_timedelta` and in the charm_review view to prettify the min, max, and
  mean latencies.
* tests have been added

[Aaron Bentley (abentley)]

Thanks. This looks good to me. In theory, I think we do want to do two fetches (open and <6 months old), so that the size of the response is proportional to the size of the data we want to evaluate. But I'm happy to wait until we need that.

review: Approve

[j.c.sackett (jcsackett)]

> Thanks. This looks good to me. In theory, I think we do want to do two
> fetches (open and <6 months old), so that the size of the response is
> proportional to the size of the data we want to evaluate. But I'm happy to
> wait until we need that.

Cool; I'll put in a comment in that function suggesting we want to re-evaluate it in time so the TODO doesn't get lost. Thanks!

[lp:~jcsackett/charmworld/better-stats-window]

327. By j.c.sackett on 2013-09-17

Link to bug

328. By j.c.sackett on 2013-09-17

Comment capturing future TODO in get_tasks_and_proposals

=== modified file 'charmworld/jobs/review.py'
--- charmworld/jobs/review.py	2013-06-12 20:49:47 +0000
+++ charmworld/jobs/review.py	2013-09-17 15:22:38 +0000
@@ -13,13 +13,13 @@
  - use dateutil date parsing instead of string comparsion.
  - merge proposals show target with series/branch.
 
-"""
+""" 
+import datetime
+import itertools
+import logging
 
 from launchpadlib.launchpad import Launchpad
-
-import itertools
 import pymongo
-import logging
 
 from charmworld.utils import (
     configure_logging,
@@ -30,10 +30,14 @@
 from utils import lock
 from utils import LockHeld
 
-log = None
-
-
-def update_review_queue(db):
+
+def get_tasks_and_proposals(log):
+    '''Gets review items (bugs and proposals) from launchpad.'''
+    # TODO: Eventually these single requests should be broken into two each:
+    # one to get anything created within the window, and one to get anything
+    # older than the window that is still open. Right now this is probably the
+    # more performant way to go about it, but that's going to change as the data
+    # outside of our window gets larger.
     with Timer() as timer:
         lp = Launchpad.login_anonymously('charm-tools',
                                          'production',
@@ -45,66 +49,91 @@
         charm_contributors = lp.people['charm-contributors']
 
     log.debug("lp login time %0.2f", timer.duration())
-    bug_statuses = [
-        'New', 'Confirmed', 'Triaged', 'In Progress', 'Fix Committed']
 
     with Timer() as timer:
         bugs = charm.searchTasks(
             tags=['new-formula', 'new-charm'],
-            tags_combinator="Any",
-            status=bug_statuses)
+            tags_combinator="Any")
         # Best practice  dictates that charmers be subscribed to all bugs
         # and merge proposals for official source package branches.
-        charmers_bugs = charmers.searchTasks(status=bug_statuses)
-        proposals = charmers.getRequestedReviews(status="Needs review")
-        contributor_proposals = charm_contributors.getRequestedReviews(
-            status="Needs review")
+        charmers_bugs = charmers.searchTasks()
+        proposals = charmers.getRequestedReviews()
+        contributor_proposals = charm_contributors.getRequestedReviews()
 
         juju = lp.projects['juju']
         doc_proposals = [mp for mp in juju.getMergeProposals()
                          if mp.target_branch_link.endswith("~juju/juju/docs")]
 
     log.debug("lp query time %0.2f", timer.duration())
-    doc_proposals = [mp for mp in doc_proposals if not mp.queue_status in (
-        'Work in progress',)]
-
-    r_queue = list()
-    for task in itertools.chain(bugs, charmers_bugs):
-        entry = {
-            'date_modified': task.bug.date_last_updated,
-            'date_created': task.date_created,
-            'summary': task.title.split('"')[1].strip(),
-            'item': task.web_link,
-            'status': task.status,
-        }
-        r_queue.append(entry)
-
-    for proposal in itertools.chain(proposals,
-                                    contributor_proposals,
-                                    doc_proposals):
-
-        parts = proposal.target_branch_link.rsplit('/', 3)
-        if parts[-1] == "trunk":
-            parts.pop(-1)
-
-        target = "/".join(parts[2:])
-        origin = "/".join(proposal.source_branch_link.rsplit('/', 3)[1:])
-
-        num_comments = proposal.all_comments.total_size
-        if num_comments != 0:
-            last_modified = proposal.all_comments[
-                num_comments - 1].date_created
-        else:
-            last_modified = proposal.date_created
-
-        entry = {
-            'date_modified': last_modified,
-            'date_created': proposal.date_created,
-            'summary': "Merge for %s from %s" % (target, origin),
-            'item': proposal.web_link,
-            'status': proposal.queue_status,
-        }
-        r_queue.append(entry)
+    return (itertools.chain(bugs, charmers_bugs),
+       itertools.chain(proposals, contributor_proposals, doc_proposals))
+
+
+def update_review_queue(db, tasks, proposals, log):
+    '''Updates the review queue information.'''
+    bug_statuses = [
+        'New', 'Confirmed', 'Triaged', 'In Progress', 'Fix Committed']
+    proposal_statuses = ['Needs review', 'Needs fixing', 'Needs information']
+    now = datetime.datetime.utcnow()
+    window = now - datetime.timedelta(days=180) # 6 month window for latency
+
+    r_queue = []
+    latencies = []
+    for task in tasks:
+        if (task.date_created.replace(tzinfo=None) >= window or
+            task.status in bug_statuses):
+            if task.date_confirmed:
+                latency = task.date_confirmed - task.date_created
+            else:
+                # Now has been calculated in UTC, and LP returns UTC TZ datetimes.
+                # We can safely remove the TZ, letting us get the timedelta.
+                latency = now - task.date_created.replace(tzinfo=None)
+            latencies.append(latency.total_seconds())
+
+        if task.status in bug_statuses:
+            entry = {
+                'date_modified': task.bug.date_last_updated,
+                'date_created': task.date_created,
+                'summary': task.title.split('"')[1].strip(),
+                'item': task.web_link,
+                'status': task.status,
+            }
+            r_queue.append(entry)
+
+    for proposal in proposals:
+        if (proposal.date_created.replace(tzinfo=None) >= window or
+            proposal.queue_status in proposal_statuses):
+            if proposal.date_reviewed:
+                latency = proposal.date_reviewed - proposal.date_review_requested
+            else:
+                # Now has been calculated in UTC, and LP returns UTC TZ datetimes.
+                # We can safely remove the TZ, letting us get the timedelta.
+                latency = now - proposal.date_review_requested.replace(tzinfo=None)
+            latencies.append(latency.total_seconds())
+
+        if proposal.queue_status in proposal_statuses:
+            parts = proposal.target_branch_link.rsplit('/', 3)
+            if parts[-1] == "trunk":
+                parts.pop(-1)
+            target = "/".join(parts[2:])
+            origin = "/".join(proposal.source_branch_link.rsplit('/', 3)[1:])
+
+            num_comments = proposal.all_comments.total_size
+            if num_comments != 0:
+                last_modified = proposal.all_comments[
+                    num_comments - 1].date_created
+            else:
+                last_modified = proposal.date_created
+
+            entry = {
+                'latency': latency.total_seconds(),
+                'date_modified': last_modified,
+                'date_created': proposal.date_created,
+                'summary': "Merge for %s from %s" % (target, origin),
+                'item': proposal.web_link,
+                'status': proposal.queue_status,
+            }
+            r_queue.append(entry)
 
     # Drop old collection
     log.info(
@@ -113,11 +142,24 @@
 
     # Bulk insert
     log.info("Updating review queue (%d items)" % len(r_queue))
-    db['review_queue'].insert(r_queue)
-
+    if (r_queue != []):
+        # Needs check as bulk insert of an empty list is prohibited
+        db['review_queue'].insert(r_queue)
+
+    # Get stats:
+    stats = latency_stats(latencies)
+    if stats:
+        stats['date'] = now
+        db.review_queue_latency.insert(stats)
+
+def latency_stats(queue):
+    if queue != []:
+        min_latency = min(queue)
+        mean_latency = sum(queue)/len(queue)
+        max_latency = max(queue)
+        return {'min': min_latency, 'max': max_latency, 'mean': mean_latency}
 
 def main():
-    global log
     configure_logging()
     log = logging.getLogger("charm.review")
     c = pymongo.Connection(MONGO_URL, safe=True)
@@ -126,7 +168,8 @@
     try:
         with lock('ingest-review',
                   int(settings['script_lease_time']) * 60, db, log):
-            update_review_queue(db)
+            tasks, proposals = get_tasks_and_proposals(log)
+            update_review_queue(db, tasks, proposals, log)
     except LockHeld, error:
         log.warn(str(error))
 

=== added file 'charmworld/jobs/tests/test_review.py'
--- charmworld/jobs/tests/test_review.py	1970-01-01 00:00:00 +0000
+++ charmworld/jobs/tests/test_review.py	2013-09-17 15:22:38 +0000
@@ -0,0 +1,110 @@
+# Copyright 2012, 2013 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+import datetime
+import logging
+
+from charmworld.jobs.review import update_review_queue
+from charmworld.testing import factory
+from charmworld.testing import MongoTestBase
+
+
+NOW = datetime.datetime.now()
+YESTERDAY = NOW - datetime.timedelta(1)
+TWO_DAYS = NOW - datetime.timedelta(2)
+
+
+class MockBug:
+    date_last_updated = NOW
+
+
+class MockTask:
+
+    def __init__(self, confirmed=False):
+        self.date_created = TWO_DAYS
+        self.title = u'Bug #0 in a collection: "A bug task"'
+        self.web_link = "http://example.com"
+        self.bug = MockBug()
+        if confirmed:
+            self.status = "Confirmed"
+            self.date_confirmed = YESTERDAY 
+        else:
+            self.date_confirmed = None
+            self.status = "New"
+
+
+class MockCommentCollection:
+    total_size = 0
+
+
+class MockProposal:
+
+    def __init__(self, reviewed=False):
+        base = 'https://api.launchpad.net/devel/'
+        self.target_branch_link = base + '~charmers/charms/precise/foo/trunk' 
+        self.source_branch_link = base + '~bar/charms/precise/foo/fnord'
+        self.all_comments = MockCommentCollection()
+        self.date_review_requested = TWO_DAYS
+        self.date_created = TWO_DAYS
+        self.web_link = 'http://example.com'
+        if reviewed:
+            self.date_reviewed = YESTERDAY
+            self.queue_status = "Approved" 
+        else:
+            self.date_reviewed = None
+            self.queue_status = "Needs review" 
+
+
+class ReviewTest(MongoTestBase):
+    
+    def test_review_handles_empty_queue(self):
+        self.db.review_queue.insert([{'foo': 'bar'}])
+        log = logging.getLogger('foo')
+        update_review_queue(self.db, [], [], log)
+        self.assertEqual(0, self.db.review_queue.count())
+
+    def test_review_handles_bugs(self):
+        log = logging.getLogger('foo')
+        update_review_queue(self.db, [MockTask()], [], log)
+        self.assertEqual(1, self.db.review_queue.count())
+        item = self.db.review_queue.find_one()
+        self.assertEqual(NOW.date(), item['date_modified'].date())
+        self.assertEqual(TWO_DAYS.date(), item['date_created'].date())
+        self.assertEqual('A bug task', item['summary'])
+        self.assertEqual('http://example.com', item['item'])
+        self.assertEqual('New', item['status'])
+
+    def test_review_handles_proposals(self):
+        log = logging.getLogger('foo')
+        update_review_queue(self.db, [], [MockProposal()], log)
+        self.assertEqual(1, self.db.review_queue.count())
+        item = self.db.review_queue.find_one()
+        self.assertEqual(TWO_DAYS.date(), item['date_modified'].date())
+        self.assertEqual(TWO_DAYS.date(), item['date_created'].date())
+        self.assertEqual('Merge for foo from precise/foo/fnord', item['summary'])
+        self.assertEqual('http://example.com', item['item'])
+        self.assertEqual('Needs review', item['status'])
+
+    def test_review_calculates_latency(self):
+        log = logging.getLogger('foo')
+        self.assertEqual(0, self.db.review_queue_latency.count())
+        update_review_queue(self.db, [], [MockProposal(True)], log)
+        self.assertEqual(1, self.db.review_queue_latency.count())
+        item = self.db.review_queue_latency.find_one()
+        self.assertEqual(NOW.date(), item['date'].date())
+        self.assertEqual(1, datetime.timedelta(seconds=item['max']).days)
+        self.assertEqual(1, datetime.timedelta(seconds=item['mean']).days)
+        self.assertEqual(1, datetime.timedelta(seconds=item['min']).days)
+
+    def test_review_discards_closed_bugs(self):
+        tasks = [MockTask(), MockTask()]
+        tasks[0].status = 'Fix released'
+        log = logging.getLogger('foo')
+        update_review_queue(self.db, tasks, [], log)
+        self.assertEqual(1, self.db.review_queue.count())
+
+    def test_review_discards_approved_proposals(self):
+        proposals = [MockProposal(), MockProposal()]
+        proposals[0].queue_status = 'Approved'
+        log = logging.getLogger('foo')
+        update_review_queue(self.db, [], proposals, log)
+        self.assertEqual(1, self.db.review_queue.count())

=== added file 'charmworld/static/jspark.js'
--- charmworld/static/jspark.js	1970-01-01 00:00:00 +0000
+++ charmworld/static/jspark.js	2013-09-17 15:22:38 +0000
@@ -0,0 +1,107 @@
+/**
+ * Javascript Sparklines Library
+ * Written By John Resig
+ * http://ejohn.org/projects/jspark/
+ * 
+ * This work is tri-licensed under the MPL, GPL, and LGPL:
+ * http://www.mozilla.org/MPL/
+ * 
+ * To use, place your data points within your HTML, like so:
+ * <span class="sparkline">10,8,20,5...</span>
+ *
+ * in your CSS you might want to have the rule:
+ * .sparkline { display: none }
+ * so that non-compatible browsers don't see a huge pile of numbers.
+ *
+ * Finally, include this library in your header, like so:
+ * <script language="javascript" src="jspark.js"></script>
+ */
+
+addEvent( window, "load", function() {
+  var a = document.getElementsByTagName("*") || document.all;
+
+  for ( var i = 0; i < a.length; i++ )
+    if ( has( a[i].className, "sparkline" ) )
+      sparkline( a[i] );
+} );
+
+function has(s,c) {
+  var r = new RegExp("(^| )" + c + "\W*");
+  return ( r.test(s) ? true : false );
+}
+
+function addEvent( obj, type, fn ) {
+  if ( obj.attachEvent ) {
+    obj['e'+type+fn] = fn;
+    obj[type+fn] = function(){obj['e'+type+fn]( window.event );}
+    obj.attachEvent( 'on'+type, obj[type+fn] );
+  } else
+    obj.addEventListener( type, fn, false );
+}
+
+function removeEvent( obj, type, fn ) {
+  if ( obj.detachEvent ) {
+    obj.detachEvent( 'on'+type, obj[type+fn] );
+    obj[type+fn] = null;
+  } else
+    obj.removeEventListener( type, fn, false );
+}
+
+
+function sparkline(o) {
+  var p = o.innerHTML.split(',');
+  while ( o.childNodes.length > 0 )
+    o.removeChild( o.firstChild );
+
+  var nw = "auto";
+  var nh = "auto";
+  if ( window.getComputedStyle ) {
+    nw = window.getComputedStyle( o, null ).width;
+    nh = window.getComputedStyle( o, null ).height;
+  }
+
+  if ( nw != "auto" ) nw = nw.substr( 0, nw.length - 2 );
+  if ( nh != "auto" ) nh = nh.substr( 0, nh.length - 2 );
+
+  var f = 2;
+  var w = ( nw == "auto" || nw == 0 ? p.length * f : nw - 0 );
+  var h = ( nh == "auto" || nh == 0 ? "1em" : nh );
+
+  var co = document.createElement("canvas");
+
+  if ( co.getContext ) o.style.display = 'inline';
+  else return false;
+
+  co.style.height = h;
+  co.style.width = w;
+  co.width = w;
+  o.appendChild( co );
+
+  var h = co.offsetHeight;
+  co.height = h;
+
+  var min = 9999;
+  var max = -1;
+
+  for ( var i = 0; i < p.length; i++ ) {
+    p[i] = p[i] - 0;
+    if ( p[i] < min ) min = p[i];
+    if ( p[i] > max ) max = p[i];
+  }
+
+  if ( co.getContext ) {
+    var c = co.getContext("2d");
+    c.strokeStyle = "red";
+    c.lineWidth = 1.0;
+    c.beginPath();
+
+    for ( var i = 0; i < p.length; i++ ) {
+      if ( i == 0 )
+        c.moveTo( (w / p.length) * i, h - (((p[i] - min) / (max - min)) * h) );
+      c.lineTo( (w / p.length) * i, h - (((p[i] - min) / (max - min)) * h) );
+    }
+
+    c.stroke();
+    o.style.display = 'inline';
+  }
+}

=== modified file 'charmworld/templates/review.pt'
--- charmworld/templates/review.pt	2013-09-05 09:47:11 +0000
+++ charmworld/templates/review.pt	2013-09-17 15:22:38 +0000
@@ -1,9 +1,22 @@
 <html tal:define="main load: main.pt" metal:use-macro="main.macros['page']">
   <body>
+    <metal:block fill-slot="js_include">
+      <script type="text/javascript"
+        src="${request.static_url('charmworld:static/jspark.js')}">
+      </script>
+    </metal:block>
 <metal:block metal:fill-slot="content">
   <div class="row no-border">
     <h1>Charmers Review Queue</h1>
-    <p class="note">${len(queue)} reviews</p>
+    <p class="note">
+      <strong>Items:</strong> ${len(queue)}
+      <strong>Max wait time:</strong> ${max}
+      <span class="sparklinesline">${sparklines['maxes']}</span>
+      <strong>Average wait time:</strong> ${mean}
+      <span class="sparklinesline">${sparklines['means']}</span>
+      <strong>Min wait time:</strong> ${min}
+      <span class="sparklinesline">${sparklines['mins']}</span>
+    </p>
     <table>
       <thead>
         <tr>
@@ -15,7 +28,7 @@
         </tr>
       </thead>
       <tr tal:repeat="item queue">
-        <td tal:content="age_format(item['date_modified'])"></td>
+        <td tal:content="age_format(item['date_created'])"></td>
         <td tal:content="item['date_created'].strftime('%Y/%m/%d')"></td>
         <td tal:content="item['date_modified'].strftime('%Y/%m/%d')"></td>
         <td>

=== renamed file 'charmworld/test_utils.py' => 'charmworld/tests/test_utils.py'
=== modified file 'charmworld/utils.py'
--- charmworld/utils.py	2013-09-09 13:45:45 +0000
+++ charmworld/utils.py	2013-09-17 15:22:38 +0000
@@ -28,6 +28,21 @@
 )
 
 
+def prettify_timedelta(diff):
+    """Return a prettified time delta, suitable for pretty printing."""
+    age_s = int(diff.days * 86400 + diff.seconds)
+
+    for u, template in _units:
+        r = float(age_s) / float(u)
+        if r >= 1.9:
+            r = int(round(r))
+            v = template % r
+            if r > 1:
+                v += "s"
+            return v
+    return ''
+
+
 def pretty_timedelta(time1, time2=None):
     """Calculate time delta between two `datetime` objects.
     (the result is somewhat imprecise, only use for prettyprinting).
@@ -41,19 +56,7 @@
         raise ValueError('The start date is before the end date.')
 
     diff = time2 - time1
-    age_s = int(diff.days * 86400 + diff.seconds)
-
-#    if age_s <= 60 * 1.9:
-#        return ngettext('%(num)i second', '%(num)i seconds', age_s)
-    for u, template in _units:
-        r = float(age_s) / float(u)
-        if r >= 1.9:
-            r = int(round(r))
-            v = template % r
-            if r > 1:
-                v += "s"
-            return v
-    return ''
+    return prettify_timedelta(diff)
 
 
 def configure_logging():

=== modified file 'charmworld/views/tests/test_tools.py'
--- charmworld/views/tests/test_tools.py	2013-09-05 09:47:11 +0000
+++ charmworld/views/tests/test_tools.py	2013-09-17 15:22:38 +0000
@@ -4,11 +4,15 @@
 __metaclass__ = type
 
 
-from datetime import datetime
+from datetime import (
+    datetime,
+    timedelta,
+)
 
 from charmworld.models import Charm
 from charmworld.views.tools import (
     charm_store_missing,
+    get_sparklines,
     proof_errors,
 )
 from charmworld.testing import factory
@@ -31,6 +35,16 @@
 
 class TestReviews(WebTestBase):
 
+    def test_sparklines(self):
+        stats = [
+            {'min': 0, 'max':10, 'mean': 5},
+            {'min': 4, 'max': 6, 'mean': 5.5},
+            {'min': 2, 'max': 20, 'mean': 12}]
+        sparklines = get_sparklines(stats)
+        self.assertEqual('0,4,2', stats['mins'])
+        self.assertEqual('10,6,20', stats['maxes'])
+        self.assertEqual('5,5.5,12', stats['mins'])
+
     def test_last_modified_formatting(self):
         self.db.review_queue.save(
             factory.make_review_entry(date_modified=datetime(2012, 1, 2)))
@@ -52,6 +66,25 @@
              for heading, col in zip(headings, columns)]
         self.assertEqual(['2012/01/02', '2012/01/03'], colmap['Last Modified'])
 
+    def test_empty_sparklines(self):
+        sparklines = get_sparklines([])
+        self.assertEqual('', sparklines['maxes'])
+        self.assertEqual('', sparklines['mins'])
+        self.assertEqual('', sparklines['means'])
+
+    def test_single_sparklines(self):
+        sparklines = get_sparklines([{'max': 1, 'min': 2, 'mean': 3}])
+        self.assertEqual('1', sparklines['maxes'])
+        self.assertEqual('2', sparklines['mins'])
+        self.assertEqual('3', sparklines['means'])
+
+    def test_sparklines(self):
+        sparklines = get_sparklines([
+            {'max': 1, 'min': 1, 'mean': 1},
+            {'max': 1, 'min': 2, 'mean': 3}])
+        self.assertEqual('1,1', sparklines['maxes'])
+        self.assertEqual('1,2', sparklines['mins'])
+        self.assertEqual('1,3', sparklines['means'])
 
 class CharmStoreMissingTestCase(ViewTestBase):
 

=== modified file 'charmworld/views/tools.py'
--- charmworld/views/tools.py	2013-09-03 14:15:49 +0000
+++ charmworld/views/tools.py	2013-09-17 15:22:38 +0000
@@ -1,5 +1,7 @@
 # Copyright 2012, 2013 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
+import datetime
+import math
 
 import pymongo
 from pyramid.view import view_config
@@ -15,6 +17,21 @@
 REPORT_CACHE = 180
 
 
+def get_sparklines(stats):
+    mins = []
+    maxes = []
+    means = []
+    for s in stats:
+        mins.append(str(s['min']))
+        means.append(str(s['mean']))
+        maxes.append(str(s['max']))
+
+    return {
+        'mins': ','.join(mins),
+        'means': ','.join(means),
+        'maxes': ','.join(maxes)}
+
+
 @cached_view_config(
     route_name="tools",
     renderer="charmworld:templates/tools.pt")
@@ -43,7 +60,27 @@
     queue = list(
         request.db.review_queue.find(
             sort=[('date_modified', pymongo.ASCENDING)]))
-    return {'queue': queue, 'age_format': utils.pretty_timedelta}
+    stats = list(request.db.review_queue_latency.find(
+        date={"$gte": datetime.datetime.utcnow() - datetime.timedelta(180)},
+        sort=[('date_modified', pymongo.ASCENDING)]))
+    sparklines = get_sparklines(stats)
+    if stats:
+        current_stats = stats[0] 
+        max_latency = utils.prettify_timedelta(
+            datetime.timedelta(seconds=current_stats['max']))
+        min_latency = utils.prettify_timedelta(
+            datetime.timedelta(seconds=current_stats['min']))
+        mean_latency = utils.prettify_timedelta(
+            datetime.timedelta(seconds=current_stats['mean']))
+    else:
+        max_latency = min_latency = mean_latency = 'N/A'
+    return {
+        'queue': queue,
+        'age_format': utils.pretty_timedelta,
+        'max': max_latency,
+        'mean': mean_latency,
+        'min': min_latency,
+        'sparklines': sparklines}
 
 
 @view_config(