def test_filter_exported_views(self):
test_view_1_name = "testView1"
description = "testDescription"
columns = mock.Mock()
measure = mock.Mock()
aggregation = mock.Mock()
test_view_1 = View(name=test_view_1_name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
print("test view 1", test_view_1)
test_view_2_name = "testView2"
test_view_2 = View(name=test_view_2_name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
print("test view 2", test_view_2)
all_the_views = {test_view_1, test_view_2}
print("all the views", all_the_views)
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
views = measure_to_view_map.filter_exported_views(
all_views=all_the_views)
print("filtered views", views)
self.assertEqual(views, all_the_views)
def test_record_with_exporter(self):
exporter = mock.Mock()
measure_name = "test_measure"
measure_description = "test_description"
measure = BaseMeasure(name=measure_name,
description=measure_description)
view_name = "test_view"
view_description = "test_description"
view_columns = ["testTag1", "testColumn2"]
view_measure = measure
view_aggregation = mock.Mock()
View(name=view_name,
description=view_description,
columns=view_columns,
measure=view_measure,
aggregation=view_aggregation)
measure_value = 5
tags = {"testTag1": "testTag1Value"}
measurement_map = {measure: measure_value}
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map.exporters.append(exporter)
measure_to_view_map._registered_measures = {}
record = measure_to_view_map.record(tags=tags,
measurement_map=measurement_map,
timestamp=timestamp)
self.assertNotEqual(
measure,
measure_to_view_map._registered_measures.get(measure.name))
self.assertIsNone(record)
def test_register_view_with_exporter(self):
exporter = mock.Mock()
name = "testView"
description = "testDescription"
columns = mock.Mock()
measure = MeasureInt("measure", "description", "1")
aggregation = mock.Mock()
view = View(name=name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map.exporters.append(exporter)
measure_to_view_map._registered_views = {}
measure_to_view_map._registered_measures = {}
measure_to_view_map.register_view(view=view, timestamp=timestamp)
self.assertIsNone(measure_to_view_map.exported_views)
self.assertEqual(measure_to_view_map._registered_views[view.name],
view)
self.assertEqual(
measure_to_view_map._registered_measures[measure.name], measure)
self.assertIsNotNone(
measure_to_view_map._measure_to_view_data_list_map[
view.measure.name])
def test_export(self):
exporter = mock.Mock()
view_data = []
measure_name = "test_measure"
measure_description = "test_description"
measure = BaseMeasure(
name=measure_name, description=measure_description)
view_name = "test_view"
view_description = "test_description"
view_columns = ["testTag1", "testColumn2"]
view_measure = measure
view_aggregation = mock.Mock()
view = View(
name=view_name,
description=view_description,
columns=view_columns,
measure=view_measure,
aggregation=view_aggregation)
measure_value = 5
tags = {"testTag1": "testTag1Value"}
measurement_map = {measure: measure_value}
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map.exporters.append(exporter)
measure_to_view_map._registered_measures = {}
measure_to_view_map.export(view_data)
self.assertTrue(True)
def test_get_view(self):
name = "testView"
description = "testDescription"
columns = mock.Mock()
measure = mock.Mock()
aggregation = mock.Mock()
view = View(name=name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map._registered_views = {}
no_registered_views = measure_to_view_map.get_view(view_name=name,
timestamp=timestamp)
self.assertEqual(None, no_registered_views)
measure_to_view_map._registered_views = {name: view}
measure_to_view_map._map = {
view.measure.name:
[ViewData(view=view, start_time=timestamp, end_time=timestamp)]
}
print(measure_to_view_map._map)
view_data = measure_to_view_map.get_view(view_name=name,
timestamp=timestamp)
self.assertIsNotNone(view_data)
measure_to_view_map._map = {}
view_data = measure_to_view_map.get_view(view_name=name,
timestamp=timestamp)
self.assertIsNone(view_data)
measure_to_view_map._map = {
view.measure.name: [
ViewData(view=mock.Mock(),
start_time=timestamp,
end_time=timestamp)
]
}
view_data = measure_to_view_map.get_view(view_name=name,
timestamp=timestamp)
self.assertIsNone(view_data)
def test_register_view(self):
name = "testView"
description = "testDescription"
columns = mock.Mock()
measure = mock.Mock()
aggregation = mock.Mock()
view = View(name=name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map._registered_views = {}
measure_to_view_map._registered_measures = {}
measure_to_view_map.register_view(view=view, timestamp=timestamp)
self.assertIsNone(measure_to_view_map.exported_views)
self.assertEqual(measure_to_view_map._registered_views[measure.name],
view)
self.assertEqual(
measure_to_view_map._registered_measures[measure.name], measure)
self.assertIsNotNone(measure_to_view_map._map[view.measure.name])
test_measure = mock.Mock()
measure_to_view_map._registered_measures = {measure.name: test_measure}
test_with_registered_measures = measure_to_view_map.register_view(
view=view, timestamp=timestamp)
self.assertIsNone(test_with_registered_measures)
self.assertIsNotNone(measure_to_view_map._map[view.measure.name])
measure_to_view_map._registered_measures = {measure.name: None}
self.assertIsNone(
measure_to_view_map._registered_measures.get(measure.name))
measure_to_view_map.register_view(view=view, timestamp=timestamp)
self.assertEqual(
measure, measure_to_view_map._registered_measures[measure.name])
self.assertIsNotNone(measure_to_view_map._map[view.measure.name])
measure_to_view_map._registered_views = {name: view}
test_result_1 = measure_to_view_map.register_view(view=view,
timestamp=timestamp)
self.assertIsNone(test_result_1)
self.assertIsNotNone(measure_to_view_map._map[view.measure.name])
def _record_metrics(self, metrics):
# The list of view data is what we are going to use for the
# final export to exporter.
view_data_changed: List[ViewData] = []
# Walk the protobufs and convert them to ViewData
for metric in metrics:
descriptor = metric.metric_descriptor
timeseries = metric.timeseries
if len(timeseries) == 0:
continue
columns = [label_key.key for label_key in descriptor.label_keys]
start_time = timeseries[0].start_timestamp.seconds
# Create the view and view_data
measure = measure_module.BaseMeasure(
descriptor.name, descriptor.description, descriptor.unit)
view = self.view_manager.measure_to_view_map.get_view(
descriptor.name, None)
if not view:
view = View(
descriptor.name,
descriptor.description,
columns,
measure,
aggregation=None)
self.view_manager.measure_to_view_map.register_view(
view, start_time)
view_data = (self.view_manager.measure_to_view_map.
_measure_to_view_data_list_map[measure.name][-1])
view_data_changed.append(view_data)
# Create the aggregation and fill it in the our stats
for series in timeseries:
tag_vals = tuple(val.value for val in series.label_values)
for point in series.points:
if point.HasField("int64_value"):
data = CountAggregationData(point.int64_value)
elif point.HasField("double_value"):
data = LastValueAggregationData(
ValueDouble, point.double_value)
elif point.HasField("distribution_value"):
dist_value = point.distribution_value
counts_per_bucket = [
bucket.count for bucket in dist_value.buckets
]
bucket_bounds = (
dist_value.bucket_options.explicit.bounds)
data = DistributionAggregationData(
dist_value.sum / dist_value.count,
dist_value.count,
dist_value.sum_of_squared_deviation,
counts_per_bucket, bucket_bounds)
else:
raise ValueError("Summary is not supported")
view_data.tag_value_aggregation_data_map[tag_vals] = data
# Finally, export all the values
self.view_manager.measure_to_view_map.export(view_data_changed)
def __init__(self, name, description, unit, tags: List[str]):
self._measure = measure_module.MeasureInt(name, description, unit)
tags = [tag_key_module.TagKey(tag) for tag in tags]
self._view = View(name, description, tags, self.measure,
aggregation.LastValueAggregation())
def test_record(self):
measure_name = "test_measure"
measure_description = "test_description"
measure = BaseMeasure(name=measure_name,
description=measure_description)
view_name = "test_view"
view_description = "test_description"
view_columns = ["testTag1", "testColumn2"]
view_measure = measure
view_aggregation = mock.Mock()
view = View(name=view_name,
description=view_description,
columns=view_columns,
measure=view_measure,
aggregation=view_aggregation)
measure_value = 5
value = "testValue"
tags = {"testTag1": "testTag1Value"}
stats = {Measurement(measure=measure, value=measure_value): value}
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map._registered_measures = {}
record = measure_to_view_map.record(tags=tags,
stats=stats,
timestamp=timestamp)
self.assertNotEqual(
measure,
measure_to_view_map._registered_measures.get(measure.name))
self.assertIsNone(record)
measure_to_view_map._registered_measures = {measure.name: measure}
measure_to_view_map._map = {}
record = measure_to_view_map.record(tags=tags,
stats=stats,
timestamp=timestamp)
self.assertEqual(
measure,
measure_to_view_map._registered_measures.get(measure.name))
self.assertIsNone(record)
measure_to_view_map._map = {measure.name: mock.Mock()}
measure_to_view_map.record(tags=tags, stats=stats, timestamp=timestamp)
self.assertEqual(
measure,
measure_to_view_map._registered_measures.get(measure.name))
self.assertTrue(measure.name in measure_to_view_map._map)
measure_to_view_map._map = {"testing": mock.Mock()}
measure_to_view_map.record(tags=tags, stats=stats, timestamp=timestamp)
self.assertTrue(measure.name not in measure_to_view_map._map)
measure_to_view_map_mock = mock.Mock()
measure_to_view_map = measure_to_view_map_mock
measure_to_view_map._registered_measures = {measure.name: measure}
measure_to_view_map._map = mock.Mock()
measure_to_view_map.record(tags=mock.Mock(),
stats=mock.Mock(),
timestamp=mock.Mock())
self.assertEqual(
measure,
measure_to_view_map._registered_measures.get(measure.name))
self.assertIsNotNone(measure_to_view_map.view_datas)
self.assertTrue(measure_to_view_map_mock.record.called)
tags = {"testTag1": "testTag1Value"}
stats = {}
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
record = measure_to_view_map.record(tags=tags,
stats=stats,
timestamp=timestamp)
self.assertIsNone(record)
def test_register_view(self):
name = "testView"
description = "testDescription"
columns = mock.Mock()
measure = MeasureInt("measure", "description", "1")
aggregation = mock.Mock()
view = View(name=name,
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
timestamp = mock.Mock()
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
measure_to_view_map._registered_views = {}
measure_to_view_map._registered_measures = {}
measure_to_view_map.register_view(view=view, timestamp=timestamp)
self.assertIsNone(measure_to_view_map.exported_views)
self.assertEqual(measure_to_view_map._registered_views[view.name],
view)
self.assertEqual(
measure_to_view_map._registered_measures[measure.name], measure)
self.assertIsNotNone(
measure_to_view_map._measure_to_view_data_list_map[
view.measure.name])
# Registers a view with an existing measure.
view2 = View(name="testView2",
description=description,
columns=columns,
measure=measure,
aggregation=aggregation)
test_with_registered_measures = measure_to_view_map.register_view(
view=view2, timestamp=timestamp)
self.assertIsNone(test_with_registered_measures)
self.assertEqual(
measure_to_view_map._registered_measures[measure.name], measure)
# Registers a view with a measure that has the same name as an existing
# measure, but with different schema. measure2 and view3 should be
# ignored.
measure2 = MeasureInt("measure", "another measure", "ms")
view3 = View(name="testView3",
description=description,
columns=columns,
measure=measure2,
aggregation=aggregation)
test_with_registered_measures = measure_to_view_map.register_view(
view=view3, timestamp=timestamp)
self.assertIsNone(test_with_registered_measures)
self.assertEqual(
measure_to_view_map._registered_measures[measure2.name], measure)
measure_to_view_map._registered_measures = {measure.name: None}
self.assertIsNone(
measure_to_view_map._registered_measures.get(measure.name))
measure_to_view_map.register_view(view=view, timestamp=timestamp)
# view is already registered, measure will not be registered again.
self.assertIsNone(
measure_to_view_map._registered_measures.get(measure.name))
self.assertIsNotNone(
measure_to_view_map._measure_to_view_data_list_map[
view.measure.name])
measure_to_view_map._registered_views = {name: view}
test_result_1 = measure_to_view_map.register_view(view=view,
timestamp=timestamp)
self.assertIsNone(test_result_1)
self.assertIsNotNone(
measure_to_view_map._measure_to_view_data_list_map[
view.measure.name])
import mock
from opencensus.stats import measure_to_view_map as measure_to_view_map_module
from opencensus.stats.aggregation import CountAggregation
from opencensus.stats.measure import BaseMeasure
from opencensus.stats.measure import MeasureInt
from opencensus.stats.view import View
from opencensus.stats.view_data import ViewData
from opencensus.tags import tag_key as tag_key_module
METHOD_KEY = tag_key_module.TagKey("method")
REQUEST_COUNT_MEASURE = MeasureInt("request_count", "number of requests", "1")
REQUEST_COUNT_VIEW_NAME = "request_count_view"
COUNT = CountAggregation()
REQUEST_COUNT_VIEW = View(REQUEST_COUNT_VIEW_NAME,
"number of requests broken down by methods",
[METHOD_KEY], REQUEST_COUNT_MEASURE, COUNT)
class TestMeasureToViewMap(unittest.TestCase):
@staticmethod
def _get_target_class():
return measure_to_view_map_module.MeasureToViewMap
def _make_one(self, *args, **kw):
return self._get_target_class()(*args, **kw)
def test_constructor(self):
measure_to_view_map = measure_to_view_map_module.MeasureToViewMap()
self.assertEqual({},