Merge lp:~theiw/txstatsd/txstatsd-coda-hale-timer into lp:txstatsd

[Ian Wilkinson]

Completes the support for the Coda Hale metrics. The inclusion of the timer metric brings a number of dependencies: the histogram metric, and some stats support.

This also fixes an issue in updating the counter metric reporter.

Completes the support for the Coda Hale metrics. The inclusion of the timer metric brings a number of dependencies: the histogram metric, and some stats support.

This also fixes an issue in updating the counter metric reporter.

[Sidnei da Silva (sidnei)]

My understanding is that Lucio had an issue with histogram, so I'm deferring to him on the stats side which I don't have much background into. Code-wise, everything looks fine, tests pass. +1!

review: Approve

[Lucio Torre (lucio.torre)]

Just for the record:
1)

674 + def update(self, value):
675 + self._count += 1
676 + if self._count <= len(self._values):
677 + self._values[self._count - 1] = value
678 + else:
679 + r = random.randint(1, sys.maxint) % self._count
680 + if r < len(self._values):
681 + self._values[r] = value

If we received 1 million values and reservoir_size == 100, then we will only update the values once every 10k values. And when we get to 10M values, we will only update the values once every 100k values.

This seems to be an uniform sampling of the whole history of the values. The problem here is that we dont keep the whole history, just the data since the last time we reset txstatsd. And given a systemic change in the observed system, which could affect the values significantly, we would only change the derived stat in a way inversely proportional to the size of the history. So this stat would en up showing more information about when we last restarted txstatsd than the real value we are trying to track.

So, the question is, whats the use case for uniformly sampled histograms?

Same goes for mean and all the other metrics implemented in the HistogramMetricReporter which track the whole history.

2) maybe minor. with percentiles we approximate the CDF of the random variable, not the PDF. And from the term histogram i imagine we get to see the PDF.

Examples:
http://upload.wikimedia.org/wikipedia/commons/7/74/Normal_Distribution_PDF.svg
http://en.wikipedia.org/wiki/File:Normal_Distribution_CDF.svg
Which one of the two reminds you more of a histogram for a normal distribution?

[Ian Wilkinson (theiw)]

This is the response I received from a friend more knowledgable on stats than myself:

"1) Using historical data can be fine but it depends on the process generating the data. The buzzword here is stationarity. If the data generating process doesn't change over time then using historical data is OK. If the process has changed then using that data is a bad idea. Basically, if there is some sort of trend then you have problems.
2) Looking at the code the fact that it's giving you the percentiles would imply it's a cumulative histogram...which is still a type of histogram! As for it being an estimate of the CDF, it will be under some conditions on the data generating process but this is non-parametrics and I don't know an awful lot about them."

I have also posted Coda Hale on the historical data concern.

On Monday, 26 September 2011 at 15:41, Lucio Torre wrote:

> Just for the record:
> 1)
>
> 674 + def update(self, value):
> 675 + self._count += 1
> 676 + if self._count <= len(self._values):
> 677 + self._values[self._count - 1] = value
> 678 + else:
> 679 + r = random.randint(1, sys.maxint) % self._count
> 680 + if r < len(self._values):
> 681 + self._values[r] = value
>
> If we received 1 million values and reservoir_size == 100, then we will only update the values once every 10k values. And when we get to 10M values, we will only update the values once every 100k values.
>
> This seems to be an uniform sampling of the whole history of the values. The problem here is that we dont keep the whole history, just the data since the last time we reset txstatsd. And given a systemic change in the observed system, which could affect the values significantly, we would only change the derived stat in a way inversely proportional to the size of the history. So this stat would en up showing more information about when we last restarted txstatsd than the real value we are trying to track.
>
> So, the question is, whats the use case for uniformly sampled histograms?
>
> Same goes for mean and all the other metrics implemented in the HistogramMetricReporter which track the whole history.
>
> 2) maybe minor. with percentiles we approximate the CDF of the random variable, not the PDF. And from the term histogram i imagine we get to see the PDF.
>
> Examples:
> http://upload.wikimedia.org/wikipedia/commons/7/74/Normal_Distribution_PDF.svg
> http://en.wikipedia.org/wiki/File:Normal_Distribution_CDF.svg
> Which one of the two reminds you more of a histogram for a normal distribution?
> --
> https://code.launchpad.net/~theiw/txstatsd/txstatsd-coda-hale-timer/+merge/75333
> You are the owner of lp:~theiw/txstatsd/txstatsd-coda-hale-timer.

[Lucio Torre (lucio.torre)]

i think we can land this so we can unblock clients using this functionality.

Still, we should continue investigating this and maybe make any changes necessary to support most valuable stats.

I think that for each stat that we present we *must* be able to understand what it means and what data is taken into account to produce it (and how its merged too).

We we should have a page explaining in easy to understand terms what each metric is.

review: Approve

=== modified file 'txstatsd/metrics/countermetric.py'
--- txstatsd/metrics/countermetric.py	2011-09-09 15:49:05 +0000
+++ txstatsd/metrics/countermetric.py	2011-09-14 12:06:24 +0000
@@ -67,7 +67,7 @@
         self.count = 0
 
     def mark(self, value):
-        self.count += value
+        self.count = value
 
     def report(self, timestamp):
         return self.message % {

=== modified file 'txstatsd/metrics/extendedmetrics.py'
--- txstatsd/metrics/extendedmetrics.py	2011-09-09 15:17:09 +0000
+++ txstatsd/metrics/extendedmetrics.py	2011-09-14 12:06:24 +0000
@@ -1,5 +1,6 @@
 
 from txstatsd.metrics.countermetric import CounterMetric
+from txstatsd.metrics.timermetric import TimerMetric
 from txstatsd.metrics.metrics import Metrics
 
 
@@ -37,3 +38,13 @@
                                    sample_rate)
             self._metrics[name] = metric
         self._metrics[name].decrement(value)
+
+    def timing(self, name, duration, sample_rate=1):
+        """Report this sample performed in duration ms."""
+        name = self.fully_qualify_name(name)
+        if not name in self._metrics:
+            metric = TimerMetric(self.connection,
+                                 name,
+                                 sample_rate)
+            self._metrics[name] = metric
+        self._metrics[name].mark(duration)

