Merge lp:~sidnei/txstatsd/no-strings-attached into lp:txstatsd

[Sidnei da Silva]

- Produce a list of tuples when flushing, format when writing.

Produce a list of tuples when flushing, format when writing.

[Lucio Torre (lucio.torre)]

you are the god of refactoring

review: Approve

=== modified file 'txstatsd/metrics/countermetric.py'
--- txstatsd/metrics/countermetric.py	2011-09-14 12:01:10 +0000
+++ txstatsd/metrics/countermetric.py	2011-12-02 17:13:07 +0000
@@ -1,6 +1,4 @@
-
 import math
-from string import Template
 
 from txstatsd.metrics.metric import Metric
 
@@ -49,9 +47,6 @@
 class CounterMetricReporter(object):
     """An incrementing and decrementing counter metric."""
 
-    MESSAGE = (
-        "$prefix%(key)s.count %(count)s %(timestamp)s\n")
-
     def __init__(self, name, prefix=""):
         """Construct a metric we expect to be periodically updated.
 
@@ -60,17 +55,13 @@
         self.name = name
 
         if prefix:
-            prefix += '.'
-        self.message = Template(CounterMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
-
+            prefix += "."
+        self.prefix = prefix
         self.count = 0
 
     def mark(self, value):
         self.count = value
 
     def report(self, timestamp):
-        return self.message % {
-            "key": self.name,
-            "count": math.trunc(self.count),
-            "timestamp": timestamp}
+        return [(self.prefix + self.name + ".count",
+                 math.trunc(self.count), timestamp)]

=== modified file 'txstatsd/metrics/distinctmetric.py'
--- txstatsd/metrics/distinctmetric.py	2011-11-18 17:13:52 +0000
+++ txstatsd/metrics/distinctmetric.py	2011-12-02 17:13:07 +0000
@@ -14,6 +14,7 @@
 from string import Template
 
 from zope.interface import implements
+
 from txstatsd.metrics.metric import Metric
 from txstatsd.itxstatsd import IMetric
 
@@ -106,12 +107,6 @@
     """
     implements(IMetric)
 
-    MESSAGE = (
-        "$prefix%(key)s.count_1min %(count_1min)s %(timestamp)s\n"
-        "$prefix%(key)s.count_1hour %(count_1hour)s %(timestamp)s\n"
-        "$prefix%(key)s.count_1day %(count_1day)s %(timestamp)s\n"
-        "$prefix%(key)s.count %(count)s %(timestamp)s\n")
-
     def __init__(self, name, wall_time_func=time.time, prefix=""):
         """Construct a metric we expect to be periodically updated.
 
@@ -124,9 +119,8 @@
         self.wall_time_func = wall_time_func
         self.counter = SlidingDistinctCounter(32, 32)
         if prefix:
-            prefix += '.'
-        self.message = Template(DistinctMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
+            prefix += "."
+        self.prefix = prefix
 
     def count(self):
         return self.counter.distinct()
@@ -148,10 +142,11 @@
 
     def flush(self, interval, timestamp):
         now = self.wall_time_func()
-        return self.message % {
-            "key": self.name,
-            "count": self.count(),
-            "count_1min": self.count_1min(now),
-            "count_1hour": self.count_1hour(now),
-            "count_1day": self.count_1day(now),
-            "timestamp": timestamp}
+        metrics = []
+        items = {".count": self.count(),
+                 ".count_1min": self.count_1min(now),
+                 ".count_1hour": self.count_1hour(now),
+                 ".count_1day": self.count_1day(now)}
+        for item, value in items.iteritems():
+            metrics.append((self.prefix + self.name + item, value, timestamp))
+        return metrics

=== modified file 'txstatsd/metrics/extendedmetrics.py'
--- txstatsd/metrics/extendedmetrics.py	2011-11-28 17:14:10 +0000
+++ txstatsd/metrics/extendedmetrics.py	2011-12-02 17:13:07 +0000
@@ -5,6 +5,7 @@
 
 
 class ExtendedMetrics(Metrics):
+
     def __init__(self, connection=None, namespace=""):
         """A convenience class for reporting metric samples
         to a C{txstatsd} server configured with the

=== modified file 'txstatsd/metrics/gaugemetric.py'
--- txstatsd/metrics/gaugemetric.py	2011-10-01 04:05:34 +0000
+++ txstatsd/metrics/gaugemetric.py	2011-12-02 17:13:07 +0000
@@ -27,9 +27,6 @@
 class GaugeMetricReporter(object):
     """A gauge metric is an instantaneous reading of a particular value."""
 
