← Back to branch summary

~landscape/txstatsd/trunk

« back to all changes in this revision

Viewing changes to txstatsd/tests/test_processor.py

  • Committer: Sidnei da Silva
  • Date: 2011-07-27 20:35:23 UTC
  • mfrom: (11.2.6 txstatsd)
  • Revision ID: sidnei.da.silva@canonical.com-20110727203523-mmhr5clzkfyqva8f
- Merge from lp:txstatsd

Show diffs side-by-side

added added

removed removed

Lines of Context:
txstatsd/tests/test_processor.py
1
1
from unittest import TestCase
2
2
 
3
 
from txstatsd.processor import MessageProcessor
 
3
from txstatsd.server.processor import MessageProcessor
4
4
 
5
5
 
6
6
class TestMessageProcessor(MessageProcessor):
25
25
        unit. 'c' is simply used to signal that this is a counter message.
26
26
        """
27
27
        self.processor.process("gorets:1|c")
28
 
        self.assertEqual(1, len(self.processor.counters))
29
 
        self.assertEqual(1.0, self.processor.counters["gorets"])
 
28
        self.assertEqual(1, len(self.processor.counter_metrics))
 
29
        self.assertEqual(1.0, self.processor.counter_metrics["gorets"])
30
30
 
31
31
    def test_receive_counter_rate(self):
32
32
        """
37
37
        counter value.
38
38
        """
39
39
        self.processor.process("gorets:1|c|@0.1")
40
 
        self.assertEqual(1, len(self.processor.counters))
41
 
        self.assertEqual(10.0, self.processor.counters["gorets"])
 
40
        self.assertEqual(1, len(self.processor.counter_metrics))
 
41
        self.assertEqual(10.0, self.processor.counter_metrics["gorets"])
42
42
 
43
43
    def test_receive_timer(self):
44
44
        """
46
46
        identifier and '320' is the time in milliseconds.
47
47
        """
48
48
        self.processor.process("glork:320|ms")
49
 
        self.assertEqual(1, len(self.processor.timers))
50
 
        self.assertEqual([320], self.processor.timers["glork"])
 
49
        self.assertEqual(1, len(self.processor.timer_metrics))
 
50
        self.assertEqual([320], self.processor.timer_metrics["glork"])
 
51
 
 
52
    def test_receive_gauge_metric(self):
 
53
        """
 
54
        A gauge metric message takes the form:
 
55
        '<name>:<count>|g'.
 
56
        'g' indicates this is a gauge metric message.
 
57
        """
 
58
        self.processor.process("gorets:9.6|g")
 
59
        self.assertEqual(1, len(self.processor.gauge_metrics))
 
60
        self.assertEqual(
 
61
            [9.6, 'gorets'],
 
62
            self.processor.gauge_metrics.pop())
51
63
 
52
64
    def test_receive_message_no_fields(self):
53
65
        """
54
66
        If a timer message has no fields, it is logged and discarded.
55
67
        """
56
68
        self.processor.process("glork")
57
 
        self.assertEqual(0, len(self.processor.timers))
58
 
        self.assertEqual(0, len(self.processor.counters))
 
69
        self.assertEqual(0, len(self.processor.timer_metrics))
 
70
        self.assertEqual(0, len(self.processor.counter_metrics))
59
71
        self.assertEqual(["glork"], self.processor.failures)
60
72
 
61
73
    def test_receive_counter_no_value(self):
63
75
        If a counter message has no value, it is logged and discarded.
64
76
        """
65
77
        self.processor.process("gorets:|c")
66
 
        self.assertEqual(0, len(self.processor.counters))
 
78
        self.assertEqual(0, len(self.processor.counter_metrics))
67
79
        self.assertEqual(["gorets:|c"], self.processor.failures)
68
80
 
69
81
    def test_receive_timer_no_value(self):
71
83
        If a timer message has no value, it is logged and discarded.
72
84
        """
73
85
        self.processor.process("glork:|ms")
74
 
        self.assertEqual(0, len(self.processor.timers))
 
86
        self.assertEqual(0, len(self.processor.timer_metrics))
75
87
        self.assertEqual(["glork:|ms"], self.processor.failures)
76
88
 
77
89
    def test_receive_not_enough_fields(self):
79
91
        If a timer message has not enough fields, it is logged and discarded.
80
92
        """
81
93
        self.processor.process("glork:1")
82
 
        self.assertEqual(0, len(self.processor.timers))
83
 
        self.assertEqual(0, len(self.processor.counters))
 
94
        self.assertEqual(0, len(self.processor.timer_metrics))
 
95
        self.assertEqual(0, len(self.processor.counter_metrics))
84
96
        self.assertEqual(["glork:1"], self.processor.failures)
85
97
 
86
98
    def test_receive_too_many_fields(self):
88
100
        If a timer message has too many fields, it is logged and discarded.
89
101
        """
90
102
        self.processor.process("gorets:1|c|@0.1|yay")
91
 
        self.assertEqual(0, len(self.processor.timers))
92
 
        self.assertEqual(0, len(self.processor.counters))
 
103
        self.assertEqual(0, len(self.processor.timer_metrics))
 
104
        self.assertEqual(0, len(self.processor.counter_metrics))
93
105
        self.assertEqual(["gorets:1|c|@0.1|yay"], self.processor.failures)
94
106
 
95
107
 
110
122
        If a counter is present, flushing it will generate a counter message
111
123
        normalized to the default interval.
112
124
        """