=== added file 'txstatsd/metrics/histogrammetric.py'
--- txstatsd/metrics/histogrammetric.py	1970-01-01 00:00:00 +0000
+++ txstatsd/metrics/histogrammetric.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,195 @@
+
+import math
+import sys
+
+from string import Template
+
+from txstatsd.stats.exponentiallydecayingsample \
+    import ExponentiallyDecayingSample
+from txstatsd.stats.uniformsample import UniformSample
+
+
+class HistogramMetricReporter(object):
+    """
+    A metric which calculates the distribution of a value.
+
+    See:
+    - U{Accurately computing running variance
+          <http://www.johndcook.com/standard_deviation.html>}
+    """
+
+    MESSAGE = (
+        "$prefix%(key)s.min %(min)s %(timestamp)s\n"
+        "$prefix%(key)s.max %(max)s %(timestamp)s\n"
+        "$prefix%(key)s.mean %(mean)s %(timestamp)s\n"
+        "$prefix%(key)s.stddev %(lower)s %(timestamp)s\n"
+        "$prefix%(key)s.median %(count)s %(timestamp)s\n"
+        "$prefix%(key)s.75percentile %(75percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.95percentile %(95percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.98percentile %(98percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.99percentile %(99percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.999percentile %(999percentile)s %(timestamp)s\n")
+
+    @classmethod
+    def using_uniform_sample(cls, prefix=""):
+        """
+        Uses a uniform sample of 1028 elements, which offers a 99.9%
+        confidence level with a 5% margin of error assuming a normal
+        distribution.
+         """
+        sample = UniformSample(1028)
+        return HistogramMetricReporter(sample, prefix=prefix)
+
+    @classmethod
+    def using_exponentially_decaying_sample(cls, prefix=""):
+        """
+        Uses an exponentially decaying sample of 1028 elements, which offers
+        a 99.9% confidence level with a 5% margin of error assuming a normal
+        distribution, and an alpha factor of 0.015, which heavily biases
+        the sample to the past 5 minutes of measurements.
+        """
+        sample = ExponentiallyDecayingSample(1028, 0.015)
+        return HistogramMetricReporter(sample, prefix=prefix)
+
+    def __init__(self, sample, prefix=""):
+        """Creates a new HistogramMetric with the given sample.
+
+        @param sample: The sample to create a histogram from.
+        """
+        self.sample = sample
+
+        if prefix:
+            prefix += '.'
+        self.message = Template(HistogramMetricReporter.MESSAGE).substitute(
+            prefix=prefix)
+
+        self._min = 0
+        self._max = 0
+        self._sum = 0
+
+        # These are for the Welford algorithm for calculating running
+        # variance without floating-point doom.
+        self.variance = [-1.0, 0.0]    # M, S
+        self.count = 0
+
+        self.clear()
+
+    def clear(self):
+        """Clears all recorded values."""
+        self.sample.clear()
+        self.count = 0
+        self._max = None
+        self._min = None
+        self._sum = 0
+        self.variance = [-1.0, 0.0]
+
+    def update(self, value, name=""):
+        """Adds a recorded value.
+
+        @param value: The length of the value.
+        """
+        self.count += 1
+        self.sample.update(value)
+        self.set_max(value)
+        self.set_min(value)
+        self._sum += value
+        self.update_variance(value)
+
+    def report(self, timestamp):
+        # median, 75, 95, 98, 99, 99.9 percentile
+        percentiles = self.percentiles(0.5, 0.75, 0.95, 0.98, 0.99, 0.999)
+
+        return self.message % {
+            "key": self.name,
+            "min": self.min(),
+            "max": self.max(),
+            "mean": self.mean(),
+            "stddev": self.std_dev(),
+            "median": percentiles[0],
+            "75percentile": percentiles[1],
+            "95percentile": percentiles[2],
+            "98percentile": percentiles[3],
+            "99percentile": percentiles[4],
+            "999percentile": percentiles[5],
+            "timestamp": timestamp}
+
+    def min(self):
+        """Returns the smallest recorded value."""
+        return self._min if self.count > 0 else 0.0
+
+    def max(self):
+        """Returns the largest recorded value."""
+        return self._max if self.count > 0 else 0.0
+
+    def mean(self):
+        """Returns the arithmetic mean of all recorded values."""
+        return float(self._sum) / self.count if self.count > 0 else 0.0
+
+    def std_dev(self):
+        """Returns the standard deviation of all recorded values."""
+        return math.sqrt(self.get_variance()) if self.count > 0 else 0.0
+
+    def percentiles(self, *percentiles):
+        """Returns a list of values at the given percentiles.
+
+        @param percentiles one or more percentiles
+        """
+
+        scores = [0.0 for i in range(len(percentiles))]
+        if self.count > 0:
+            values = self.sample.get_values()
+            values.sort()
+
+            for i in range(len(percentiles)):
+                p = percentiles[i]
+                pos = p * (len(values) + 1)
+                if pos < 1:
+                    scores[i] = values[0]
+                elif pos >= len(values):
+                    scores[i] = values[-1]
+                else:
+                    lower = values[int(pos) - 1]
+                    upper = values[int(pos)]
+                    scores[i] = lower + (pos - math.floor(pos)) * (
+                        upper - lower)
+
+        return scores
+
+    def get_values(self):
+        """Returns a list of all values in the histogram's sample."""
+        return self.sample.get_values()
+
+    def get_variance(self):
+        if self.count <= 1:
+            return 0.0
+        return self.variance[1] / (self.count - 1)
+
+    def set_max(self, potential_max):
+        if self._max is None:
+            self._max = potential_max
+        else:
+            self._max = max(self.max(), potential_max)
+
+    def set_min(self, potential_min):
+        if self._min is None:
+            self._min = potential_min
+        else:
+            self._min = min(self.min(), potential_min)
+
+    def update_variance(self, value):
+        old_values = self.variance
+        new_values = [0.0, 0.0]
+        if old_values[0] == -1:
+            new_values[0] = value
+            new_values[1] = 0.0
+        else:
+            old_m = old_values[0]
+            old_s = old_values[1]
+
+            new_m = old_m + (float(value - old_m) / self.count)
+            new_s = old_s + (float(value - old_m) * (value - new_m))
+
+            new_values[0] = new_m
+            new_values[1] = new_s
+
+        self.variance = new_values
\ No newline at end of file