-    MESSAGE = (
-        "$prefix%(key)s.value %(value)s %(timestamp)s\n")
-
     def __init__(self, name, prefix=""):
         """Construct a metric we expect to be periodically updated.
 
@@ -38,17 +35,12 @@
         self.name = name
 
         if prefix:
-            prefix += '.'
-        self.message = Template(GaugeMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
-
+            prefix += "."
+        self.prefix = prefix
         self.value = 0
 
     def mark(self, value):
         self.value = value
 
     def report(self, timestamp):
-        return self.message % {
-            "key": self.name,
-            "value": self.value,
-            "timestamp": timestamp}
+        return [(self.prefix + self.name + ".value", self.value, timestamp)]

=== modified file 'txstatsd/metrics/histogrammetric.py'
--- txstatsd/metrics/histogrammetric.py	2011-09-14 12:01:10 +0000
+++ txstatsd/metrics/histogrammetric.py	2011-12-02 17:13:07 +0000
@@ -1,8 +1,4 @@
-
 import math
-import sys
-
-from string import Template
 
 from txstatsd.stats.exponentiallydecayingsample \
     import ExponentiallyDecayingSample
@@ -18,18 +14,6 @@
           <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=""):
         """
@@ -59,9 +43,8 @@
         self.sample = sample
 
         if prefix:
-            prefix += '.'
-        self.message = Template(HistogramMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
+            prefix += "."
+        self.prefix = prefix
 
         self._min = 0
         self._max = 0
@@ -98,20 +81,22 @@
     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)
+        metrics = []
+        items = {
+            ".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]}
 
-        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}
+        for item, value in items.itervalues():
+            metrics.append((self.prefix + self.name + item, value, timestamp))
+        return metrics
 
     def min(self):
         """Returns the smallest recorded value."""
@@ -192,4 +177,4 @@
             new_values[0] = new_m
             new_values[1] = new_s
 
-        self.variance = new_values
\ No newline at end of file
+        self.variance = new_values

=== modified file 'txstatsd/metrics/metermetric.py'
--- txstatsd/metrics/metermetric.py	2011-09-09 15:17:09 +0000
+++ txstatsd/metrics/metermetric.py	2011-12-02 17:13:07 +0000
@@ -1,6 +1,3 @@
-
-from string import Template
-
 import time
 
 from txstatsd.metrics.metric import Metric
@@ -44,13 +41,6 @@
     <http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average>}
     """
 
-    MESSAGE = (
-        "$prefix%(key)s.count %(count)s %(timestamp)s\n"
-        "$prefix%(key)s.mean_rate %(mean_rate)s %(timestamp)s\n"
-        "$prefix%(key)s.1min_rate %(rate_1min)s %(timestamp)s\n"
-        "$prefix%(key)s.5min_rate %(rate_5min)s %(timestamp)s\n"
-        "$prefix%(key)s.15min_rate %(rate_15min)s %(timestamp)s\n")
-
     def __init__(self, name, wall_time_func=time.time, prefix=""):
         """Construct a metric we expect to be periodically updated.
 
@@ -61,9 +51,8 @@
         self.wall_time_func = wall_time_func
 
         if prefix:
-            prefix += '.'
-        self.message = Template(MeterMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
+            prefix += "."
+        self.prefix = prefix
 
         self.m1_rate = Ewma.one_minute_ewma()
         self.m5_rate = Ewma.five_minute_ewma()
@@ -85,14 +74,17 @@
         self.m15_rate.tick()
 
     def report(self, timestamp):
-        return self.message % {
-            "key": self.name,
-            "count": self.count,
-            "mean_rate": self.mean_rate(),
-            "rate_1min": self.one_minute_rate(),
-            "rate_5min": self.five_minute_rate(),
-            "rate_15min": self.fifteen_minute_rate(),
-            "timestamp": timestamp}
+        metrics = []
+        items = {".count": self.count,
+                 ".mean_rate": self.mean_rate(),
+                 ".1min_rate": self.one_minute_rate(),
+                 ".5min_rate": self.five_minute_rate(),
+                 ".15min_rate": self.fifteen_minute_rate()}
+
+        for item, value in items.iteritems():
+            metrics.append((self.prefix  + self.name + item,
+                            round(value, 6), timestamp))
+        return metrics
 
     def fifteen_minute_rate(self):
         return self.m15_rate.rate

=== modified file 'txstatsd/metrics/timermetric.py'
--- txstatsd/metrics/timermetric.py	2011-11-28 16:24:39 +0000
+++ txstatsd/metrics/timermetric.py	2011-12-02 17:13:07 +0000
@@ -39,18 +39,6 @@
     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.
 
@@ -63,14 +51,13 @@
         self.wall_time_func = wall_time_func
 
         if prefix:
-            prefix += '.'
-        self.message = Template(TimerMetricReporter.MESSAGE).substitute(
-            prefix=prefix)
+            prefix += "."
+        self.prefix = prefix
 
         sample = ExponentiallyDecayingSample(1028, 0.015)
         self.histogram = HistogramMetricReporter(sample)
         self.meter = MeterMetricReporter(
-            'calls', wall_time_func=self.wall_time_func)
+            "calls", wall_time_func=self.wall_time_func)
         self.clear()
 
     def clear(self):
