def test_convert_view_without_labels(self):
mock_measure = mock.Mock(spec=measure.MeasureFloat)
mock_aggregation = mock.Mock(spec=aggregation.DistributionAggregation)
mock_aggregation.aggregation_type = aggregation.Type.DISTRIBUTION
vd = mock.Mock(spec=view_data.ViewData)
vd.view = view.View(name=mock.Mock(),
description=mock.Mock(),
columns=[],
measure=mock_measure,
aggregation=mock_aggregation)
vd.start_time = '2019-04-11T22:33:44.555555Z'
mock_point = mock.Mock(spec=point.Point)
mock_point.value = mock.Mock(spec=value.ValueDistribution)
mock_agg = mock.Mock(spec=aggregation_data.SumAggregationDataFloat)
mock_agg.to_point.return_value = mock_point
vd.tag_value_aggregation_data_map = {tuple(): mock_agg}
current_time = '2019-04-11T22:33:55.666666Z'
metric = metric_utils.view_data_to_metric(vd, current_time)
self.assertEqual(metric.descriptor.label_keys, [])
self.assertEqual(len(metric.time_series), 1)
[ts] = metric.time_series
self.assertEqual(ts.label_values, [])
self.assertEqual(len(ts.points), 1)
[pt] = ts.points
self.assertEqual(pt, mock_point)
def generate_metrics(view_data_objects):
metrics = []
for view_data_object in view_data_objects:
metric = metric_utils.view_data_to_metric(view_data_object,
TEST_TIMESTAMP)
metrics.append(metric)
return metrics
def test_create_batched_time_series(self, monitor_resource_mock):
client = mock.Mock()
v_data = view_data_module.ViewData(view=VIDEO_SIZE_VIEW,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR)
v_data.record(context=tag_map_module.TagMap(), value=2, timestamp=None)
view_data = [v_data]
option = stackdriver.Options(project_id="project-test")
exporter = stackdriver.StackdriverStatsExporter(options=option,
client=client)
view_data = [metric_utils.view_data_to_metric(view_data[0], TEST_TIME)]
time_series_batches = exporter.create_batched_time_series(view_data, 1)
self.assertEqual(len(time_series_batches), 1)
[time_series_batch] = time_series_batches
self.assertEqual(len(time_series_batch), 1)
[time_series] = time_series_batch
self.assertEqual(
time_series.metric.type,
'custom.googleapis.com/opencensus/' + VIDEO_SIZE_VIEW_NAME)
self.check_labels(time_series.metric.labels, {},
include_opencensus=True)
def test_create_timeseries_multiple_tag_values(self,
monitoring_resoure_mock):
view_manager, stats_recorder, exporter = \
self.setup_create_timeseries_test()
view_manager.register_view(VIDEO_SIZE_VIEW)
measure_map = stats_recorder.new_measurement_map()
# Add first point with one tag value
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY, tag_value_module.TagValue("1200"))
measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 25 * MiB)
measure_map.record(tag_map)
# Add second point with different tag value
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY, tag_value_module.TagValue("1400"))
measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 12 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(
VIDEO_SIZE_VIEW_NAME, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 2)
ts_by_frontend = {
ts.metric.labels.get(FRONTEND_KEY_CLEAN): ts
for ts in time_series_list
}
self.assertEqual(set(ts_by_frontend.keys()), {"1200", "1400"})
ts1 = ts_by_frontend["1200"]
ts2 = ts_by_frontend["1400"]
# Verify first time series
self.assertEqual(ts1.resource.type, "global")
self.assertEqual(
ts1.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(ts1.resource)
self.assertEqual(len(ts1.points), 1)
value1 = ts1.points[0].value
self.assertEqual(value1.distribution_value.count, 1)
# Verify second time series
self.assertEqual(ts2.resource.type, "global")
self.assertEqual(
ts2.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(ts2.resource)
self.assertEqual(len(ts2.points), 1)
value2 = ts2.points[0].value
self.assertEqual(value2.distribution_value.count, 1)
def do_test_view_data_to_metric(self, aggregation_class,
value_type, metric_descriptor_type):
"""Test that ViewDatas are converted correctly into Metrics.
This test doesn't check that the various aggregation data `to_point`
methods handle the point conversion correctly, just that converted
Point is included in the Metric, and the metric has the expected
structure, descriptor, and labels.
"""
start_time = datetime.datetime(2019, 1, 25, 11, 12, 13)
current_time = datetime.datetime(2019, 1, 25, 12, 13, 14)
mock_measure = mock.Mock(spec=measure.MeasureFloat)
mock_aggregation = mock.Mock(spec=aggregation_class)
mock_aggregation.get_metric_type.return_value = metric_descriptor_type
vv = view.View(
name=mock.Mock(),
description=mock.Mock(),
columns=[tag_key.TagKey('k1'), tag_key.TagKey('k2')],
measure=mock_measure,
aggregation=mock_aggregation)
vd = mock.Mock(spec=view_data.ViewData)
vd.view = vv
vd.start_time = start_time
mock_point = mock.Mock(spec=point.Point)
mock_point.value = mock.Mock(spec=value_type)
mock_agg = mock.Mock(spec=aggregation_data.SumAggregationData)
mock_agg.to_point.return_value = mock_point
vd.tag_value_aggregation_data_map = {
(tag_value.TagValue('v1'), tag_value.TagValue('v2')): mock_agg
}
metric = metric_utils.view_data_to_metric(vd, current_time)
mock_agg.to_point.assert_called_once_with(current_time)
self.assertEqual(metric.descriptor.name, vv.name)
self.assertEqual(metric.descriptor.description, vv.description)
self.assertEqual(metric.descriptor.unit, vv.measure.unit)
self.assertEqual(metric.descriptor.type, metric_descriptor_type)
self.assertListEqual(
[lk.key for lk in metric.descriptor.label_keys],
['k1', 'k2'])
self.assertEqual(len(metric.time_series), 1)
[ts] = metric.time_series
self.assertEqual(ts.start_timestamp, start_time)
self.assertListEqual(
[lv.value for lv in ts.label_values],
['v1', 'v2'])
self.assertEqual(len(ts.points), 1)
[pt] = ts.points
self.assertEqual(pt, mock_point)
def test_create_timeseries_float_tagvalue(self, monitor_resource_mock):
client = mock.Mock()
option = stackdriver.Options(project_id="project-test",
resource="global")
exporter = stackdriver.StackdriverStatsExporter(options=option,
client=client)
stats = stats_module.stats
view_manager = stats.view_manager
stats_recorder = stats.stats_recorder
if len(view_manager.measure_to_view_map.exporters) > 0:
view_manager.unregister_exporter(
view_manager.measure_to_view_map.exporters[0])
view_manager.register_exporter(exporter)
agg_3 = aggregation_module.SumAggregation(sum=2.2)
view_name3 = "view-name3"
new_view3 = view_module.View(view_name3,
"processed video size over time",
[FRONTEND_KEY_FLOAT],
VIDEO_SIZE_MEASURE_FLOAT, agg_3)
view_manager.register_view(new_view3)
tag_value_float = tag_value_module.TagValue("1200")
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY_FLOAT, tag_value_float)
measure_map = stats_recorder.new_measurement_map()
measure_map.measure_float_put(VIDEO_SIZE_MEASURE_FLOAT, 25 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(view_name3, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
[time_series] = time_series_list
self.assertEqual(time_series.metric.type,
"custom.googleapis.com/opencensus/view-name3")
self.check_labels(time_series.metric.labels,
{FRONTEND_KEY_FLOAT_CLEAN: "1200"},
include_opencensus=True)
self.assertIsNotNone(time_series.resource)
self.assertEqual(len(time_series.points), 1)
expected_value = monitoring_v3.types.TypedValue()
expected_value.double_value = 2.2 + 25 * MiB
self.assertEqual(time_series.points[0].value, expected_value)
def test_create_batched_time_series_with_many(self, monitor_resource_mock):
client = mock.Mock()
# First view with 3
view_name1 = "view-name1"
view1 = view_module.View(view_name1, "test description", ['test'],
VIDEO_SIZE_MEASURE,
aggregation_module.LastValueAggregation())
v_data1 = view_data_module.ViewData(view=view1,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR)
v_data1.record(context=tag_map_module.TagMap({'test': '1'}),
value=7,
timestamp=None)
v_data1.record(context=tag_map_module.TagMap({'test': '2'}),
value=5,
timestamp=None)
v_data1.record(context=tag_map_module.TagMap({'test': '3'}),
value=3,
timestamp=None)
# Second view with 2
view_name2 = "view-name2"
view2 = view_module.View(view_name2, "test description", ['test'],
VIDEO_SIZE_MEASURE,
aggregation_module.LastValueAggregation())
v_data2 = view_data_module.ViewData(view=view2,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR)
v_data2.record(context=tag_map_module.TagMap({'test': '1'}),
value=7,
timestamp=None)
v_data2.record(context=tag_map_module.TagMap({'test': '2'}),
value=5,
timestamp=None)
view_data = [v_data1, v_data2]
view_data = [
metric_utils.view_data_to_metric(vd, TEST_TIME) for vd in view_data
]
option = stackdriver.Options(project_id="project-test")
exporter = stackdriver.StackdriverStatsExporter(options=option,
client=client)
time_series_batches = exporter.create_batched_time_series(view_data, 2)
self.assertEqual(len(time_series_batches), 3)
[tsb1, tsb2, tsb3] = time_series_batches
self.assertEqual(len(tsb1), 2)
self.assertEqual(len(tsb2), 2)
self.assertEqual(len(tsb3), 1)
def test_create_timeseries_multiple_tags(self):
"""Check that exporter creates timeseries for multiple tag values.
create_time_series_list should return a time series for each set of
values in the tag value aggregation map.
"""
agg = aggregation_module.CountAggregation(
aggregation_type=aggregation_module.Type.COUNT)
view = view_module.View(
name="example.org/test_view",
description="example.org/test_view",
columns=[
tag_key_module.TagKey('color'),
tag_key_module.TagKey('shape')
],
measure=mock.Mock(),
aggregation=agg,
)
v_data = view_data_module.ViewData(
view=view,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR,
)
rs_count = aggregation_data_module.CountAggregationData(10)
bc_count = aggregation_data_module.CountAggregationData(20)
v_data._tag_value_aggregation_data_map = {
('red', 'square'): rs_count,
('blue', 'circle'): bc_count,
}
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
exporter = stackdriver.StackdriverStatsExporter()
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 2)
self.assertEqual(len(time_series_list[0].points), 1)
self.assertEqual(len(time_series_list[1].points), 1)
ts_by_color = {
ts.metric.labels.get('color'): ts
for ts in time_series_list
}
rs_ts = ts_by_color['red']
bc_ts = ts_by_color['blue']
self.assertEqual(rs_ts.metric.labels.get('shape'), 'square')
self.assertEqual(bc_ts.metric.labels.get('shape'), 'circle')
self.assertEqual(rs_ts.points[0].value.int64_value, 10)
self.assertEqual(bc_ts.points[0].value.int64_value, 20)
def test_bad_http_response(stats_exporter, caplog):
view_data = to_view_data(VIEWS["last"])
view_data.record(None, 100, None)
metric = metric_utils.view_data_to_metric(view_data, TEST_TIMESTAMP)
stats_exporter.export_metrics([metric])
assert (
"opencensus_ext_newrelic.stats",
logging.ERROR,
"New Relic send_metrics failed with status code: 500",
) in caplog.record_tuples
def test_create_timeseries(self, monitor_resource_mock):
view_manager, stats_recorder, exporter = \
self.setup_create_timeseries_test()
view_manager.register_view(VIDEO_SIZE_VIEW)
tag_value = tag_value_module.TagValue("1200")
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY, tag_value)
measure_map = stats_recorder.new_measurement_map()
measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 25 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(
VIDEO_SIZE_VIEW_NAME, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(time_series.resource.type, "global")
self.assertEqual(
time_series_list[0].metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.check_labels(time_series.metric.labels,
{FRONTEND_KEY_CLEAN: "1200"},
include_opencensus=True)
self.assertIsNotNone(time_series.resource)
self.assertEqual(len(time_series.points), 1)
value = time_series.points[0].value
self.assertEqual(value.distribution_value.count, 1)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.check_labels(time_series.metric.labels,
{FRONTEND_KEY_CLEAN: "1200"},
include_opencensus=True)
self.assertIsNotNone(time_series.resource)
self.assertEqual(len(time_series.points), 1)
value = time_series.points[0].value
self.assertEqual(value.distribution_value.count, 1)
def test_send_metrics_exception(stats_exporter, caplog):
# Remove the client object to force an exception when send_metrics is called
delattr(stats_exporter, "client")
view_data = to_view_data(VIEWS["last"])
view_data.record(None, 100, None)
metric = metric_utils.view_data_to_metric(view_data, TEST_TIMESTAMP)
response = stats_exporter.export_metrics([metric])
assert response is None
assert (
"opencensus_ext_newrelic.stats",
logging.ERROR,
"New Relic send_metrics failed with an exception.",
) in caplog.record_tuples
def test_create_timeseries_from_distribution(self):
"""Check for explicit 0-bound bucket for SD export."""
agg = aggregation_module.DistributionAggregation(
aggregation_type=aggregation_module.Type.DISTRIBUTION)
view = view_module.View(
name="example.org/test_view",
description="example.org/test_view",
columns=['tag_key'],
measure=mock.Mock(),
aggregation=agg,
)
v_data = view_data_module.ViewData(
view=view,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR,
)
# Aggregation over (10 * range(10)) for buckets [2, 4, 6, 8]
dad = aggregation_data_module.DistributionAggregationData(
mean_data=4.5,
count_data=100,
sum_of_sqd_deviations=825,
counts_per_bucket=[20, 20, 20, 20, 20],
bounds=[2, 4, 6, 8],
exemplars={mock.Mock()
for ii in range(5)})
v_data._tag_value_aggregation_data_map = {('tag_value', ): dad}
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
exporter = stackdriver.StackdriverStatsExporter()
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
[time_series] = time_series_list
self.check_labels(time_series.metric.labels, {'tag_key': 'tag_value'},
include_opencensus=True)
self.assertEqual(len(time_series.points), 1)
[point] = time_series.points
dv = point.value.distribution_value
self.assertEqual(100, dv.count)
self.assertEqual(825.0, dv.sum_of_squared_deviation)
self.assertEqual([0, 20, 20, 20, 20, 20], dv.bucket_counts)
self.assertEqual([0, 2, 4, 6, 8],
dv.bucket_options.explicit_buckets.bounds)
def test_export_double_point_value(self):
view = view_module.View('', '', [FRONTEND_KEY], VIDEO_SIZE_MEASURE,
aggregation_module.SumAggregation())
v_data = view_data_module.ViewData(view=view,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR)
v_data.record(context=tag_map_module.TagMap(),
value=2.5,
timestamp=None)
view_data = [v_data]
view_data = [metric_utils.view_data_to_metric(view_data[0], TEST_TIME)]
handler = mock.Mock(spec=ocagent.ExportRpcHandler)
ocagent.StatsExporter(handler).export_metrics(view_data)
self.assertEqual(
handler.send.call_args[0]
[0].metrics[0].timeseries[0].points[0].double_value, 2.5)
def get_metrics(self, timestamp):
"""Get a Metric for each registered view.
Convert each registered view's associated `ViewData` into a `Metric` to
be exported.
:type timestamp: :class: `datetime.datetime`
:param timestamp: The timestamp to use for metric conversions, usually
the current time.
:rtype: Iterator[:class: `opencensus.metrics.export.metric.Metric`]
"""
for vdl in self._measure_to_view_data_list_map.values():
for vd in vdl:
metric = metric_utils.view_data_to_metric(vd, timestamp)
if metric is not None:
yield metric
def test_export_view_data(self):
v_data = view_data_module.ViewData(view=VIDEO_SIZE_VIEW,
start_time=TEST_TIME_STR,
end_time=TEST_TIME_STR)
v_data.record(context=tag_map_module.TagMap(), value=2, timestamp=None)
view_data = [v_data]
view_data = [metric_utils.view_data_to_metric(view_data[0], TEST_TIME)]
handler = mock.Mock(spec=ocagent.ExportRpcHandler)
ocagent.StatsExporter(handler).export_metrics(view_data)
self.assertEqual(
handler.send.call_args[0][0].metrics[0].metric_descriptor,
metrics_pb2.MetricDescriptor(
name=VIDEO_SIZE_VIEW_NAME,
description='processed video size over time',
unit='By',
type=metrics_pb2.MetricDescriptor.CUMULATIVE_DISTRIBUTION,
label_keys=[metrics_pb2.LabelKey(key=FRONTEND_KEY)]))
self.assertEqual(
handler.send.call_args[0][0].metrics[0].timeseries[0],
metrics_pb2.TimeSeries(
start_timestamp=timestamp_pb2.Timestamp(seconds=1545699723,
nanos=4000),
label_values=[metrics_pb2.LabelValue(has_value=False)],
points=[
metrics_pb2.Point(
timestamp=timestamp_pb2.Timestamp(seconds=1545699723,
nanos=4000),
distribution_value=metrics_pb2.DistributionValue(
sum=2,
count=1,
bucket_options=metrics_pb2.DistributionValue.
BucketOptions(
explicit=metrics_pb2.DistributionValue.
BucketOptions.Explicit(
bounds=[16.0 * MiB, 256.0 * MiB])),
buckets=[
metrics_pb2.DistributionValue.Bucket(count=1),
metrics_pb2.DistributionValue.Bucket(),
metrics_pb2.DistributionValue.Bucket(),
]))
]))
def test_create_timeseries_disjoint_tags(self, monitoring_resoure_mock):
view_manager, stats_recorder, exporter = \
self.setup_create_timeseries_test()
# Register view with two tags
view_name = "view-name"
view = view_module.View(view_name, "test description",
[FRONTEND_KEY, FRONTEND_KEY_FLOAT],
VIDEO_SIZE_MEASURE,
aggregation_module.SumAggregation())
view_manager.register_view(view)
# Add point with one tag in common and one different tag
measure_map = stats_recorder.new_measurement_map()
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY, tag_value_module.TagValue("1200"))
tag_map.insert(FRONTEND_KEY_STR, tag_value_module.TagValue("1800"))
measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 25 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(view_name, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
[time_series] = time_series_list
# Verify first time series
self.assertEqual(time_series.resource.type, "global")
self.assertEqual(time_series.metric.type,
"custom.googleapis.com/opencensus/" + view_name)
self.check_labels(time_series.metric.labels,
{FRONTEND_KEY_CLEAN: "1200"},
include_opencensus=True)
self.assertIsNotNone(time_series.resource)
self.assertEqual(len(time_series.points), 1)
expected_value = monitoring_v3.types.TypedValue()
# TODO: #565
expected_value.double_value = 25.0 * MiB
self.assertEqual(time_series.points[0].value, expected_value)
def test_create_timeseries_str_tagvalue(self, monitor_resource_mock):
view_manager, stats_recorder, exporter = \
self.setup_create_timeseries_test()
agg_1 = aggregation_module.LastValueAggregation(value=2)
view_name1 = "view-name1"
new_view1 = view_module.View(view_name1,
"processed video size over time",
[FRONTEND_KEY_INT], VIDEO_SIZE_MEASURE_2,
agg_1)
view_manager.register_view(new_view1)
tag_value_int = tag_value_module.TagValue("Abc")
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY_INT, tag_value_int)
measure_map = stats_recorder.new_measurement_map()
measure_map.measure_int_put(VIDEO_SIZE_MEASURE_2, 25 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(view_name1, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.check_labels(time_series.metric.labels,
{FRONTEND_KEY_INT_CLEAN: "Abc"},
include_opencensus=True)
self.assertIsNotNone(time_series.resource)
self.assertEqual(len(time_series.points), 1)
expected_value = monitoring_v3.types.TypedValue()
# TODO: #565
expected_value.double_value = 25.0 * MiB
self.assertEqual(time_series.points[0].value, expected_value)
def test_create_timeseries_with_resource(self, monitor_resource_mock):
client = mock.Mock()
execution_context.clear()
option = stackdriver.Options(project_id="project-test", resource="")
exporter = stackdriver.StackdriverStatsExporter(options=option,
client=client)
stats = stats_module.stats
view_manager = stats.view_manager
stats_recorder = stats.stats_recorder
if len(view_manager.measure_to_view_map.exporters) > 0:
view_manager.unregister_exporter(
view_manager.measure_to_view_map.exporters[0])
view_manager.register_exporter(exporter)
view_manager.register_view(VIDEO_SIZE_VIEW)
tag_value = tag_value_module.TagValue("1200")
tag_map = tag_map_module.TagMap()
tag_map.insert(FRONTEND_KEY, tag_value)
measure_map = stats_recorder.new_measurement_map()
measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 25 * MiB)
measure_map.record(tag_map)
v_data = measure_map.measure_to_view_map.get_view(
VIDEO_SIZE_VIEW_NAME, None)
v_data = metric_utils.view_data_to_metric(v_data, TEST_TIME)
# check for gce_instance monitored resource
mocked_labels = {
'instance_id': 'my-instance',
'project_id': 'my-project',
'zone': 'us-east1',
'pod_id': 'localhost',
'namespace_id': 'namespace'
}
mock_resource = mock.Mock()
mock_resource.get_type.return_value = 'gce_instance'
mock_resource.get_labels.return_value = mocked_labels
monitor_resource_mock.return_value = mock_resource
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(time_series.resource.type, "gce_instance")
self.check_labels(
time_series.resource.labels, {
'instance_id': 'my-instance',
'project_id': 'my-project',
'zone': 'us-east1',
})
self.assertEqual(
time_series.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(time_series)
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(
time_series.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
# check for gke_container monitored resource
mocked_labels = {
'instance_id': 'my-instance',
'project_id': 'my-project',
'zone': 'us-east1',
'pod_id': 'localhost',
'cluster_name': 'cluster',
'namespace_id': 'namespace'
}
mock_resource = mock.Mock()
mock_resource.get_type.return_value = 'gke_container'
mock_resource.get_labels.return_value = mocked_labels
monitor_resource_mock.return_value = mock_resource
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(time_series.resource.type, "k8s_container")
self.check_labels(
time_series.resource.labels, {
'project_id': 'my-project',
'location': 'us-east1',
'cluster_name': 'cluster',
'pod_name': 'localhost',
'namespace_name': 'namespace',
})
self.assertEqual(
time_series.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(time_series)
# check for aws_ec2_instance monitored resource
mocked_labels = {
'instance_id': 'my-instance',
'aws_account': 'my-project',
'region': 'us-east1',
}
mock_resource = mock.Mock()
mock_resource.get_type.return_value = 'aws_ec2_instance'
mock_resource.get_labels.return_value = mocked_labels
monitor_resource_mock.return_value = mock_resource
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(time_series.resource.type, "aws_ec2_instance")
self.check_labels(
time_series.resource.labels, {
'instance_id': 'my-instance',
'aws_account': 'my-project',
'region': 'aws:us-east1',
})
self.assertEqual(
time_series.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(time_series)
# check for out of box monitored resource
mock_resource = mock.Mock()
mock_resource.get_type.return_value = ''
mock_resource.get_labels.return_value = mock.Mock()
monitor_resource_mock.return_value = mock_resource
time_series_list = exporter.create_time_series_list(v_data)
self.assertEqual(len(time_series_list), 1)
time_series = time_series_list[0]
self.assertEqual(time_series.resource.type, 'global')
self.check_labels(time_series.resource.labels, {})
self.assertEqual(
time_series.metric.type,
"custom.googleapis.com/opencensus/my.org/views/video_size_test2")
self.assertIsNotNone(time_series)