=== added file 'txstatsd/metrics/timermetric.py'
--- txstatsd/metrics/timermetric.py	1970-01-01 00:00:00 +0000
+++ txstatsd/metrics/timermetric.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,153 @@
+
+from string import Template
+
+import time
+
+from txstatsd.metrics.histogrammetric import HistogramMetricReporter
+from txstatsd.metrics.metermetric import MeterMetricReporter
+from txstatsd.metrics.metric import Metric
+from txstatsd.stats.exponentiallydecayingsample \
+    import ExponentiallyDecayingSample
+
+
+class TimerMetric(Metric):
+    """
+    A timer metric which aggregates timing durations and provides duration
+    statistics, plus throughput statistics via L{MeterMetric}.
+    """
+
+    def __init__(self, connection, name, sample_rate=1):
+        """Construct a metric that reports samples to the supplied
+        C{connection}.
+
+        @param connection: The connection endpoint representing
+            the StatsD server.
+        @param name: Indicates what is being instrumented.
+        @param sample_rate: Restrict the number of samples sent
+            to the StatsD server based on the supplied C{sample_rate}.
+        """
+        Metric.__init__(self, connection, name, sample_rate=sample_rate)
+
+    def mark(self, duration):
+        """Report this sample performed in duration (measured in seconds)."""
+        self.send("%s|ms" % duration)
+
+
+class TimerMetricReporter(object):
+    """
+    A timer metric which aggregates timing durations and provides duration
+    statistics, plus throughput statistics via L{MeterMetricReporter}.
+    """
+
+    MESSAGE = (
+        "$prefix%(key)s.min %(min)s %(timestamp)s\n"
+        "$prefix%(key)s.max %(max)s %(timestamp)s\n"
+        "$prefix%(key)s.mean %(mean)s %(timestamp)s\n"
+        "$prefix%(key)s.stddev %(stddev)s %(timestamp)s\n"
+        "$prefix%(key)s.median %(median)s %(timestamp)s\n"
+        "$prefix%(key)s.75percentile %(75percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.95percentile %(95percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.98percentile %(98percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.99percentile %(99percentile)s %(timestamp)s\n"
+        "$prefix%(key)s.999percentile %(999percentile)s %(timestamp)s\n")
+
+    def __init__(self, name, wall_time_func=time.time, prefix=""):
+        """Construct a metric we expect to be periodically updated.
+
+        @param name: Indicates what is being instrumented.
+        @param wall_time_func: Function for obtaining wall time.
+        @param prefix: If present, a string to prepend to the message
+            composed when C{report} is called.
+        """
+        self.name = name
+        self.wall_time_func = wall_time_func
+
+        if prefix:
+            prefix += '.'
+        self.message = Template(TimerMetricReporter.MESSAGE).substitute(
+            prefix=prefix)
+
+        sample = ExponentiallyDecayingSample(1028, 0.015)
+        self.histogram = HistogramMetricReporter(sample)
+        self.meter = MeterMetricReporter(
+            'calls', wall_time_func=self.wall_time_func)
+        self.clear()
+
+    def clear(self):
+        """Clears all recorded durations."""
+        self.histogram.clear()
+
+    def count(self):
+        return self.histogram.count
+
+    def fifteen_minute_rate(self):
+        return self.meter.fifteen_minute_rate()
+
+    def five_minute_rate(self):
+        return self.meter.five_minute_rate()
+
+    def mean_rate(self):
+        return self.meter.mean_rate()
+
+    def one_minute_rate(self):
+        return self.meter.one_minute_rate()
+
+    def max(self):
+        """Returns the longest recorded duration."""
+        return self.histogram.max()
+
+    def min(self):
+        """Returns the shortest recorded duration."""
+        return self.histogram.min()
+
+    def mean(self):
+        """Returns the arithmetic mean of all recorded durations."""
+        return self.histogram.mean()
+
+    def std_dev(self):
+        """Returns the standard deviation of all recorded durations."""
+        return self.histogram.std_dev()
+
+    def percentiles(self, *percentiles):
+        """
+        Returns an array of durations at the given percentiles.
+
+        @param percentiles: One or more percentiles.
+        """
+        return [percentile for percentile in
+            self.histogram.percentiles(*percentiles)]
+
+    def get_values(self):
+        """Returns a list of all recorded durations in the timer's sample."""
+        return [value for value in self.histogram.get_values()]
+
+    def update(self, duration):
+        """Adds a recorded duration.
+
+        @param duration: The length of the duration in seconds.
+        """
+        if duration >= 0:
+            self.histogram.update(duration)
+            self.meter.mark()
+
+    def tick(self):
+        """Updates the moving averages."""
+        self.meter.tick()
+
+    def report(self, timestamp):
+        # median, 75, 95, 98, 99, 99.9 percentile
+        percentiles = self.percentiles(0.5, 0.75, 0.95, 0.98, 0.99, 0.999)
+
+        return self.message % {
+            "key": self.name,
+            "min": self.min(),
+            "max": self.max(),
+            "mean": self.mean(),
+            "stddev": self.std_dev(),
+            "median": percentiles[0],
+            "75percentile": percentiles[1],
+            "95percentile": percentiles[2],
+            "98percentile": percentiles[3],
+            "99percentile": percentiles[4],
+            "999percentile": percentiles[5],
+            "timestamp": timestamp}

=== modified file 'txstatsd/server/configurableprocessor.py'
--- txstatsd/server/configurableprocessor.py	2011-09-09 15:17:09 +0000
+++ txstatsd/server/configurableprocessor.py	2011-09-14 12:06:24 +0000
@@ -5,6 +5,7 @@
 
 from txstatsd.metrics.countermetric import CounterMetricReporter
 from txstatsd.metrics.metermetric import MeterMetricReporter
+from txstatsd.metrics.timermetric import TimerMetricReporter
 from txstatsd.server.processor import MessageProcessor
 
 
@@ -12,25 +13,17 @@
     """
     This specialised C{MessageProcessor} supports behaviour
     that is not StatsD-compliant.
+
     Currently, this extends to:
     - Allow a prefix to be added to the composed messages sent
       to the Graphite server.
     - Report an incrementing and decrementing counter metric.
+    - Report a timer metric which aggregates timing durations and provides
+      duration statistics, plus throughput statistics.
     """
 