@@ -137,17 +124,19 @@
     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)
+        metrics = []
+        items = {".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]}
 
-        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}
+        for item, value in items.iteritems():
+            metrics.append((self.prefix + self.name + item,
+                            round(value, 6), timestamp))
+        return metrics

=== modified file 'txstatsd/server/configurableprocessor.py'
--- txstatsd/server/configurableprocessor.py	2011-11-24 13:15:59 +0000
+++ txstatsd/server/configurableprocessor.py	2011-12-02 17:13:07 +0000
@@ -23,18 +23,18 @@
       duration statistics, plus throughput statistics.
     """
 
-    METRICS_SUMMARY = "statsd.numStats %s %s\n"
+    METRICS_SUMMARY = "statsd.numStats"
 
     def __init__(self, time_function=time.time, message_prefix="", plugins=None):
         super(ConfigurableMessageProcessor, self).__init__(
             time_function=time_function, plugins=plugins)
 
         if message_prefix:
-            self.metrics_summary = message_prefix + '.' + \
-                ConfigurableMessageProcessor.METRICS_SUMMARY
+            self.metrics_summary = (
+                message_prefix + "." + 
+                ConfigurableMessageProcessor.METRICS_SUMMARY)
         else:
-            self.metrics_summary = \
-                ConfigurableMessageProcessor.METRICS_SUMMARY
+            self.metrics_summary = ConfigurableMessageProcessor.METRICS_SUMMARY
 
         self.message_prefix = message_prefix
         self.gauge_metrics = {}
@@ -86,8 +86,8 @@
         metrics = []
         events = 0
         for metric in self.counter_metrics.itervalues():
-            message = metric.report(timestamp)
-            metrics.append(message)
+            messages = metric.report(timestamp)
+            metrics.extend(messages)
             events += 1
 
         return (metrics, events)
@@ -96,8 +96,8 @@
         metrics = []
         events = 0
         for metric in self.gauge_metrics.itervalues():
-            message = metric.report(timestamp)
-            metrics.append(message)
+            messages = metric.report(timestamp)
+            metrics.extend(messages)
             events += 1
 
         return (metrics, events)
@@ -106,14 +106,14 @@
         metrics = []
         events = 0
         for metric in self.timer_metrics.itervalues():
-            message = metric.report(timestamp)
-            metrics.append(message)
+            messages = metric.report(timestamp)
+            metrics.extend(messages)
             events += 1
 
         return (metrics, events)
 
     def flush_metrics_summary(self, messages, num_stats, timestamp):
-        messages.append(self.metrics_summary % (num_stats, timestamp))
+        messages.append((self.metrics_summary, num_stats, timestamp))
 
     def update_metrics(self):
         super(ConfigurableMessageProcessor, self).update_metrics()

=== modified file 'txstatsd/server/loggingprocessor.py'
--- txstatsd/server/loggingprocessor.py	2011-11-18 17:13:52 +0000
+++ txstatsd/server/loggingprocessor.py	2011-12-02 17:13:07 +0000
@@ -28,9 +28,9 @@
 
         def log_metrics(metrics):
             for metric in metrics.itervalues():
-                report = metric.report(timestamp)
-                for measurement in report.splitlines():
-                    self.logger.info(measurement)
+                messages = metric.report(timestamp)
+                for measurement in messages:
+                    self.logger.info("%s %s %s" % measurement)
 
         log_metrics(self.counter_metrics)
         log_metrics(self.gauge_metrics)
@@ -38,7 +38,6 @@
         log_metrics(self.timer_metrics)
         
         for metric in self.plugin_metrics.itervalues():
-            report = metric.flush(interval, timestamp)
-            for measurement in report.splitlines():
-                self.logger.info(measurement)
+            for measurement in metric.flush(interval, timestamp):
+                self.logger.info("%s %s %s" % measurement)
 

=== modified file 'txstatsd/server/processor.py'
--- txstatsd/server/processor.py	2011-11-24 13:15:59 +0000
+++ txstatsd/server/processor.py	2011-12-02 17:13:07 +0000
@@ -34,28 +34,15 @@
     <txstatsd.server.configurableprocessor.ConfigurableMessageProcessor>}).
     """
 
-    COUNTERS_MESSAGE = (
-        "stats.%(key)s %(value)s %(timestamp)s\n"
-        "stats_counts.%(key)s %(count)s %(timestamp)s\n")
-
-    TIMERS_MESSAGE = (
-        "stats.timers.%(key)s.mean %(mean)s %(timestamp)s\n"
-        "stats.timers.%(key)s.upper %(upper)s %(timestamp)s\n"
-        "stats.timers.%(key)s.upper_%(percent)s %(threshold_upper)s"
-            " %(timestamp)s\n"
-        "stats.timers.%(key)s.lower %(lower)s %(timestamp)s\n"
-        "stats.timers.%(key)s.count %(count)s %(timestamp)s\n")
-
-    GAUGE_METRIC_MESSAGE = (
-        "stats.gauge.%(key)s.value %(value)s %(timestamp)s\n")
-
     def __init__(self, time_function=time.time, plugins=None):
         self.time_function = time_function
 
