Example #1
0
    def test_telemetry_flush_interval_alternate_destination(self):
        dogstatsd = DogStatsd(telemetry_host='foo')
        fake_socket = FakeSocket()
        dogstatsd.socket = fake_socket
        fake_telemetry_socket = FakeSocket()
        dogstatsd.telemetry_socket = fake_telemetry_socket

        self.assertIsNotNone(dogstatsd.telemetry_host)
        self.assertIsNotNone(dogstatsd.telemetry_port)
        self.assertTrue(dogstatsd._dedicated_telemetry_destination())

        # set the last flush time in the future to be sure we won't flush
        dogstatsd._last_flush_time = time.time(
        ) + dogstatsd._telemetry_flush_interval
        dogstatsd.gauge('gauge', 123.4)

        self.assertEqual('gauge:123.4|g', fake_socket.recv())

        time1 = time.time()
        # setting the last flush time in the past to trigger a telemetry flush
        dogstatsd._last_flush_time = time1 - dogstatsd._telemetry_flush_interval - 1
        dogstatsd.gauge('gauge', 123.4)

        self.assertEqual('gauge:123.4|g', fake_socket.recv())
        self.assert_equal_telemetry('',
                                    fake_telemetry_socket.recv(),
                                    telemetry=telemetry_metrics(
                                        metrics=2,
                                        bytes_sent=13 * 2,
                                        packets_sent=2))

        # assert that _last_flush_time has been updated
        self.assertTrue(time1 < dogstatsd._last_flush_time)
Example #2
0
    def test_telemetry_flush_interval(self):
        dogstatsd = DogStatsd()
        fake_socket = FakeSocket()
        dogstatsd.socket = fake_socket

        # set the last flush time in the future to be sure we won't flush
        dogstatsd._last_flush_time = time.time(
        ) + dogstatsd._telemetry_flush_interval
        dogstatsd.gauge('gauge', 123.4)

        metric = 'gauge:123.4|g'
        self.assertEqual(metric, fake_socket.recv())

        time1 = time.time()
        # setting the last flush time in the past to trigger a telemetry flush
        dogstatsd._last_flush_time = time1 - dogstatsd._telemetry_flush_interval - 1
        dogstatsd.gauge('gauge', 123.4)
        self.assert_equal_telemetry(metric,
                                    fake_socket.recv(2),
                                    telemetry=telemetry_metrics(
                                        metrics=2,
                                        bytes_sent=2 * len(metric),
                                        packets_sent=2))

        # assert that _last_flush_time has been updated
        self.assertTrue(time1 < dogstatsd._last_flush_time)
Example #3
0
    def test_telemetry_flush_interval_alternate_destination(self):
        statsd = DogStatsd(telemetry_host='foo')
        fake_socket = FakeSocket()
        statsd.socket = fake_socket
        fake_telemetry_socket = FakeSocket()
        statsd.telemetry_socket = fake_telemetry_socket

        assert statsd.telemetry_host != None
        assert statsd.telemetry_port != None
        assert statsd._dedicated_telemetry_destination()

        # set the last flush time in the future to be sure we won't flush
        statsd._last_flush_time = time.time(
        ) + statsd._telemetry_flush_interval
        statsd.gauge('gauge', 123.4)

        assert_equal('gauge:123.4|g', fake_socket.recv())

        t1 = time.time()
        # setting the last flush time in the past to trigger a telemetry flush
        statsd._last_flush_time = t1 - statsd._telemetry_flush_interval - 1
        statsd.gauge('gauge', 123.4)

        assert_equal('gauge:123.4|g', fake_socket.recv())
        assert_equal_telemetry('',
                               fake_telemetry_socket.recv(),
                               telemetry=telemetry_metrics(metrics=2,
                                                           bytes_sent=13 * 2,
                                                           packets_sent=2))
        # assert that _last_flush_time has been updated
        assert t1 < statsd._last_flush_time
Example #4
0
    def test_telemetry_flush_interval(self):
        statsd = DogStatsd()
        fake_socket = FakeSocket()
        statsd.socket = fake_socket

        # set the last flush time in the future to be sure we won't flush
        statsd._last_flush_time = time.time(
        ) + statsd._telemetry_flush_interval
        statsd.gauge('gauge', 123.4)

        metric = 'gauge:123.4|g'
        assert_equal(metric, fake_socket.recv())

        t1 = time.time()
        # setting the last flush time in the past to trigger a telemetry flush
        statsd._last_flush_time = t1 - statsd._telemetry_flush_interval - 1
        statsd.gauge('gauge', 123.4)
        assert_equal_telemetry(metric,
                               fake_socket.recv(2),
                               telemetry=telemetry_metrics(metrics=2,
                                                           bytes_sent=2 *
                                                           len(metric),
                                                           packets_sent=2))

        # assert that _last_flush_time has been updated
        assert t1 < statsd._last_flush_time
Example #5
0
    def test_telemetry_flush_interval_batch(self):
        dogstatsd = DogStatsd()

        fake_socket = FakeSocket()
        dogstatsd.socket = fake_socket

        dogstatsd.open_buffer()
        dogstatsd.gauge('gauge1', 1)
        dogstatsd.gauge('gauge2', 2)

        time1 = time.time()
        # setting the last flush time in the past to trigger a telemetry flush
        dogstatsd._last_flush_time = time1 - statsd._telemetry_flush_interval -1

        dogstatsd.close_buffer()

        metric = 'gauge1:1|g\ngauge2:2|g'
        self.assert_equal_telemetry(metric, fake_socket.recv(2), telemetry=telemetry_metrics(metrics=2, bytes_sent=len(metric)))
        # assert that _last_flush_time has been updated
        self.assertTrue(time1 < dogstatsd._last_flush_time)