-    # Notice: These messages replicate those seen in the
-    # MessageProcessor (excepting the prefix identifier).
-    # In a future release they will be placed in their
-    # respective metric reporter class.
-    # See MeterMetricReporter.
-    TIMERS_MESSAGE = (
-        "$prefix%(key)s.mean %(mean)s %(timestamp)s\n"
-        "$prefix%(key)s.upper %(upper)s %(timestamp)s\n"
-        "$prefix%(key)s.upper_%(percent)s %(threshold_upper)s"
-            " %(timestamp)s\n"
-        "$prefix%(key)s.lower %(lower)s %(timestamp)s\n"
-        "$prefix%(key)s.count %(count)s %(timestamp)s\n")
-
+    #TODO Provide a GaugeMetricReporter (in the manner of the other
+    # Coda Hale metrics).
     GAUGE_METRIC_MESSAGE = (
         "$prefix%(key)s.value %(value)s %(timestamp)s\n")
 
@@ -41,14 +34,16 @@
         if message_prefix:
             message_prefix += '.'
 
-        message = Template(ConfigurableMessageProcessor.TIMERS_MESSAGE)
-        self.timers_message = message.substitute(
-            prefix=message_prefix)
-
         message = Template(ConfigurableMessageProcessor.GAUGE_METRIC_MESSAGE)
         self.gauge_metric_message = message.substitute(
             prefix=message_prefix)
 
+    def compose_timer_metric(self, key, duration):
+        if not key in self.timer_metrics:
+            metric = TimerMetricReporter(key, prefix=self.message_prefix)
+            self.timer_metrics[key] = metric
+        self.timer_metrics[key].update(duration)
+
     def process_counter_metric(self, key, composite, message):
         try:
             value = float(composite[0])
@@ -79,3 +74,19 @@
             events += 1
 
         return (metrics, events)
+
+    def flush_timer_metrics(self, percent, timestamp):
+        metrics = []
+        events = 0
+        for metric in self.timer_metrics.itervalues():
+            message = metric.report(timestamp)
+            metrics.append(message)
+            events += 1
+
+        return (metrics, events)
+
+    def update_metrics(self):
+        super(ConfigurableMessageProcessor, self).update_metrics()
+
+        for metric in self.timer_metrics.itervalues():
+            metric.tick()

=== modified file 'txstatsd/server/processor.py'
--- txstatsd/server/processor.py	2011-09-09 15:17:09 +0000
+++ txstatsd/server/processor.py	2011-09-14 12:06:24 +0000
@@ -94,14 +94,18 @@
         else:
             return self.fail(message)
 
-    def process_timer_metric(self, key, value, message):
+    def process_timer_metric(self, key, duration, message):
         try:
-            value = float(value)
+            duration = float(duration)
         except (TypeError, ValueError):
             return self.fail(message)
+
+        self.compose_timer_metric(key, duration)
+
+    def compose_timer_metric(self, key, duration):
         if key not in self.timer_metrics:
             self.timer_metrics[key] = []
-        self.timer_metrics[key].append(value)
+        self.timer_metrics[key].append(duration)
 
     def process_counter_metric(self, key, composite, message):
         try:

=== added file 'txstatsd/stats/exponentiallydecayingsample.py'
--- txstatsd/stats/exponentiallydecayingsample.py	1970-01-01 00:00:00 +0000
+++ txstatsd/stats/exponentiallydecayingsample.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,124 @@
+
+import math
+import random
+import time
+
+
+class ExponentiallyDecayingSample(object):
+    """
+    An exponentially-decaying random sample of values. Uses Cormode et
+    al's forward-decaying priority reservoir sampling method to produce a
+    statistically representative sample, exponentially biased towards newer
+    entries.
+
+    See:
+    - U{Cormode et al. Forward Decay: A Practical Time Decay Model for
+      Streaming Systems. ICDE '09: Proceedings of the 2009 IEEE International
+      Conference on Data Engineering (2009)
+      <http://www.research.att.com/people/Cormode_Graham/
+      library/publications/CormodeShkapenyukSrivastavaXu09.pdf>}
+    """
+
+    # 1 hour (in seconds)
+    RESCALE_THRESHOLD = 60 * 60
+
+    def __init__(self, reservoir_size, alpha):
+        """Creates a new C{ExponentiallyDecayingSample}.
+
+        @param reservoir_size: The number of samples to keep in the sampling
+            reservoir.
+        @parama alpha: The exponential decay factor; the higher this is,
+            the more biased the sample will be towards newer values.
+        """
+        self._values = dict()
+        self.alpha = alpha
+        self.reservoir_size = reservoir_size
+
+        self.count = 0
+        self.start_time = 0
+        self.next_scale_time = 0
+
+        self.clear()
+
+    def clear(self):
+        self._values.clear()
+        self.count = 0
+        self.start_time = self.tick()
+        self.next_scale_time = (
+            time.time() + ExponentiallyDecayingSample.RESCALE_THRESHOLD)
+
+    def size(self):
+        return min(self.reservoir_size, self.count)
+
+    def update(self, value, timestamp=None):
+        """Adds an old value with a fixed timestamp to the sample.
+
+        @param value: The value to be added.
+        @param timestamp: The epoch timestamp of *value* in seconds.
+        """
+
+        if timestamp is None:
+            timestamp = self.tick()
+
+        priority = self.weight(timestamp - self.start_time) / random.random()
+        self.count += 1
+        new_count = self.count
+        if new_count <= self.reservoir_size:
+            self._values[priority] = value
+        else:
+            keys = sorted(self._values.keys())
+            first = keys[0]
+
+            if first < priority:
+                if priority not in self._values:
+                    self._values[priority] = value
+                    del self._values[first]
+
+        now = time.time()
+        next = self.next_scale_time
+        if now >= next:
+            self.rescale(now, next)
+
+    def get_values(self):
+        keys = sorted(self._values.keys())
+        return [self._values[k] for k in keys]
+
+    def tick(self):
+        return time.time()
+
+    def weight(self, t):
+        return math.exp(self.alpha * t)
+
+    def rescale(self, now, next):
+        """
+        A common feature of the above techniques - indeed, the key technique
+        that allows us to track the decayed weights efficiently - is that they
+        maintain counts and other quantities based on g(ti - L), and only
+        scale by g(t - L) at query time. But while g(ti - L)/g(t-L) is
+        guaranteed to lie between zero and one, the intermediate values of
+        g(ti - L) could become very large. For polynomial functions, these
+        values should not grow too large, and should be effectively
+        represented in practice by floating point values without loss of
+        precision. For exponential functions, these values could grow quite
+        large as new values of (ti - L) become large, and potentially exceed
+        the capacity of common floating point types. However, since the values
+        stored by the algorithms are linear combinations of g values (scaled
+        sums), they can be rescaled relative to a new landmark. That is, by
+        the analysis of exponential decay in Section III-A, the choice of L
+        does not affect the final result. We can therefore multiply each value
+        based on L by a factor of exp(-alpha(L' - L)), and obtain the correct
+        value as if we had instead computed relative to a new landmark L' (and
+        then use this new L' at query time). This can be done with a linear
+        pass over whatever data structure is being used.
+        """
+
+        self.next_scale_time = (
+            now + ExponentiallyDecayingSample.RESCALE_THRESHOLD)
+        old_start_time = self.start_time
+        self.start_time = self.tick()
+        keys = sorted(self._values.keys())
+        for k in keys:
+            v = self._values[k]
+            del self._values[k]
+            self._values[k * math.exp(-self.alpha *
+                         (self.start_time - old_start_time))] = v