-        self.counters_message = MessageProcessor.COUNTERS_MESSAGE
-        self.timers_message = MessageProcessor.TIMERS_MESSAGE
-        self.gauge_metric_message = MessageProcessor.GAUGE_METRIC_MESSAGE
-
+        self.stats_prefix = "stats."
+        self.metrics_summary = "statsd.numStats"
+        self.count_prefix = "stats_counts."
+        self.timer_prefix = self.stats_prefix + "timers."
+        self.gauge_prefix = self.stats_prefix + "gauge."
+    
         self.timer_metrics = {}
         self.counter_metrics = {}
         self.gauge_metrics = deque()
@@ -197,27 +184,27 @@
         counter_metrics, events = self.flush_counter_metrics(interval,
                                                              timestamp)
         if events > 0:
-            messages.extend(counter_metrics)
+            messages.extend(sorted(counter_metrics))
             num_stats += events
 
         timer_metrics, events = self.flush_timer_metrics(percent, timestamp)
         if events > 0:
-            messages.extend(timer_metrics)
+            messages.extend(sorted(timer_metrics))
             num_stats += events
 
         gauge_metrics, events = self.flush_gauge_metrics(timestamp)
         if events > 0:
-            messages.extend(gauge_metrics)
+            messages.extend(sorted(gauge_metrics))
             num_stats += events
 
         meter_metrics, events = self.flush_meter_metrics(timestamp)
         if events > 0:
-            messages.extend(meter_metrics)
+            messages.extend(sorted(meter_metrics))
             num_stats += events
 
         plugin_metrics, events = self.flush_plugin_metrics(interval, timestamp)
         if events > 0:
-            messages.extend(plugin_metrics)
+            messages.extend(sorted(plugin_metrics))
             num_stats += events
 
         self.flush_metrics_summary(messages, num_stats, timestamp)
@@ -230,12 +217,8 @@
             self.counter_metrics[key] = 0
 
             value = count / interval
-            message = self.counters_message % {
-                "key": key,
-                "value": value,
-                "count": count,
-                "timestamp": timestamp}
-            metrics.append(message)
+            metrics.append((self.stats_prefix + key, value, timestamp))
+            metrics.append((self.count_prefix + key, count, timestamp))
             events += 1
 
         return (metrics, events)
@@ -264,16 +247,13 @@
                     threshold_upper = timers[-1]
                     mean = sum(timers) / index
 
-                message = self.timers_message % {
-                    "key": key,
-                    "mean": mean,
-                    "upper": upper,
-                    "percent": percent,
-                    "threshold_upper": threshold_upper,
-                    "lower": lower,
-                    "count": count,
-                    "timestamp": timestamp}
-                metrics.append(message)
+                items = {".mean": mean,
+                         ".upper": upper,
+                         ".upper_%s" % percent: threshold_upper,
+                         ".lower": lower,
+                         ".count": count}
+                for item, value in items.iteritems():
+                    metrics.append((self.timer_prefix + key + item, value, timestamp))
                 events += 1
 
         return (metrics, events)
@@ -285,11 +265,7 @@
             value = metric[0]
             key = metric[1]
 
-            message = self.gauge_metric_message % {
-                "key": key,
-                "value": value,
-                "timestamp": timestamp}
-            metrics.append(message)
+            metrics.append((self.gauge_prefix + key + ".value", value, timestamp))
             events += 1
 
         self.gauge_metrics.clear()
@@ -300,8 +276,8 @@
         metrics = []
         events = 0
         for metric in self.meter_metrics.itervalues():
-            message = metric.report(timestamp)
-            metrics.append(message)
+            messages = metric.report(timestamp)
+            metrics.extend(messages)
             events += 1
 
         return (metrics, events)
@@ -311,14 +287,14 @@
         events = 0
 
         for metric in self.plugin_metrics.itervalues():
-            message = metric.flush(interval, timestamp)
-            metrics.append(message)
+            messages = metric.flush(interval, timestamp)
+            metrics.extend(messages)
             events += 1
 
         return (metrics, events)
 
     def flush_metrics_summary(self, messages, num_stats, timestamp):
-        messages.append("statsd.numStats %s %s\n" % (num_stats, timestamp))
+        messages.append((self.metrics_summary, num_stats, timestamp))
 
     def update_metrics(self):
         for metric in self.meter_metrics.itervalues():

