Python MetricsAggregator.flush方法代码示例

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_gauge(self):
        stats = MetricsAggregator('myhost', 1)

        # Track some counters.
        stats.submit('my.first.gauge:1|g')
        stats.submit('my.first.gauge:5|g')
        stats.submit('my.second.gauge:1.5|g')

        # Ensure they roll up nicely.
        time.sleep(1)
        metrics = self.sort_metrics(stats.flush(False))
        assert len(metrics) == 2

        first, second = metrics

        nt.assert_equals(first['metric'], 'my.first.gauge')
        nt.assert_equals(first['points'][0][1], 5)
        nt.assert_equals(first['host'], 'myhost')

        nt.assert_equals(second['metric'], 'my.second.gauge')
        nt.assert_equals(second['points'][0][1], 1.5)


        # Ensure they shall be flushed no more.
        metrics = stats.flush(False)
        assert not len(metrics)

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_histogram(self):
        stats = MetricsAggregator('myhost')

        # Sample all numbers between 1-100 many times. This
        # means our percentiles should be relatively close to themselves.
        percentiles = range(100)
        random.shuffle(percentiles) # in place
        for i in percentiles:
            for j in xrange(20):
                for type_ in ['h', 'ms']:
                    m = 'my.p:%s|%s' % (i, type_)
                    stats.submit_packets(m)

        metrics = self.sort_metrics(stats.flush())

        def assert_almost_equal(i, j, e=1):
            # Floating point math?
            assert abs(i - j) <= e, "%s %s %s" % (i, j, e)

        nt.assert_equal(len(metrics), 5)
        p95, pavg, pcount, pmax, pmed = self.sort_metrics(metrics)
        nt.assert_equal(p95['metric'], 'my.p.95percentile')
        assert_almost_equal(p95['points'][0][1], 95, 10)
        assert_almost_equal(pmax['points'][0][1], 99, 1)
        assert_almost_equal(pmed['points'][0][1], 50, 2)
        assert_almost_equal(pavg['points'][0][1], 50, 2)
        assert_almost_equal(pcount['points'][0][1], 4000, 0) # 100 * 20 * 2
        nt.assert_equals(p95['host'], 'myhost')

        # Ensure that histograms are reset.
        metrics = self.sort_metrics(stats.flush())
        assert not metrics

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_gauge(self):
        stats = MetricsAggregator('myhost')

        # Track some counters.
        stats.submit_packets('my.first.gauge:1|g')
        stats.submit_packets('my.first.gauge:5|g')
        stats.submit_packets('my.second.gauge:1.5|g')

        # Ensure that gauges roll up correctly.
        metrics = self.sort_metrics(stats.flush())
        assert len(metrics) == 2

        first, second = metrics

        nt.assert_equals(first['metric'], 'my.first.gauge')
        nt.assert_equals(first['points'][0][1], 5)
        nt.assert_equals(first['host'], 'myhost')

        nt.assert_equals(second['metric'], 'my.second.gauge')
        nt.assert_equals(second['points'][0][1], 1.5)

        # Ensure that old gauges get dropped due to old timestamps
        stats.gauge('my.first.gauge', 5)
        stats.gauge('my.first.gauge', 1, timestamp=1000000000)
        stats.gauge('my.second.gauge', 20, timestamp=1000000000)

        metrics = self.sort_metrics(stats.flush())
        assert len(metrics) == 1

        first = metrics[0]

        nt.assert_equals(first['metric'], 'my.first.gauge')
        nt.assert_equals(first['points'][0][1], 5)
        nt.assert_equals(first['host'], 'myhost')

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_counter(self):
        stats = MetricsAggregator('myhost', 1)

        # Track some counters.
        stats.submit('my.first.counter:1|c')
        stats.submit('my.first.counter:5|c')
        stats.submit('my.second.counter:1|c')
        stats.submit('my.third.counter:3|c')

        time.sleep(1)
        # Ensure they roll up nicely.
        metrics = self.sort_metrics(stats.flush(False))
        assert len(metrics) == 3

        first, second, third = metrics
        nt.assert_equals(first['metric'], 'my.first.counter')
        nt.assert_equals(first['points'][0][1], 6)
        nt.assert_equals(first['host'], 'myhost')

        nt.assert_equals(second['metric'], 'my.second.counter')
        nt.assert_equals(second['points'][0][1], 1)

        nt.assert_equals(third['metric'], 'my.third.counter')
        nt.assert_equals(third['points'][0][1], 3)

        # Ensure they're gone now.
        assert not len(stats.flush(False))

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_counter(self):
        stats = MetricsAggregator('myhost')

        # Track some counters.
        stats.submit_packets('my.first.counter:1|c')
        stats.submit_packets('my.first.counter:5|c')
        stats.submit_packets('my.second.counter:1|c')
        stats.submit_packets('my.third.counter:3|c')

        # Ensure they roll up nicely.
        metrics = self.sort_metrics(stats.flush())
        assert len(metrics) == 3

        first, second, third = metrics
        nt.assert_equals(first['metric'], 'my.first.counter')
        nt.assert_equals(first['points'][0][1], 6)
        nt.assert_equals(first['host'], 'myhost')

        nt.assert_equals(second['metric'], 'my.second.counter')
        nt.assert_equals(second['points'][0][1], 1)

        nt.assert_equals(third['metric'], 'my.third.counter')
        nt.assert_equals(third['points'][0][1], 3)

        # Ensure that counters reset to zero.
        metrics = self.sort_metrics(stats.flush())
        first, second, third = metrics
        nt.assert_equals(first['metric'], 'my.first.counter')
        nt.assert_equals(first['points'][0][1], 0)
        nt.assert_equals(second['metric'], 'my.second.counter')
        nt.assert_equals(second['points'][0][1], 0)
        nt.assert_equals(third['metric'], 'my.third.counter')
        nt.assert_equals(third['points'][0][1], 0)

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_rate(self):
        stats = MetricsAggregator('myhost')
        stats.submit_packets('my.rate:10|_dd-r')
        # Sleep 1 second so the time interval > 0
        time.sleep(1)
        stats.submit_packets('my.rate:40|_dd-r')

        # Check that the rate is calculated correctly
        metrics = stats.flush()
        nt.assert_equal(len(metrics), 1)
        m = metrics[0]
        nt.assert_equals(m['metric'], 'my.rate')
        nt.assert_equals(m['points'][0][1], 30)

        # Assert that no more rates are given
        assert not stats.flush()

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_tags(self):
        stats = MetricsAggregator('myhost')
        stats.submit_packets('gauge:1|c')
        stats.submit_packets('gauge:2|c|@1')
        stats.submit_packets('gauge:4|c|#tag1,tag2')
        stats.submit_packets('gauge:8|c|#tag2,tag1') # Should be the same as above
        stats.submit_packets('gauge:16|c|#tag3,tag4')

        metrics = self.sort_metrics(stats.flush())

        assert len(metrics) == 3
        first, second, third = metrics

        nt.assert_equal(first['metric'], 'gauge')
        nt.assert_equal(first['tags'], None)
        nt.assert_equal(first['points'][0][1], 3)
        nt.assert_equal(first['host'], 'myhost')

        nt.assert_equal(second['metric'], 'gauge')
        nt.assert_equal(second['tags'], ('tag1', 'tag2'))
        nt.assert_equal(second['points'][0][1], 12)
        nt.assert_equal(second['host'], 'myhost')

        nt.assert_equal(third['metric'], 'gauge')
        nt.assert_equal(third['tags'], ('tag3', 'tag4'))
        nt.assert_equal(third['points'][0][1], 16)
        nt.assert_equal(third['host'], 'myhost')

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_tags(self):
        stats = MetricsAggregator("myhost")
        stats.submit_packets("gauge:1|c")
        stats.submit_packets("gauge:2|c|@1")
        stats.submit_packets("gauge:4|c|#tag1,tag2")
        stats.submit_packets("gauge:8|c|#tag2,tag1")  # Should be the same as above
        stats.submit_packets("gauge:16|c|#tag3,tag4")

        metrics = self.sort_metrics(stats.flush())

        assert len(metrics) == 3
        first, second, third = metrics

        nt.assert_equal(first["metric"], "gauge")
        nt.assert_equal(first["tags"], None)
        nt.assert_equal(first["points"][0][1], 3)
        nt.assert_equal(first["host"], "myhost")

        nt.assert_equal(second["metric"], "gauge")
        nt.assert_equal(second["tags"], ("tag1", "tag2"))
        nt.assert_equal(second["points"][0][1], 12)
        nt.assert_equal(second["host"], "myhost")

        nt.assert_equal(third["metric"], "gauge")
        nt.assert_equal(third["tags"], ("tag3", "tag4"))
        nt.assert_equal(third["points"][0][1], 16)
        nt.assert_equal(third["host"], "myhost")

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_sets(self):
        stats = MetricsAggregator("myhost")
        stats.submit_packets("my.set:10|s")
        stats.submit_packets("my.set:20|s")
        stats.submit_packets("my.set:20|s")
        stats.submit_packets("my.set:30|s")
        stats.submit_packets("my.set:30|s")
        stats.submit_packets("my.set:30|s")

        # Assert that it's treated normally.
        metrics = stats.flush()
        nt.assert_equal(len(metrics), 1)
        m = metrics[0]
        nt.assert_equal(m["metric"], "my.set")
        nt.assert_equal(m["points"][0][1], 3)

        # Assert there are no more sets
        assert not stats.flush()

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_scientific_notation(self):
        stats = MetricsAggregator('myhost', interval=10)

        stats.submit_packets('test.scinot:9.512901e-05|g')
        metrics = self.sort_metrics(stats.flush())

        assert len(metrics) == 1
        ts, val = metrics[0].get('points')[0]
        nt.assert_almost_equal(val, 9.512901e-05)

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_string_sets(self):
        stats = MetricsAggregator('myhost')
        stats.submit_packets('my.set:string|s')
        stats.submit_packets('my.set:sets|s')
        stats.submit_packets('my.set:sets|s')
        stats.submit_packets('my.set:test|s')
        stats.submit_packets('my.set:test|s')
        stats.submit_packets('my.set:test|s')

        # Assert that it's treated normally.
        metrics = stats.flush()
        nt.assert_equal(len(metrics), 1)
        m = metrics[0]
        nt.assert_equal(m['metric'], 'my.set')
        nt.assert_equal(m['points'][0][1], 3)

        # Assert there are no more sets
        assert not stats.flush()

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_sampled_counter(self):

        # Submit a sampled counter.
        stats = MetricsAggregator("myhost")
        stats.submit_packets("sampled.counter:1|c|@0.5")
        metrics = stats.flush()
        assert len(metrics) == 1
        m = metrics[0]
        assert m["metric"] == "sampled.counter"
        nt.assert_equal(m["points"][0][1], 2)

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_metrics_expiry(self):
        # Ensure metrics eventually expire and stop submitting.
        stats = MetricsAggregator('myhost', expiry_seconds=1)
        stats.submit_packets('test.counter:123|c')

        # Ensure points keep submitting
        assert stats.flush()
        assert stats.flush()
        time.sleep(0.5)
        assert stats.flush()

        # Now sleep for longer than the expiry window and ensure
        # no points are submitted
        time.sleep(2)
        m = stats.flush()
        assert not m, str(m)

        # If we submit again, we're all good.
        stats.submit_packets('test.counter:123|c')
        assert stats.flush()

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_diagnostic_stats(self):
        stats = MetricsAggregator('myhost')
        for i in xrange(10):
            stats.submit_packets('metric:10|c')
        stats.send_packet_count('datadog.dogstatsd.packet.count')
        metrics = self.sort_metrics(stats.flush())
        nt.assert_equals(2, len(metrics))
        first, second = metrics

        nt.assert_equal(first['metric'], 'datadog.dogstatsd.packet.count')
        nt.assert_equal(first['points'][0][1], 10)

# 需要导入模块: from dogstatsd import MetricsAggregator [as 别名]
# 或者: from dogstatsd.MetricsAggregator import flush [as 别名]
    def test_gauge_sample_rate(self):
        stats = MetricsAggregator('myhost')

        # Submit a sampled gauge metric.
        stats.submit_packets('sampled.gauge:10|g|@0.1')

        # Assert that it's treated normally.
        metrics = stats.flush()
        nt.assert_equal(len(metrics), 1)
        m = metrics[0]
        nt.assert_equal(m['metric'], 'sampled.gauge')
        nt.assert_equal(m['points'][0][1], 10)