113
 
        self.processor.counters["gorets"] = 42
 
125
        self.processor.counter_metrics["gorets"] = 42
114
126
        messages = self.processor.flush()
115
127
        self.assertEqual(2, len(messages))
116
128
        counters = messages[0].splitlines()
117
129
        self.assertEqual("stats.gorets 4 42", counters[0])
118
130
        self.assertEqual("stats_counts.gorets 42 42", counters[1])
119
131
        self.assertEqual("statsd.numStats 1 42", messages[1])
120
 
        self.assertEqual(0, self.processor.counters["gorets"])
 
132
        self.assertEqual(0, self.processor.counter_metrics["gorets"])
121
133
 
122
134
    def test_flush_counter_one_second_interval(self):
123
135
        """
124
136
        It is possible to flush counters with a one-second interval, in which
125
137
        case the counter value will be unchanged.
126
138
        """
127
 
        self.processor.counters["gorets"] = 42
 
139
        self.processor.counter_metrics["gorets"] = 42
128
140
        messages = self.processor.flush(interval=1000)
129
141
        self.assertEqual(2, len(messages))
130
142
        counters = messages[0].splitlines()
131
143
        self.assertEqual("stats.gorets 42 42", counters[0])
132
144
        self.assertEqual("stats_counts.gorets 42 42", counters[1])
133
145
        self.assertEqual("statsd.numStats 1 42", messages[1])
134
 
        self.assertEqual(0, self.processor.counters["gorets"])
 
146
        self.assertEqual(0, self.processor.counter_metrics["gorets"])
135
147
 
136
148
    def test_flush_single_timer_single_time(self):
137
149
        """
139
151
        threshold_upper, lower, mean will be set to the same value. Timer is
140
152
        reset after flush is called.
141
153
        """
142
 
        self.processor.timers["glork"] = [24]
 
154
        self.processor.timer_metrics["glork"] = [24]
143
155
        messages = self.processor.flush()
144
156
        self.assertEqual(2, len(messages))
145
157
        timers = messages[0].splitlines()
149
161
        self.assertEqual("stats.timers.glork.lower 24 42", timers[3])
150
162
        self.assertEqual("stats.timers.glork.count 1 42", timers[4])
151
163
        self.assertEqual("statsd.numStats 1 42", messages[1])
152
 
        self.assertEqual([], self.processor.timers["glork"])
 
164
        self.assertEqual([], self.processor.timer_metrics["glork"])
153
165
 
154
166
    def test_flush_single_timer_multiple_times(self):
155
167
        """
160
172
        - count will be the count of data points
161
173
        - mean will be the mean value within the 90th percentile
162
174
        """
163
 
        self.processor.timers["glork"] = [4, 8, 15, 16, 23, 42]
 
175
        self.processor.timer_metrics["glork"] = [4, 8, 15, 16, 23, 42]
164
176
        messages = self.processor.flush()
165
177
        self.assertEqual(2, len(messages))
166
178
        timers = messages[0].splitlines()
170
182
        self.assertEqual("stats.timers.glork.lower 4 42", timers[3])
171
183
        self.assertEqual("stats.timers.glork.count 6 42", timers[4])
172
184
        self.assertEqual("statsd.numStats 1 42", messages[1])
173
 
        self.assertEqual([], self.processor.timers["glork"])
 
185
        self.assertEqual([], self.processor.timer_metrics["glork"])
174
186
 
175
187
    def test_flush_single_timer_50th_percentile(self):
176
188
        """
184
196
        - count will be the count of data points
185
197
        - mean will be the mean value within the 50th percentile
186
198
        """
187
 
        self.processor.timers["glork"] = [4, 8, 15, 16, 23, 42]
 
199
        self.processor.timer_metrics["glork"] = [4, 8, 15, 16, 23, 42]
188
200
        messages = self.processor.flush(percent=50)
189
201
        self.assertEqual(2, len(messages))
190
202
        timers = messages[0].splitlines()
194
206
        self.assertEqual("stats.timers.glork.lower 4 42", timers[3])
195
207
        self.assertEqual("stats.timers.glork.count 6 42", timers[4])
196
208
        self.assertEqual("statsd.numStats 1 42", messages[1])
197
 
        self.assertEqual([], self.processor.timers["glork"])
 
209
        self.assertEqual([], self.processor.timer_metrics["glork"])
 
210
 
 
211
    def test_flush_gauge_metric(self):
 
212
        """
 
213
        Test the correct rendering of the Graphite report for
 
214
        a gauge metric.
 
215
        """
 
216
 
 
217
        self.processor.process("gorets:9.6|g")
 
218
 
 
219
        messages = self.processor.flush()
 
220
        self.assertEqual(2, len(messages))
 
221
        gauge_metric = messages[0].splitlines()
 
222
        self.assertEqual(
 
223
            "stats.gauge.gorets.value 9.6 42", gauge_metric[0])
 
224
        self.assertEqual(
 
225
            "statsd.numStats 1 42", messages[1])
 
226
        self.assertEqual(0, len(self.processor.gauge_metrics))