=== modified file 'txstatsd/server/protocol.py'
--- txstatsd/server/protocol.py	2011-10-28 16:24:03 +0000
+++ txstatsd/server/protocol.py	2011-12-02 17:13:07 +0000
@@ -77,7 +77,7 @@
         """Flush messages queued in the processor to Graphite."""
         for message in self.processor.flush(interval=self.interval):
             if self.connected and not self.paused:
-                self.transport.write(message)
+                self.transport.write("%s %s %s\n" % message)
 
         self.flush_message_graphite_metric()
 

=== modified file 'txstatsd/tests/metrics/test_distinct.py'
--- txstatsd/tests/metrics/test_distinct.py	2011-11-18 20:03:34 +0000
+++ txstatsd/tests/metrics/test_distinct.py	2011-12-02 17:13:07 +0000
@@ -12,6 +12,7 @@
 
 
 class TestHash(TestCase):
+
     def test_hash_chars(self):
         "For one table, all chars map to different chars"
         results = set()
@@ -43,6 +44,7 @@
 
 
 class TestZeros(TestCase):
+
     def test_zeros(self):
         self.assertEquals(distinct.zeros(1), 0)
         self.assertEquals(distinct.zeros(2), 1)
@@ -53,6 +55,7 @@
 
 
 class TestDistinct(TestCase):
+
     def test_all(self):
         random.seed(1)
 
@@ -65,6 +68,7 @@
 
 
 class TestDistinctMetricReporter(TestCase):
+
     def test_reports(self):
         random.seed(1)
         _wall_time = [0]
@@ -80,7 +84,6 @@
         self.assertTrue(abs(dmr.count_1min(now) - 1) < 2)
         self.assertTrue(abs(dmr.count_1hour(now) - 72) < 15)
         self.assertTrue(abs(dmr.count_1day(now) - 1728) < 500)
-        self.assertTrue("count_1hour" in dmr.flush(1, now))
 
 
 class TestPlugin(TestCase):

=== modified file 'txstatsd/tests/test_configurableprocessor.py'
--- txstatsd/tests/test_configurableprocessor.py	2011-11-18 17:13:52 +0000
+++ txstatsd/tests/test_configurableprocessor.py	2011-12-02 17:13:07 +0000
@@ -20,9 +20,8 @@
         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].splitlines()[0])
+        self.assertEqual(("gorets.count", 17, 42), messages[0])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[1])
 
     def test_flush_counter_with_prefix(self):
         """
@@ -33,10 +32,9 @@
         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("test.metric.statsd.numStats 1 42",
-                         messages[1].splitlines()[0])
+        self.assertEqual(("test.metric.gorets.count", 17, 42), messages[0])
+        self.assertEqual(("test.metric.statsd.numStats", 1, 42),
+                         messages[1])
         
     def test_flush_plugin(self):
         """
@@ -47,8 +45,8 @@
             plugins=[distinct_metric_factory])
         configurable_processor.process("gorets:17|pd")
         messages = configurable_processor.flush()
-        self.assertEqual(2, len(messages))
-        self.assertTrue("test.metric.gorets" in messages[0])
+        self.assertEqual(5, len(messages))
+        self.assertEquals(("test.metric.gorets.count", 1, 42), messages[0])
         
         
     def test_flush_single_timer_single_time(self):
@@ -62,19 +60,18 @@
         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].splitlines()[0])
