Add a timed context manager to statsd.

This enables a context manager in statsd so you can easily time
a set of code without saving the start time, etc. manually:

```python
with statsd.timed_context('user.query.time', sample_rate=0.5):
    # Do what you need to ...
    pass

start = time.time()
try:
    get_user(user_id)
finally:
    statsd.timing('user.query.time', time.time() - start)
```

Two tests are also added for this code.

Fixes DataDog#25

datadog/dogstatsd/base.py

@@ -130,7 +130,7 @@ def timing(self, metric, value, tags=None, sample_rate=1):
     def timed(self, metric, tags=None, sample_rate=1):
         """
         A decorator that will measure the distribution of a function's run
-        time.  Optionally specify a list of tag or a sample rate.
+        time.  Optionally specify a list of tags or a sample rate.
         ::
 
             @statsd.timed('user.query.time', sample_rate=0.5)
@@ -156,6 +156,44 @@ def wrapped(*args, **kwargs):
             return wrapped
         return wrapper
 
+    class _TimedContextManager(object):
+        def __init__(self, statsd, metric, tags=None, sample_rate=1):
+            """
+            Create a context manager which will report the time elapsed by its
+            context.
+            """
+            self.statsd = statsd
+            self.metric = metric
+            self.tags = tags
+            self.sample_rate = sample_rate
+
+        def __enter__(self):
+            self.start = time()
+
+        def __exit__(self, type, value, traceback):
+            # Report the elapsed time of the context manager.
+            self.statsd.timing(self.metric, time() - self.start,
+                               self.tags, self.sample_rate)
+
+    def timed_context(self, metric, tags=None, sample_rate=1):
+        """
+        A context manager that will measure the distribution of a context's run
+        time.  Optionally specify a list of tags or a sample rate.
+        ::
+
+            with statsd.timed_context('user.query.time', sample_rate=0.5):
+                # Do what you need to ...
+                pass
+
+            # Is equivalent to ...
+            start = time.time()
+            try:
+                get_user(user_id)
+            finally:
+                statsd.timing('user.query.time', time.time() - start)
+        """
+        return self._TimedContextManager(self, metric, tags, sample_rate)
+
     def set(self, metric, value, tags=None, sample_rate=1):
         """
         Sample a set value.

tests/unit/dogstatsd/test_statsd.py

@@ -169,6 +169,40 @@ def func(a, b, c=1, d=1):
         t.assert_equal('timed.test', name)
         self.assert_almost_equal(0.5, float(value), 0.1)
 
+    def test_timed_context(self):
+        with self.statsd.timed_context('timed_context.test'):
+            time.sleep(0.5)
+
+        packet = self.recv()
+        name_value, type_ = packet.split('|')
+        name, value = name_value.split(':')
+
+        t.assert_equal('ms', type_)
+        t.assert_equal('timed_context.test', name)
+        self.assert_almost_equal(0.5, float(value), 0.1)
+
+    def test_timed_context_exception(self):
+        """Test that an exception bubbles out of the context manager."""
+        class ContextException(Exception):
+            pass
+
+        def func(self):
+            with self.statsd.timed_context('timed_context.test.exception'):
+                time.sleep(0.5)
+                raise ContextException()
+
+        # Ensure the exception was raised.
+        t.assert_raises(ContextException, func, self)
+
+        # Ensure the timing was recorded.
+        packet = self.recv()
+        name_value, type_ = packet.split('|')
+        name, value = name_value.split(':')
+
+        t.assert_equal('ms', type_)
+        t.assert_equal('timed_context.test.exception', name)
+        self.assert_almost_equal(0.5, float(value), 0.1)
+
     def test_batched(self):
         self.statsd.open_buffer()
         self.statsd.gauge('page.views', 123)