=== added file 'txstatsd/stats/uniformsample.py'
--- txstatsd/stats/uniformsample.py	1970-01-01 00:00:00 +0000
+++ txstatsd/stats/uniformsample.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,45 @@
+
+import random
+import sys
+
+
+class UniformSample(object):
+    """
+    A random sample of a stream of values. Uses Vitter's Algorithm R to
+    produce a statistically representative sample.
+    
+    See:
+    - U{Random Sampling with a Reservoir
+        <http://www.cs.umd.edu/~samir/498/vitter.pdf>}
+    """
+
+    def __init__(self, reservoir_size):
+        """Creates a new C{UniformSample}.
+
+        @param reservoir_size: The number of samples to keep in the sampling
+            reservoir.
+        """
+        self._values = [0 for i in range(reservoir_size)]
+        self._count = 0
+        self.clear()
+    
+    def clear(self):
+        self._values = [0 for i in range(len(self._values))]
+        self._count = 0
+
+    def size(self):
+        c = self._count
+        return len(self._values) if c > len(self._values) else c
+
+    def update(self, value):
+        self._count += 1
+        if self._count <= len(self._values):
+            self._values[self._count - 1] = value
+        else:
+            r = random.randint(1, sys.maxint) % self._count
+            if r < len(self._values):
+                self._values[r] = value
+
+    def get_values(self):
+        s = self.size()
+        return [self._values[i] for i in range(0, s)]

=== added directory 'txstatsd/tests/metrics'
=== added file 'txstatsd/tests/metrics/__init__.py'
--- txstatsd/tests/metrics/__init__.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/metrics/__init__.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,2 @@
+
+

=== added file 'txstatsd/tests/metrics/test_histogrammetric.py'
--- txstatsd/tests/metrics/test_histogrammetric.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/metrics/test_histogrammetric.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,89 @@
+
+import math
+from unittest import TestCase
+
+from txstatsd.metrics.histogrammetric import HistogramMetricReporter
+from txstatsd.stats.uniformsample import UniformSample
+
+
+class TestHistogramReporterMetric(TestCase):
+    def test_histogram_with_zero_recorded_values(self):
+        sample = UniformSample(100)
+        histogram = HistogramMetricReporter(sample)
+
+        self.assertEqual(histogram.count, 0, 'Should have a count of 0')
+        self.assertEqual(histogram.max(), 0,
+                         'Should have a max of 0')
+        self.assertEqual(histogram.min(), 0,
+                         'Should have a min of 0')
+
+        self.assertEqual(histogram.mean(), 0,
+                         'Should have a mean of 0')
+
+        self.assertEqual(histogram.std_dev(), 0,
+                         'Should have a standard deviation of 0')
+
+        percentiles = histogram.percentiles(0.5, 0.75, 0.99)
+        self.assertTrue(
+            (math.fabs(percentiles[0] - 0) < 0.01),
+            'Should calculate percentiles')
+        self.assertTrue(
+            (math.fabs(percentiles[1] - 0) < 0.01),
+            'Should calculate percentiles')
+        self.assertTrue(
+            (math.fabs(percentiles[2] - 0) < 0.01),
+            'Should calculate percentiles')
+
+        self.assertEqual(len(histogram.get_values()), 0,
+                         'Should have no values')
+
+    def test_histogram_of_numbers_1_through_10000(self):
+        sample = UniformSample(100000)
+        histogram = HistogramMetricReporter(sample)
+        for i in range(1, 10001):
+            histogram.update(i)
+    
+        self.assertEqual(histogram.count, 10000,
+                         'Should have a count of 10000')
+    
+        self.assertEqual(histogram.max(), 10000,
+                         'Should have a max of 10000')
+        self.assertEqual(histogram.min(), 1,
+                         'Should have a min of 1')
+
+    def test_histogram_of_numbers_1_through_10000(self):
+        sample = UniformSample(100000)
+        histogram = HistogramMetricReporter(sample)
+        for i in range(1, 10001):
+            histogram.update(i)
+
+        self.assertEqual(histogram.count, 10000,
+                         'Should have a count of 10000')
+
+        self.assertEqual(histogram.max(), 10000,
+                         'Should have a max of 10000')
+        self.assertEqual(histogram.min(), 1,
+                         'Should have a min of 1')
+
+        self.assertTrue(
+            (math.fabs(histogram.mean() - 5000.5) < 0.01),
+            'Should have a mean value of 5000.5')
+
+        self.assertTrue(
+            (math.fabs(histogram.std_dev() - 2886.89) < 0.01),
+            'Should have a standard deviation of X')
+
+        percentiles = histogram.percentiles(0.5, 0.75, 0.99)
+        self.assertTrue(
+            (math.fabs(percentiles[0] - 5000.5) < 0.01),
+            'Should calculate percentiles')
+        self.assertTrue(
+            (math.fabs(percentiles[1] - 7500.75) < 0.01),
+            'Should calculate percentiles')
+        self.assertTrue(
+            (math.fabs(percentiles[2] - 9900.99) < 0.01),
+            'Should calculate percentiles')
+
+        values = [i for i in range(1, 10001)]
+        self.assertEqual(histogram.get_values(), values,
+                         'Should have 10000 values')
\ No newline at end of file