+        self.assertEqual(11, len(messages))
+        self.assertEqual(("glork.75percentile", 24.0, 42), messages[0])
+        self.assertEqual(("glork.95percentile", 24.0, 42), messages[1])
+        self.assertEqual(("glork.98percentile", 24.0, 42), messages[2])
+        self.assertEqual(("glork.999percentile", 24.0, 42), messages[3])
+        self.assertEqual(("glork.99percentile", 24.0, 42), messages[4])
+        self.assertEqual(("glork.max", 24.0, 42), messages[5])
+        self.assertEqual(("glork.mean", 24.0, 42), messages[6])
+        self.assertEqual(("glork.median", 24.0, 42), messages[7])
+        self.assertEqual(("glork.min", 24.0, 42), messages[8])
+        self.assertEqual(("glork.stddev", 0.0, 42), messages[9])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[10])
 
     def test_flush_single_timer_multiple_times(self):
         """
@@ -97,19 +94,18 @@
         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].splitlines()[0])
+        self.assertEqual(11, len(messages))
+        self.assertEqual(("glork.75percentile", 27.75, 42), messages[0])
+        self.assertEqual(("glork.95percentile", 42.0, 42), messages[1])
+        self.assertEqual(("glork.98percentile", 42.0, 42), messages[2])
+        self.assertEqual(("glork.999percentile", 42.0, 42), messages[3])
+        self.assertEqual(("glork.99percentile", 42.0, 42), messages[4])
+        self.assertEqual(("glork.max", 42.0, 42), messages[5])
+        self.assertEqual(("glork.mean", 18.0, 42), messages[6])
+        self.assertEqual(("glork.median", 15.5, 42), messages[7])
+        self.assertEqual(("glork.min", 4.0, 42), messages[8])
+        self.assertEqual(("glork.stddev", 13.490738, 42), messages[9])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[10])
 
 
 class FlushMeterMetricMessagesTest(TestCase):
@@ -135,23 +131,16 @@
 
         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(
-            "test.metric.statsd.numStats 1 %s" % self.time_now,
-            messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(("test.metric.gorets.15min_rate", 0.0, self.time_now),
+                         messages[0])
+        self.assertEqual(("test.metric.gorets.1min_rate", 0.0, self.time_now),
+                         messages[1])
+        self.assertEqual(("test.metric.gorets.5min_rate", 0.0, self.time_now),
+                         messages[2])
+        self.assertEqual(("test.metric.gorets.count", 3.0, self.time_now),
+                         messages[3])
+        self.assertEqual(("test.metric.gorets.mean_rate", 3.0, self.time_now),
+                         messages[4])
+        self.assertEqual(("test.metric.statsd.numStats", 1, self.time_now),
+                         messages[5])

=== modified file 'txstatsd/tests/test_loggingprocessor.py'
--- txstatsd/tests/test_loggingprocessor.py	2011-11-18 17:13:52 +0000
+++ txstatsd/tests/test_loggingprocessor.py	2011-12-02 17:13:07 +0000
@@ -8,7 +8,7 @@
 
 class FakeMeterMetric(object):
     def report(self, *args):
-        return 'Sample report'
+        return [('Sample report', 1, 2)]
 
 class TestLogger(object):
     def __init__(self):
@@ -44,7 +44,9 @@
         metric = FakeMeterMetric()
         processor.meter_metrics['test'] = metric
         processor.flush()
-        self.assertEqual(metric.report() + "\n", logger.log)
+        expected = "\n".join(["%s %s %s" % message
+                              for message in metric.report()])
+        self.assertEqual(expected + "\n", logger.log)
 
     def test_logger_plugin(self):
         logger = TestLogger()
@@ -53,7 +55,9 @@
             time_function=lambda: 42)
         processor.process("gorets:17|pd")
         processor.flush()
-        self.assertEqual(processor.plugin_metrics['gorets'].flush(
-                                10, processor.time_function()),
-                         logger.log)
+        messages = processor.plugin_metrics['gorets'].flush(
+            10, processor.time_function())
+        expected = "\n".join(["%s %s %s" % message
+                              for message in messages])
+        self.assertEqual(expected + "\n", logger.log)
 

=== modified file 'txstatsd/tests/test_processor.py'
--- txstatsd/tests/test_processor.py	2011-11-18 20:03:34 +0000
+++ txstatsd/tests/test_processor.py	2011-12-02 17:13:07 +0000
@@ -130,7 +130,7 @@
         Flushing the message processor when there are no stats available should
         still produce one message where C{statsd.numStats} is set to zero.
         """
-        self.assertEqual(["statsd.numStats 0 42\n"], self.processor.flush())
+        self.assertEqual([("statsd.numStats", 0, 42)], self.processor.flush())
 
     def test_flush_counter(self):
         """
@@ -139,11 +139,10 @@
         """
         self.processor.counter_metrics["gorets"] = 42
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        counters = messages[0].splitlines()
-        self.assertEqual("stats.gorets 4 42", counters[0])
-        self.assertEqual("stats_counts.gorets 42 42", counters[1])
-        self.assertEqual("statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(3, len(messages))
+        self.assertEqual(("stats.gorets", 4, 42), messages[0])
+        self.assertEqual(("stats_counts.gorets", 42, 42), messages[1])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[2])
         self.assertEqual(0, self.processor.counter_metrics["gorets"])
 
     def test_flush_counter_one_second_interval(self):
@@ -153,11 +152,10 @@
         """
         self.processor.counter_metrics["gorets"] = 42
         messages = self.processor.flush(interval=1000)
-        self.assertEqual(2, len(messages))
-        counters = messages[0].splitlines()
-        self.assertEqual("stats.gorets 42 42", counters[0])
-        self.assertEqual("stats_counts.gorets 42 42", counters[1])
-        self.assertEqual("statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(3, len(messages))
+        self.assertEqual(("stats.gorets", 42, 42), messages[0])
+        self.assertEqual(("stats_counts.gorets", 42, 42), messages[1])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[2])
         self.assertEqual(0, self.processor.counter_metrics["gorets"])
 
     def test_flush_single_timer_single_time(self):
@@ -168,14 +166,13 @@
         """
         self.processor.timer_metrics["glork"] = [24]
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        timers = messages[0].splitlines()
-        self.assertEqual("stats.timers.glork.mean 24 42", timers[0])
-        self.assertEqual("stats.timers.glork.upper 24 42", timers[1])
-        self.assertEqual("stats.timers.glork.upper_90 24 42", timers[2])
-        self.assertEqual("stats.timers.glork.lower 24 42", timers[3])
-        self.assertEqual("stats.timers.glork.count 1 42", timers[4])
-        self.assertEqual("statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(("stats.timers.glork.count", 1, 42), messages[0])
+        self.assertEqual(("stats.timers.glork.lower", 24, 42), messages[1])
+        self.assertEqual(("stats.timers.glork.mean", 24, 42), messages[2])
+        self.assertEqual(("stats.timers.glork.upper", 24, 42), messages[3])
+        self.assertEqual(("stats.timers.glork.upper_90", 24, 42), messages[4])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[5])
         self.assertEqual([], self.processor.timer_metrics["glork"])
 
     def test_flush_single_timer_multiple_times(self):
