def test_flush_many_new(self):
interface.state.global_monitor = mock.create_autospec(monitors.Monitor)
interface.state.target = targets.TaskTarget('a', 'b', 'c', 'd', 1)
# We can't use the mock's call_args_list here because the same object is
# reused as the argument to both calls and cleared inbetween.
data_lengths = []
def send(proto):
count = 0
for coll in proto.metrics_collection:
for data_set in coll.metrics_data_set:
for _ in data_set.data:
count += 1
data_lengths.append(count)
interface.state.global_monitor.send.side_effect = send
counter = metrics.CounterMetric('counter', 'desc',
[metrics.IntegerField('field')])
interface.register(counter)
for i in range(interface.METRICS_DATA_LENGTH_LIMIT + 1):
counter.increment_by(i, {'field': i})
interface.flush()
self.assertEquals(2, interface.state.global_monitor.send.call_count)
self.assertListEqual([500, 1], data_lengths)
def test_generate_every_type_of_field(self):
counter = metrics.CounterMetric('counter', 'desc', [
metrics.IntegerField('a'),
metrics.BooleanField('b'),
metrics.StringField('c'),
])
interface.register(counter)
counter.increment({'a': 1, 'b': True, 'c': 'test'})
proto = list(interface._generate_proto())[0]
data_set = proto.metrics_collection[0].metrics_data_set[0]
field_type = metrics_pb2.MetricsDataSet.MetricFieldDescriptor
self.assertEqual('a', data_set.field_descriptor[0].name)
self.assertEqual(field_type.INT64,
data_set.field_descriptor[0].field_type)
self.assertEqual('b', data_set.field_descriptor[1].name)
self.assertEqual(field_type.BOOL,
data_set.field_descriptor[1].field_type)
self.assertEqual('c', data_set.field_descriptor[2].name)
self.assertEqual(field_type.STRING,
data_set.field_descriptor[2].field_type)
self.assertEqual(1, data_set.data[0].int64_value)
self.assertEqual('a', data_set.data[0].field[0].name)
self.assertEqual(1, data_set.data[0].field[0].int64_value)
self.assertEqual('b', data_set.data[0].field[1].name)
self.assertTrue(data_set.data[0].field[1].bool_value)
self.assertEqual('c', data_set.data[0].field[2].name)
self.assertEqual('test', data_set.data[0].field[2].string_value)
def test_integer_field(self):
f = metrics.IntegerField('name')
with self.assertRaises(errors.MonitoringInvalidFieldTypeError):
f.validate_value('', 'string')
with self.assertRaises(errors.MonitoringInvalidFieldTypeError):
f.validate_value('', u'string')
f.validate_value('', 123)
f.validate_value('', long(123))
f.validate_value('', True) # Python allows this *shrug*
with self.assertRaises(errors.MonitoringInvalidFieldTypeError):
f.validate_value('', None)
with self.assertRaises(errors.MonitoringInvalidFieldTypeError):
f.validate_value('', 12.34)
def test_generate_proto_with_dangerously_set_start_time(self):
counter0 = metrics.CounterMetric('counter0', 'desc0',
[metrics.IntegerField('test')])
interface.register(counter0)
counter0.increment_by(3, {'test': 123})
counter0.increment_by(3, {'test': 456})
counter0.dangerously_set_start_time(1000)
proto = list(interface._generate_proto())[0]
data_set = proto.metrics_collection[0].metrics_data_set[0]
for d in data_set.data:
self.assertEqual(1000, d.start_timestamp.seconds)
counter0.dangerously_set_start_time(2000)
proto = list(interface._generate_proto())[0]
data_set = proto.metrics_collection[0].metrics_data_set[0]
for d in data_set.data:
self.assertEqual(2000, d.start_timestamp.seconds)
def test_grouping(self):
counter0 = metrics.CounterMetric('counter0', 'desc0',
[metrics.IntegerField('test')])
counter1 = metrics.CounterMetric('counter1', 'desc1', None)
counter2 = metrics.CounterMetric('counter2', 'desc2', None)
interface.register(counter0)
interface.register(counter1)
interface.register(counter2)
counter0.increment_by(3, {'test': 123})
counter0.increment_by(5, {'test': 999})
counter1.increment()
counter2.increment_by(4, target_fields={'task_num': 1})
protos = list(interface._generate_proto())
self.assertEqual(1, len(protos))
proto = protos[0]
self.assertEqual(2, len(proto.metrics_collection))
for coll in proto.metrics_collection:
self.assertEqual('service', coll.task.service_name)
self.assertEqual('job', coll.task.job_name)
self.assertEqual('region', coll.task.data_center)
self.assertEqual('hostname', coll.task.host_name)
first_coll = proto.metrics_collection[0]
second_coll = proto.metrics_collection[1]
self.assertEqual(0, first_coll.task.task_num)
self.assertEqual(1, second_coll.task.task_num)
self.assertEqual(2, len(first_coll.metrics_data_set))
self.assertEqual(1, len(second_coll.metrics_data_set))
data_sets = [
first_coll.metrics_data_set[0],
first_coll.metrics_data_set[1],
second_coll.metrics_data_set[0]
]
for i, data_set in enumerate(data_sets):
self.assertEqual('/infra/test/counter%d' % i, data_set.metric_name)
def test_populate_fields(self):
data = metrics_pb2.MetricsData()
m = metrics.Metric('test', 'test', [
metrics.IntegerField('a'),
metrics.BooleanField('b'),
metrics.StringField('c'),
])
m._populate_fields(data, (1, True, 'test'))
self.assertEqual(3, len(data.field))
self.assertEqual('a', data.field[0].name)
self.assertEqual(1, data.field[0].int64_value)
self.assertEqual('b', data.field[1].name)
self.assertTrue(data.field[1].bool_value)
self.assertEqual('c', data.field[2].name)
self.assertEqual('test', data.field[2].string_value)
def test_populate_field_descriptors(self):
data_set_pb = metrics_pb2.MetricsDataSet()
m = metrics.Metric('test', 'test', [
metrics.IntegerField('a'),
metrics.BooleanField('b'),
metrics.StringField('c'),
])
m._populate_field_descriptors(data_set_pb)
field_type = metrics_pb2.MetricsDataSet.MetricFieldDescriptor
self.assertEqual(3, len(data_set_pb.field_descriptor))
self.assertEqual('a', data_set_pb.field_descriptor[0].name)
self.assertEqual(field_type.INT64,
data_set_pb.field_descriptor[0].field_type)
self.assertEqual('b', data_set_pb.field_descriptor[1].name)
self.assertEqual(field_type.BOOL,
data_set_pb.field_descriptor[1].field_type)
self.assertEqual('c', data_set_pb.field_descriptor[2].name)
self.assertEqual(field_type.STRING,
data_set_pb.field_descriptor[2].field_type)
])
response_bytes = metrics.CumulativeDistributionMetric(
'http/response_bytes', 'Bytes received per http request (content only).', [
metrics.StringField('name'),
metrics.StringField('client'),
])
durations = metrics.CumulativeDistributionMetric(
'http/durations', 'Time elapsed between sending a request and getting a'
' response (including parsing) in milliseconds.', [
metrics.StringField('name'),
metrics.StringField('client'),
])
response_status = metrics.CounterMetric(
'http/response_status',
'Number of responses received by HTTP status code.', [
metrics.IntegerField('status'),
metrics.StringField('name'),
metrics.StringField('client'),
])
server_request_bytes = metrics.CumulativeDistributionMetric(
'http/server_request_bytes',
'Bytes received per http request (body only).', [
metrics.IntegerField('status'),
metrics.StringField('name'),
metrics.BooleanField('is_robot'),
])
server_response_bytes = metrics.CumulativeDistributionMetric(
'http/server_response_bytes',
'Bytes sent per http request (content only).', [
metrics.IntegerField('status'),
def test_set_list_fields(self):
m = metrics.StringMetric('foo', 'foo', [metrics.IntegerField('asdf')])
with self.assertRaises(ValueError):
m.set('bar', [1])
def test_set_wrong_number_of_fields(self):
m = metrics.StringMetric('foo', 'foo', [metrics.IntegerField('asdf')])
with self.assertRaises(errors.WrongFieldsError):
m.set('bar', {'asdf': 1, 'foo': 2})
def test_equality(self):
f = metrics.IntegerField('name')
self.assertEqual(f, f)