=== added file 'txstatsd/tests/metrics/test_timermetric.py'
--- txstatsd/tests/metrics/test_timermetric.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/metrics/test_timermetric.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,139 @@
+
+import math
+
+from twisted.trial.unittest import TestCase
+
+from txstatsd.metrics.timermetric import TimerMetricReporter
+
+
+class TestBlankTimerMetric(TestCase):
+    def setUp(self):
+        self.timer = TimerMetricReporter('test')
+        self.timer.tick()
+
+    def test_max(self):
+        self.assertEqual(
+            self.timer.max(), 0,
+            'Should have a max of zero')
+
+    def test_min(self):
+        self.assertEqual(
+            self.timer.min(), 0,
+            'Should have a min of zero')
+
+    def test_mean(self):
+        self.assertEqual(
+            self.timer.max(), 0,
+            'Should have a mean of zero')
+
+    def test_count(self):
+        self.assertEqual(
+            self.timer.count(), 0,
+            'Should have a count of zero')
+
+    def test_std_dev(self):
+        self.assertEqual(
+            self.timer.std_dev(), 0,
+            'Should have a standard deviation of zero')
+
+    def test_percentiles(self):
+        percentiles = self.timer.percentiles(0.5, 0.95, 0.98, 0.99, 0.999)
+        self.assertEqual(
+            percentiles[0], 0,
+            'Should have median of zero')
+        self.assertEqual(
+            percentiles[1], 0,
+            'Should have p95 of zero')
+        self.assertEqual(
+            percentiles[2], 0,
+            'Should have p98 of zero')
+        self.assertEqual(
+            percentiles[3], 0,
+            'Should have p99 of zero')
+        self.assertEqual(
+            percentiles[4], 0,
+            'Should have p99.9 of zero')
+
+    def test_mean_rate(self):
+        self.assertEqual(
+            self.timer.mean_rate(), 0,
+            'Should have a mean rate of zero')
+
+    def test_one_minute_rate(self):
+        self.assertEqual(
+            self.timer.one_minute_rate(), 0,
+            'Should have a one-minute rate of zero`')
+
+    def test_five_minute_rate(self):
+        self.assertEqual(
+            self.timer.five_minute_rate(), 0,
+            'Should have a five-minute rate of zero')
+
+    def test_fifteen_minute_rate(self):
+        self.assertEqual(
+            self.timer.fifteen_minute_rate(), 0,
+            'Should have a fifteen-minute rate of zero')
+
+    def test_no_values(self):
+        self.assertEqual(
+            len(self.timer.get_values()), 0,
+            'Should have no values')
+
+
+class TestTimingSeriesEvents(TestCase):
+    def setUp(self):
+        self.timer = TimerMetricReporter('test')
+        self.timer.tick()
+        self.timer.update(10)
+        self.timer.update(20)
+        self.timer.update(20)
+        self.timer.update(30)
+        self.timer.update(40)
+
+    def test_count(self):
+        self.assertEqual(
+            self.timer.count(), 5,
+            'Should record the count')
+
+    def test_min(self):
+        self.assertTrue(
+            (math.fabs(self.timer.min() - 10.0) < 0.001),
+            'Should calculate the minimum duration')
+
+    def test_max(self):
+        self.assertTrue(
+            (math.fabs(self.timer.max() - 40.0) < 0.001),
+            'Should calculate the maximum duration')
+
+    def test_mean(self):
+        self.assertTrue(
+            (math.fabs(self.timer.mean() - 24.0) < 0.001),
+            'Should calculate the mean duration')
+
+    def test_std_dev(self):
+        self.assertTrue(
+            (math.fabs(self.timer.std_dev() - 11.401) < 0.001),
+            'Should calculate the standard deviation')
+
+    def test_percentiles(self):
+        percentiles = self.timer.percentiles(0.5, 0.95, 0.98, 0.99, 0.999)
+        self.assertTrue(
+            (math.fabs(percentiles[0] - 20.0) < 0.001),
+            'Should calculate the median')
+        self.assertTrue(
+            (math.fabs(percentiles[1] - 40.0) < 0.001),
+            'Should calculate the p95')
+        self.assertTrue(
+            (math.fabs(percentiles[2] - 40.0) < 0.001),
+            'Should calculate the p98')
+        self.assertTrue(
+            (math.fabs(percentiles[3] - 40.0) < 0.001),
+            'Should calculate the p99')
+        self.assertTrue(
+            (math.fabs(percentiles[4] - 40.0) < 0.001),
+            'Should calculate the p999')
+
+    def test_values(self):
+        self.assertEqual(
+            set(self.timer.get_values()), set([10, 20, 20, 30, 40]),
+            'Should have a series of values')

=== added file 'txstatsd/tests/stats/test_exponentiallydecayingsample.py'
--- txstatsd/tests/stats/test_exponentiallydecayingsample.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/stats/test_exponentiallydecayingsample.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,47 @@
+
+from unittest import TestCase
+
+from txstatsd.stats.exponentiallydecayingsample import (
+    ExponentiallyDecayingSample)
+
+
+class TestExponentiallyDecayingSample(TestCase):
+
+    def test_100_out_of_1000_elements(self):
+        population = [i for i in range(0, 100)]
+        sample = ExponentiallyDecayingSample(1000, 0.99)
+        for i in population:
+            sample.update(i)
+
+        self.assertEqual(sample.size(), 100, 'Should have 100 elements')
+        self.assertEqual(len(sample.get_values()), 100,
+                         'Should have 100 elements')
+        self.assertEqual(
+            len(set(sample.get_values()).difference(set(population))), 0,
+            'Should only have elements from the population')
+
+    def test_100_out_of_10_elements(self):
+        population = [i for i in range(0, 10)]
+        sample = ExponentiallyDecayingSample(100, 0.99)
+        for i in population:
+            sample.update(i)
+
+        self.assertEqual(sample.size(), 10, 'Should have 10 elements')
+        self.assertEqual(len(sample.get_values()), 10,
+                         'Should have 10 elements')
+        self.assertEqual(
+            len(set(sample.get_values()).difference(set(population))), 0,
+            'Should only have elements from the population')
+
+    def test_heavily_biased_100_out_of_1000_elements(self):
+        population = [i for i in range(0, 100)]
+        sample = ExponentiallyDecayingSample(1000, 0.01)
+        for i in population:
+            sample.update(i)
+
+        self.assertEqual(sample.size(), 100, 'Should have 100 elements')
+        self.assertEqual(len(sample.get_values()), 100,
+                         'Should have 100 elements')
+        self.assertEqual(
+            len(set(sample.get_values()).difference(set(population))), 0,
+            'Should only have elements from the population')
\ No newline at end of file