@@ -189,14 +186,13 @@
         """
         self.processor.timer_metrics["glork"] = [4, 8, 15, 16, 23, 42]
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        timers = messages[0].splitlines()
-        self.assertEqual("stats.timers.glork.mean 13 42", timers[0])
-        self.assertEqual("stats.timers.glork.upper 42 42", timers[1])
-        self.assertEqual("stats.timers.glork.upper_90 23 42", timers[2])
-        self.assertEqual("stats.timers.glork.lower 4 42", timers[3])
-        self.assertEqual("stats.timers.glork.count 6 42", timers[4])
-        self.assertEqual("statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(("stats.timers.glork.count", 6, 42), messages[0])
+        self.assertEqual(("stats.timers.glork.lower", 4, 42), messages[1])
+        self.assertEqual(("stats.timers.glork.mean", 13, 42), messages[2])
+        self.assertEqual(("stats.timers.glork.upper", 42, 42), messages[3])
+        self.assertEqual(("stats.timers.glork.upper_90", 23, 42), messages[4])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[5])
         self.assertEqual([], self.processor.timer_metrics["glork"])
 
     def test_flush_single_timer_50th_percentile(self):
@@ -213,14 +209,13 @@
         """
         self.processor.timer_metrics["glork"] = [4, 8, 15, 16, 23, 42]
         messages = self.processor.flush(percent=50)
