def testCatchesException(self):
"""Tests that the _SetupAndConsumeMessages loop catches exceptions."""
q = Queue.Queue()
class RaisesException(object):
"""Class to raise an exception"""
def raiseException(self, *_args, **_kwargs):
raise Exception()
metrics.RaisesException = RaisesException
q.put(metrics.MetricCall('RaisesException', [], {},
'raiseException', ['arg1'], {'kwarg1': 'value1'},
False))
q.put(None)
exception_log = self.PatchObject(ts_mon_config.logging, 'exception')
ts_mon_config._SetupAndConsumeMessages(q, DEFAULT_OPTIONS)
self.assertEqual(1, exception_log.call_count)
# time.time is called once because we check if we need to Flush() before
# receiving the None message.
self.assertEqual(1, ts_mon_config.time.time.call_count)
self.assertEqual(0, ts_mon_config.time.sleep.call_count)
self.assertEqual(0, ts_mon_config.metrics.Flush.call_count)
def testConsumeTwoMetrics(self):
"""Tests that sending two metrics only calls flush once."""
q = Queue.Queue()
q.put(
metrics.MetricCall('Boolean', [], {}, 'mock_name1', ['arg1'],
{'kwarg1': 'value'}, False))
q.put(
metrics.MetricCall('Boolean', [], {}, 'mock_name2', ['arg2'],
{'kwarg2': 'value'}, False))
q.put(None)
ts_mon_config._ConsumeMessages(q, [''], {})
self.assertEqual(3, ts_mon_config.time.time.call_count)
ts_mon_config.time.sleep.assert_called_once_with(
ts_mon_config.FLUSH_INTERVAL - 2)
ts_mon_config.metrics.Flush.assert_called_once_with(reset_after=[])
self.mock_metric.return_value.mock_name1.assert_called_once_with(
'arg1', kwarg1='value')
self.mock_metric.return_value.mock_name2.assert_called_once_with(
'arg2', kwarg2='value')
def testSetOnceMetricKeepsEmitting(self):
"""Tests that a metric which is set once emits many times if left alone."""
self.PatchObject(ts_mon_config, 'FLUSH_INTERVAL', 0)
self.time_mock.time.side_effect = [1, 2, 3, 4, 5]
q = Queue.Queue()
q.put(metrics.MetricCall('Boolean', [], {},
'__class__', [], {},
False))
try:
ts_mon_config.MetricConsumer(q).Consume()
except StopIteration:
pass # No more time calls left.
self.assertEqual(self.flush_mock.call_count, 5)
def testConsumeOneMetric(self):
"""Tests that sending one metric calls flush once."""
q = Queue.Queue()
q.put(metrics.MetricCall('Boolean', [], {},
'mock_name', ['arg1'], {'kwarg1': 'value'},
False))
q.put(None)
ts_mon_config._SetupAndConsumeMessages(q, DEFAULT_OPTIONS)
self.assertEqual(2, ts_mon_config.time.time.call_count)
ts_mon_config.time.sleep.assert_called_once_with(
ts_mon_config.FLUSH_INTERVAL - 1)
ts_mon_config.metrics.Flush.assert_called_once_with(reset_after=[])
self.mock_metric.return_value.mock_name.assert_called_once_with(
'arg1', fields=self.common_metric_fields, kwarg1='value')
def testResetAfter(self):
"""Tests that metrics with reset_after set are cleared after."""
q = Queue.Queue()
q.put(metrics.MetricCall('Boolean', [], {},
'mock_name', ['arg1'], {'kwarg1': 'value1'},
reset_after=True))
q.put(None)
ts_mon_config._SetupAndConsumeMessages(q, DEFAULT_OPTIONS)
self.assertEqual(
[self.mock_metric.return_value],
ts_mon_config.metrics.Flush.call_args[1]['reset_after'])
self.mock_metric.return_value.mock_name.assert_called_once_with(
'arg1', fields=self.common_metric_fields, kwarg1='value1')
def testEnqueue(self):
"""Test that _Indirect enqueues messages correctly."""
metric = metrics.Boolean
with parallel.Manager() as manager:
q = manager.Queue()
self.PatchObject(metrics, 'MESSAGE_QUEUE', q)
proxy_metric = metric('foo')
proxy_metric.example('arg1', 'arg2')
message = q.get(timeout=10)
self.assertEqual(
message,
metrics.MetricCall(metric.__name__, ('foo', ), {}, 'example',
('arg1', 'arg2'), {}, False))
def testFlushingProcessExits(self):
"""Tests that _CreateTsMonFlushingProcess cleans up the process."""
processes = []
original_process_function = multiprocessing.Process
def SaveProcess(*args, **kwargs):
p = original_process_function(*args, **kwargs)
processes.append(p)
return p
self.PatchObject(multiprocessing, 'Process', SaveProcess)
with ts_mon_config._CreateTsMonFlushingProcess(DEFAULT_OPTIONS) as q:
q.put(metrics.MetricCall('Boolean', [], {},
'__class__', [], {},
False))
# wait a bit for the process to close, since multiprocessing.Queue and
# Process.join() is not synchronous.
processes[0].join(5)
self.assertEqual(0, processes[0].exitcode)
def testEnqueue(self):
"""Test that _Indirect enqueues messages correctly."""
metric = metrics.Boolean
with parallel.Manager() as manager:
q = manager.Queue()
self.PatchObject(metrics, 'MESSAGE_QUEUE', q)
proxy_metric = metric('foo')
proxy_metric.example('arg1', {'field_name': 'value'})
message = q.get(timeout=10)
expected_metric_kwargs = {
'field_spec': [ts_mon.StringField('field_name')],
'description': 'No description.',
}
self.assertEqual(
message,
metrics.MetricCall(metric.__name__, ('foo',), expected_metric_kwargs,
'example', ('arg1', {'field_name': 'value'}), {},
False))
def testCatchesException(self):
"""Tests that the _ConsumeMessages loop catches exceptions."""
q = Queue.Queue()
class RaisesException(object):
"""Class to raise an exception"""
def raiseException(self, *_args, **_kwargs):
raise Exception()
metrics.RaisesException = RaisesException
q.put(
metrics.MetricCall('RaisesException', [], {}, 'raiseException',
['arg1'], {'kwarg1': 'value1'}, False))
q.put(None)
mock_logging = self.PatchObject(ts_mon_config.logging, 'exception')
ts_mon_config._ConsumeMessages(q, [''], {})
self.assertEqual(1, mock_logging.call_count)
self.assertEqual(2, ts_mon_config.time.time.call_count)
ts_mon_config.time.sleep.assert_called_once_with(
ts_mon_config.FLUSH_INTERVAL - 1)
ts_mon_config.metrics.Flush.assert_called_once_with(reset_after=[])