=== added file 'txstatsd/tests/stats/test_uniformsample.py'
--- txstatsd/tests/stats/test_uniformsample.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/stats/test_uniformsample.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,32 @@
+
+from unittest import TestCase
+
+from txstatsd.stats.uniformsample import UniformSample
+
+
+class TestUniformSample(TestCase):
+    def test_100_out_of_1000_elements(self):
+        population = [i for i in range(0, 1000)]
+        sample = UniformSample(100)
+        for i in population:
+            sample.update(i)
+
+        self.assertEqual(sample.size(), 100, 'Should have 100 elements')
+        self.assertEqual(len(sample.get_values()), 100,
+                         'Should have 100 elements')
+        self.assertEqual(
+            len(set(sample.get_values()).difference(set(population))), 0,
+            'Should only have elements from the population')
+
+    def test_100_out_of_10_elements(self):
+        population = [i for i in range(0, 10)]
+        sample = UniformSample(100)
+        for i in population:
+            sample.update(i)
+
+        self.assertEqual(sample.size(), 10, 'Should have 10 elements')
+        self.assertEqual(len(sample.get_values()), 10,
+                         'Should have 10 elements')
+        self.assertEqual(
+            len(set(sample.get_values()).difference(set(population))), 0,
+            'Should only have elements from the population')

=== added file 'txstatsd/tests/test_configurableprocessor.py'
--- txstatsd/tests/test_configurableprocessor.py	1970-01-01 00:00:00 +0000
+++ txstatsd/tests/test_configurableprocessor.py	2011-09-14 12:06:24 +0000
@@ -0,0 +1,141 @@
+import time
+
+from unittest import TestCase
+
+from txstatsd.server.configurableprocessor import ConfigurableMessageProcessor
+
+
+class FlushMessagesTest(TestCase):
+
+    def test_flush_counter_with_empty_prefix(self):
+        """
+        Ensure no prefix features if none is supplied.
+        B{Note}: The C{ConfigurableMessageProcessor} reports
+        the counter value, and not the normalized version as
+        seen in the StatsD-compliant C{Processor}.
+        """
+        configurable_processor = ConfigurableMessageProcessor(
+            time_function=lambda: 42)
+        configurable_processor.process("gorets:17|c")
+        messages = configurable_processor.flush()
+        self.assertEqual(2, len(messages))
+        counters = messages[0].splitlines()
+        self.assertEqual("gorets.count 17 42", counters[0])
+        self.assertEqual("statsd.numStats 1 42", messages[1])
+
+    def test_flush_counter_with_prefix(self):
+        """
+        Ensure the prefix features if one is supplied.
+        """
+        configurable_processor = ConfigurableMessageProcessor(
+            time_function=lambda: 42, message_prefix="test.metric")
+        configurable_processor.process("gorets:17|c")
+        messages = configurable_processor.flush()
+        self.assertEqual(2, len(messages))
+        counters = messages[0].splitlines()
+        self.assertEqual("test.metric.gorets.count 17 42", counters[0])
+        self.assertEqual("statsd.numStats 1 42", messages[1])
+
+    def test_flush_single_timer_single_time(self):
+        """
+        If a single timer with a single data point is present, all
+        percentiles will be set to the same value.
+        """
+        configurable_processor = ConfigurableMessageProcessor(
+            time_function=lambda: 42)
+
+        configurable_processor.process("glork:24|ms")
+        messages = configurable_processor.flush()
+
+        self.assertEqual(2, len(messages))
+        timers = messages[0].splitlines()
+        self.assertEqual("glork.min 24.0 42", timers[0])
+        self.assertEqual("glork.max 24.0 42", timers[1])
+        self.assertEqual("glork.mean 24.0 42", timers[2])
+        self.assertEqual("glork.stddev 0.0 42", timers[3])
+        self.assertEqual("glork.median 24.0 42", timers[4])
+        self.assertEqual("glork.75percentile 24.0 42", timers[5])
+        self.assertEqual("glork.95percentile 24.0 42", timers[6])
+        self.assertEqual("glork.98percentile 24.0 42", timers[7])
+        self.assertEqual("glork.99percentile 24.0 42", timers[8])
+        self.assertEqual("glork.999percentile 24.0 42", timers[9])
+        self.assertEqual("statsd.numStats 1 42", messages[1])
+
+    def test_flush_single_timer_multiple_times(self):
+        """
+        Test reporting of multiple timer metric samples.
+        """
+        configurable_processor = ConfigurableMessageProcessor(
+            time_function=lambda: 42)
+
+        configurable_processor.process("glork:4|ms")
+        configurable_processor.update_metrics()
+        configurable_processor.process("glork:8|ms")
+        configurable_processor.update_metrics()
+        configurable_processor.process("glork:15|ms")
+        configurable_processor.update_metrics()
+        configurable_processor.process("glork:16|ms")
+        configurable_processor.update_metrics()
+        configurable_processor.process("glork:23|ms")
+        configurable_processor.update_metrics()
+        configurable_processor.process("glork:42|ms")
+        configurable_processor.update_metrics()
+
+        messages = configurable_processor.flush()
+        self.assertEqual(2, len(messages))
+        timers = messages[0].splitlines()
+        self.assertEqual("glork.min 4.0 42", timers[0])
+        self.assertEqual("glork.max 42.0 42", timers[1])
+        self.assertEqual("glork.mean 18.0 42", timers[2])
+        self.assertTrue(timers[3].startswith("glork.stddev 13.4907"))
+        self.assertEqual("glork.median 15.5 42", timers[4])
+        self.assertEqual("glork.75percentile 27.75 42", timers[5])
+        self.assertEqual("glork.95percentile 42.0 42", timers[6])
+        self.assertEqual("glork.98percentile 42.0 42", timers[7])
+        self.assertEqual("glork.99percentile 42.0 42", timers[8])
+        self.assertEqual("glork.999percentile 42.0 42", timers[9])
+        self.assertEqual("statsd.numStats 1 42", messages[1])
+
+
+class FlushMeterMetricMessagesTest(TestCase):
+
+    def setUp(self):
+        self.configurable_processor = ConfigurableMessageProcessor(
+            time_function=self.wall_clock_time, message_prefix="test.metric")
+        self.time_now = int(time.time())
+
+    def wall_clock_time(self):
+        return self.time_now
+
+    def mark_minutes(self, minutes):
+        for i in range(1, minutes * 60, 5):
+            self.processor.update_metrics()
+
+    def test_flush_meter_metric_with_prefix(self):
+        """
+        Test the correct rendering of the Graphite report for
+        a meter metric when a prefix is supplied.
+        """
+        self.configurable_processor.process("gorets:3.0|m")
+
+        self.time_now += 1
+        messages = self.configurable_processor.flush()
+        self.assertEqual(2, len(messages))
+        meter_metric = messages[0].splitlines()
+        self.assertEqual(
+            "test.metric.gorets.count 3.0 %s" % self.time_now,
+            meter_metric[0])
+        self.assertEqual(
+            "test.metric.gorets.mean_rate 3.0 %s" % self.time_now,
+            meter_metric[1])
+        self.assertEqual(
+            "test.metric.gorets.1min_rate 0.0 %s" % self.time_now,
+            meter_metric[2])
+        self.assertEqual(
+            "test.metric.gorets.5min_rate 0.0 %s" % self.time_now,
+            meter_metric[3])
+        self.assertEqual(
+            "test.metric.gorets.15min_rate 0.0 %s" % self.time_now,
+            meter_metric[4])
+        self.assertEqual(
+            "statsd.numStats 1 %s" % self.time_now, messages[1])