-        self.assertEqual(2, len(messages))
-        timers = messages[0].splitlines()
-        self.assertEqual("stats.timers.glork.mean 9 42", timers[0])
-        self.assertEqual("stats.timers.glork.upper 42 42", timers[1])
-        self.assertEqual("stats.timers.glork.upper_50 15 42", timers[2])
-        self.assertEqual("stats.timers.glork.lower 4 42", timers[3])
-        self.assertEqual("stats.timers.glork.count 6 42", timers[4])
-        self.assertEqual("statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(("stats.timers.glork.count", 6, 42), messages[0])
+        self.assertEqual(("stats.timers.glork.lower", 4, 42), messages[1])
+        self.assertEqual(("stats.timers.glork.mean", 9, 42), messages[2])
+        self.assertEqual(("stats.timers.glork.upper", 42, 42), messages[3])
+        self.assertEqual(("stats.timers.glork.upper_50", 15, 42), messages[4])
+        self.assertEqual(("statsd.numStats", 1, 42), messages[5])
         self.assertEqual([], self.processor.timer_metrics["glork"])
 
     def test_flush_gauge_metric(self):
@@ -233,11 +228,10 @@
 
         messages = self.processor.flush()
         self.assertEqual(2, len(messages))
-        gauge_metric = messages[0].splitlines()
-        self.assertEqual(
-            "stats.gauge.gorets.value 9.6 42", gauge_metric[0])
-        self.assertEqual(
-            "statsd.numStats 1 42", messages[1].splitlines()[0])
+        self.assertEqual(
+            ("stats.gauge.gorets.value", 9.6, 42), messages[0])
+        self.assertEqual(
+            ("statsd.numStats", 1, 42), messages[1])
         self.assertEqual(0, len(self.processor.gauge_metrics))
 
     def test_flush_distinct_metric(self):
@@ -249,12 +243,11 @@
         self.processor.process("gorets:item|pd")
 
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        metrics = messages[0]
-        self.assertTrue("stats.pdistinct.gorets.count " in metrics)
-        self.assertTrue("stats.pdistinct.gorets.count_1hour" in metrics)
-        self.assertTrue("stats.pdistinct.gorets.count_1min" in metrics)
-        self.assertTrue("stats.pdistinct.gorets.count_1day" in metrics)
+        self.assertEqual(5, len(messages))
+        self.assertEqual(("stats.pdistinct.gorets.count", 1, 42), messages[0])
+        self.assertEqual(("stats.pdistinct.gorets.count_1day", 5552568545, 42), messages[1])
+        self.assertEqual(("stats.pdistinct.gorets.count_1hour", 5552568545, 42), messages[2])
+        self.assertEqual(("stats.pdistinct.gorets.count_1min", 5552568545, 42), messages[3])
 
     def test_flush_plugin_arguments(self):
         """Test the passing of arguments for flush."""
@@ -262,6 +255,7 @@
         class FakeMetric(object):
             def flush(self, interval, timestamp):
                 self.data = interval, timestamp
+                return []
 
         self.processor.plugin_metrics["somemetric"] = FakeMetric()
         self.processor.flush(41000)
@@ -291,26 +285,25 @@
 
         self.time_now += 1
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        meter_metric = messages[0].splitlines()
-        self.assertEqual(
-            "stats.meter.gorets.count 3.0 %s" % self.time_now,
-            meter_metric[0])
-        self.assertEqual(
-            "stats.meter.gorets.mean_rate 3.0 %s" % self.time_now,
-            meter_metric[1])
-        self.assertEqual(
-            "stats.meter.gorets.1min_rate 0.0 %s" % self.time_now,
-            meter_metric[2])
-        self.assertEqual(
-            "stats.meter.gorets.5min_rate 0.0 %s" % self.time_now,
-            meter_metric[3])
-        self.assertEqual(
-            "stats.meter.gorets.15min_rate 0.0 %s" % self.time_now,
-            meter_metric[4])
-        self.assertEqual(
-            "statsd.numStats 1 %s" % self.time_now,
-            messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(
+            ("stats.meter.gorets.15min_rate", 0.0, self.time_now),
+            messages[0])
+        self.assertEqual(
+            ("stats.meter.gorets.1min_rate", 0.0, self.time_now),
+            messages[1])
+        self.assertEqual(
+            ("stats.meter.gorets.5min_rate", 0.0, self.time_now),
+            messages[2])
+        self.assertEqual(
+            ("stats.meter.gorets.count", 3.0, self.time_now),
+            messages[3])
+        self.assertEqual(
+            ("stats.meter.gorets.mean_rate", 3.0, self.time_now),
+            messages[4])
+        self.assertEqual(
+            ("statsd.numStats", 1, self.time_now),
+            messages[5])
 
         # As we are employing the expected results from test_ewma.py
         # we perform the initial tick(), before advancing the clock 60sec.
@@ -319,22 +312,21 @@
         self.mark_minutes(1)
         self.time_now += 60
         messages = self.processor.flush()
-        self.assertEqual(2, len(messages))
-        meter_metric = messages[0].splitlines()
-        self.assertEqual(
-            "stats.meter.gorets.count 3.0 %s" % self.time_now,
-            meter_metric[0])
-        self.assertTrue(
-            meter_metric[1].startswith(
-                "stats.meter.gorets.mean_rate 0.04918032"))
-        self.assertTrue(
-            meter_metric[2].startswith(
-                "stats.meter.gorets.1min_rate 0.22072766"))
-        self.assertTrue(
-            meter_metric[3].startswith(
-                "stats.meter.gorets.5min_rate 0.49123845"))
-        self.assertTrue(
-            meter_metric[4].startswith(
-                "stats.meter.gorets.15min_rate 0.5613041"))
-        self.assertEqual(
-            "statsd.numStats 1 %s" % self.time_now, messages[1].splitlines()[0])
+        self.assertEqual(6, len(messages))
+        self.assertEqual(
+            ("stats.meter.gorets.15min_rate", 0.561304, self.time_now),
+            messages[0])
+        self.assertEqual(
+            ("stats.meter.gorets.1min_rate", 0.220728, self.time_now),
+            messages[1])
+        self.assertEqual(
+            ("stats.meter.gorets.5min_rate", 0.491238, self.time_now),
+            messages[2])
+        self.assertEqual(
+            ("stats.meter.gorets.count", 3.0, self.time_now),
+            messages[3])
+        self.assertEqual(
+            ("stats.meter.gorets.mean_rate", 0.049180, self.time_now),
+            messages[4])
+        self.assertEqual(
+            ("statsd.numStats", 1, self.time_now), messages[5])

=== modified file 'txstatsd/tests/test_protocol.py'
--- txstatsd/tests/test_protocol.py	2011-10-19 17:59:44 +0000
+++ txstatsd/tests/test_protocol.py	2011-12-02 17:13:07 +0000
@@ -13,9 +13,9 @@
         self.sequence = 0
 
     def flush(self, interval):
-        """Always produce a sequence number followed by 9 lines of output"""
+        """Always produce a sequence number"""
         self.sequence += 1
-        return [str(self.sequence)]
+        return [("foo.bar", str(self.sequence), 42)]
 
 
 class FakeTransport(object):
@@ -68,7 +68,7 @@
         self.clock.advance(1)
         self.assertEqual(2, len(self.transport.messages))
         # Last message is the message graphite metric.
-        self.assertEqual("3", self.transport.messages[-2])
+        self.assertEqual("foo.bar 3 42\n", self.transport.messages[-2])
 
     def test_stopped_producer_discards_everything(self):
         """