=== modified file 'txstatsd/tests/test_processor.py'
--- txstatsd/tests/test_processor.py	2011-09-09 15:17:09 +0000
+++ txstatsd/tests/test_processor.py	2011-09-14 12:06:24 +0000
@@ -3,7 +3,6 @@
 from unittest import TestCase
 
 from txstatsd.server.processor import MessageProcessor
-from txstatsd.server.configurableprocessor import ConfigurableMessageProcessor
 
 
 class TestMessageProcessor(MessageProcessor):
@@ -16,17 +15,6 @@
         self.failures.append(message)
 
 
-class TestConfigurableMessageProcessor(ConfigurableMessageProcessor):
-
-    def __init__(self, time_function=time.time, message_prefix=""):
-        super(TestConfigurableMessageProcessor, self).__init__(
-            time_function,
-            message_prefix)
-
-    def fail(self, message):
-        self.failures.append(message)
-
-
 class ProcessMessagesTest(TestCase):
 
     def setUp(self):
@@ -145,35 +133,6 @@
         self.assertEqual("statsd.numStats 1 42", messages[1])
         self.assertEqual(0, self.processor.counter_metrics["gorets"])
 
-    def test_flush_counter_with_empty_prefix(self):
-        """
-        Ensure no prefix features if none is supplied.
-        B{Note}: The C{ConfigurableMessageProcessor} reports
-        the counter value, and not the normalized version as
-        seen in the StatsD-compliant C{Processor}.
-        """
-        configurable_processor = ConfigurableMessageProcessor(
-            time_function=lambda: 42)
-        configurable_processor.process("gorets:17|c")
-        messages = configurable_processor.flush()
-        self.assertEqual(2, len(messages))
-        counters = messages[0].splitlines()
-        self.assertEqual("gorets.count 17 42", counters[0])
-        self.assertEqual("statsd.numStats 1 42", messages[1])
-
-    def test_flush_counter_with_prefix(self):
-        """
-        Ensure the prefix features if one is supplied.
-        """
-        configurable_processor = ConfigurableMessageProcessor(
-            time_function=lambda: 42, message_prefix="test.metric")
-        configurable_processor.process("gorets:17|c")
-        messages = configurable_processor.flush()
-        self.assertEqual(2, len(messages))
-        counters = messages[0].splitlines()
-        self.assertEqual("test.metric.gorets.count 17 42", counters[0])
-        self.assertEqual("statsd.numStats 1 42", messages[1])
-
     def test_flush_counter_one_second_interval(self):
         """
         It is possible to flush counters with a one-second interval, in which
@@ -273,8 +232,6 @@
 
     def setUp(self):
         self.processor = MessageProcessor(time_function=self.wall_clock_time)
-        self.configurable_processor = ConfigurableMessageProcessor(
-            time_function=self.wall_clock_time, message_prefix="test.metric")
         self.time_now = int(time.time())
 
     def wall_clock_time(self):
@@ -284,35 +241,6 @@
         for i in range(1, minutes * 60, 5):
             self.processor.update_metrics()
 
-    def test_flush_meter_metric_with_prefix(self):
-        """
-        Test the correct rendering of the Graphite report for
-        a meter metric when a prefix is supplied.
-        """
-        self.configurable_processor.process("gorets:3.0|m")
-
-        self.time_now += 1
-        messages = self.configurable_processor.flush()
-        self.assertEqual(2, len(messages))
-        meter_metric = messages[0].splitlines()
-        self.assertEqual(
-            "test.metric.gorets.count 3.0 %s" % self.time_now,
-            meter_metric[0])
-        self.assertEqual(
-            "test.metric.gorets.mean_rate 3.0 %s" % self.time_now,
-            meter_metric[1])
-        self.assertEqual(
-            "test.metric.gorets.1min_rate 0.0 %s" % self.time_now,
-            meter_metric[2])
-        self.assertEqual(
-            "test.metric.gorets.5min_rate 0.0 %s" % self.time_now,
-            meter_metric[3])
-        self.assertEqual(
-            "test.metric.gorets.15min_rate 0.0 %s" % self.time_now,
-            meter_metric[4])
-        self.assertEqual(
-            "statsd.numStats 1 %s" % self.time_now, messages[1])
-
     def test_flush_meter_metric(self):
         """
         Test the correct rendering of the Graphite report for

=== modified file 'txstatsd/version.py'
--- txstatsd/version.py	2011-09-09 15:17:09 +0000
+++ txstatsd/version.py	2011-09-14 12:06:24 +0000
@@ -1,1 +1,1 @@
-txstatsd = "0.4.0"
+txstatsd = "0.5.0"