def test_constructor_explicit(self): count = 4 count_aggregation = aggregation_module.CountAggregation(count=count) self.assertEqual(4, count_aggregation.count.count_data) self.assertEqual("count", count_aggregation.aggregation_type)
def test_prometheus_stats(self): method_key = tag_key_module.TagKey("method") request_count_measure = measure_module.MeasureInt( "request_count", "number of requests", "1") request_count_view_name = "request_count_view" count_agg = aggregation_module.CountAggregation() request_count_view = view_module.View( request_count_view_name, "number of requests broken down by methods", [method_key], request_count_measure, count_agg) stats = stats_module.stats view_manager = stats.view_manager stats_recorder = stats.stats_recorder exporter = prometheus.new_stats_exporter( prometheus.Options(namespace="opencensus", port=9303)) view_manager.register_exporter(exporter) view_manager.register_view(request_count_view) time.sleep(random.randint(1, 10) / 1000.0) method_value_1 = tag_value_module.TagValue("some method") tag_map_1 = tag_map_module.TagMap() tag_map_1.insert(method_key, method_value_1) measure_map_1 = stats_recorder.new_measurement_map() measure_map_1.measure_int_put(request_count_measure, 1) measure_map_1.record(tag_map_1) method_value_2 = tag_value_module.TagValue("some other method") tag_map_2 = tag_map_module.TagMap() tag_map_2.insert(method_key, method_value_2) measure_map_2 = stats_recorder.new_measurement_map() measure_map_2.measure_int_put(request_count_measure, 1) measure_map_2.record(tag_map_2) measure_map_2.record(tag_map_2) if sys.version_info > (3, 0): import urllib.request contents = urllib.request.urlopen( "http://localhost:9303/metrics").read() else: import urllib2 contents = urllib2.urlopen("http://localhost:9303/metrics").read() self.assertIn(b'# TYPE opencensus_request_count_view_total counter', contents) self.assertIn( b'opencensus_request_count_view_total' b'{method="some method"} 1.0', contents) self.assertIn( b'opencensus_request_count_view_total' b'{method="some other method"} 2.0', contents)
def test_prometheus_stats(self): import random import time import sys from opencensus.stats import aggregation as aggregation_module from opencensus.stats.exporters import prometheus_exporter as prometheus from opencensus.stats import measure as measure_module from opencensus.stats import stats as stats_module from opencensus.stats import view as view_module from opencensus.tags import tag_key as tag_key_module from opencensus.tags import tag_map as tag_map_module from opencensus.tags import tag_value as tag_value_module MiB = 1 << 20 FRONTEND_KEY = tag_key_module.TagKey("my.org/keys/frontend") VIDEO_SIZE_MEASURE = measure_module.MeasureInt( "my.org/measures/video_size", "size of processed videos", "By") VIDEO_SIZE_VIEW_NAME = "my.org/views/video_size" VIDEO_SIZE_DISTRIBUTION = aggregation_module.CountAggregation( 256.0 * MiB) VIDEO_SIZE_VIEW = view_module.View(VIDEO_SIZE_VIEW_NAME, "processed video size over time", [FRONTEND_KEY], VIDEO_SIZE_MEASURE, VIDEO_SIZE_DISTRIBUTION) stats = stats_module.Stats() view_manager = stats.view_manager stats_recorder = stats.stats_recorder exporter = prometheus.new_stats_exporter(prometheus.Options(namespace="opencensus", port=9303)) view_manager.register_exporter(exporter) view_manager.register_view(VIDEO_SIZE_VIEW) time.sleep(random.randint(1, 10) / 1000.0) tag_value = tag_value_module.TagValue(str(random.randint(1, 10000))) 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) if sys.version_info > (3, 0): import urllib.request contents = urllib.request.urlopen("http://localhost:9303/metrics").read() else: import urllib2 contents = urllib2.urlopen("http://localhost:9303/metrics").read() self.assertIn(b'# TYPE opencensus_my.org/views/video_size counter', contents) self.assertIn(b'opencensus_my.org/views/video_size 268435456.0', contents)
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_create_metric_descriptor_count(self): client = mock.Mock() option = stackdriver.Options( project_id="project-test", metric_prefix="teste") view_name_count = "view-count" agg_count = aggregation_module.CountAggregation(count=2) view_count = view_module.View( view_name_count, "processed video size over time", [FRONTEND_KEY], VIDEO_SIZE_MEASURE, agg_count) exporter = stackdriver.StackdriverStatsExporter( options=option, client=client) desc = exporter.create_metric_descriptor(view_count) self.assertIsNotNone(desc)
def __init__(self, test_name, test_description=None): # oc will automatically search for the ENV VAR 'APPLICATIONINSIGHTS_CONNECTION_STRING' self.exporter = metrics_exporter.new_metrics_exporter() self.stats = stats_module.stats self.view_manager = self.stats.view_manager self.stats_recorder = self.stats.stats_recorder self.azure_logger = get_azure_logger(test_name) self.name = test_name self.desc = test_description events_measure_name = "The number of events handled by " + self.name events_measure_desc = "The number of events handled by " + self.desc if self.desc else None memory_measure_name = "memory usage percentage for " + self.name memory_measure_desc = "memory usage percentage for " + self.desc if self.desc else None cpu_measure_name = "cpu usage percentage for " + self.name cpu_measure_desc = "cpu usage percentage for " + self.desc if self.desc else None error_measure_name = "error count for " + self.name error_measure_desc = "The number of errors happened while running the test for " + self.desc if self.desc else None self.events_measure = measure_module.MeasureInt( events_measure_name, events_measure_desc, "events") self.memory_measure = measure_module.MeasureFloat( memory_measure_name, memory_measure_desc) self.cpu_measure = measure_module.MeasureFloat(cpu_measure_name, cpu_measure_desc) self.error_measure = measure_module.MeasureInt(error_measure_name, error_measure_desc) self.events_measure_view = view_module.View( events_measure_name, events_measure_desc, [], self.events_measure, aggregation_module.SumAggregation()) self.memory_measure_view = view_module.View( memory_measure_name, memory_measure_desc, [], self.memory_measure, aggregation_module.LastValueAggregation()) self.cpu_measure_view = view_module.View( cpu_measure_name, cpu_measure_desc, [], self.cpu_measure, aggregation_module.LastValueAggregation()) self.error_measure_view = view_module.View( error_measure_name, error_measure_desc, [], self.error_measure, aggregation_module.CountAggregation()) self.view_manager.register_view(self.events_measure_view) self.view_manager.register_view(self.memory_measure_view) self.view_manager.register_view(self.cpu_measure_view) self.view_manager.register_view(self.error_measure_view) self.mmap = self.stats_recorder.new_measurement_map()
def __init__(self, export_metrics=False): self.nb_check_requests = measure_module.MeasureInt( "nb_check_requests", "number of dates check requests for all weeks", "nb") self.nb_check_requests_view = view_module.View( "nb_check_requests view", "number of dates check requests for all weeks", [], self.nb_check_requests, aggregation_module.CountAggregation()) view_manager.register_view(self.nb_check_requests_view) self.mmap = stats_recorder.new_measurement_map() self.tmap = tag_map_module.TagMap() if export_metrics: exporter = metrics_exporter.new_metrics_exporter( connection_string=azure_insights.connection_string) view_manager.register_exporter(exporter)
def test_collector_to_metric_count(self): agg = aggregation_module.CountAggregation(256) view = view_module.View(VIDEO_SIZE_VIEW_NAME, "processed video size over time", [FRONTEND_KEY], VIDEO_SIZE_MEASURE, agg) registry = mock.Mock() view_data = mock.Mock() options = prometheus.Options("test1", 8001, "localhost", registry) collector = prometheus.Collector(options=options, view_data=view_data) collector.register_view(view) desc = collector.registered_views[list(REGISTERED_VIEW)[0]] metric = collector.to_metric(desc=desc, view=view) self.assertEqual(desc['name'], metric.name) self.assertEqual(desc['documentation'], metric.documentation) self.assertEqual('counter', metric.type) self.assertEqual(1, len(metric.samples))
def enable_metrics_views(): calls_view = view_module.View("pymemcache/calls", "The number of calls", [key_method, key_error, key_status], m_calls, aggregation_module.CountAggregation()) latency_view = view_module.View("pymemcache/latency", "The distribution of the latencies", [key_method, key_error, key_status], m_latency_ms, aggregation_module.DistributionAggregation([ # Latency in buckets: # [>=0ms, >=5ms, >=10ms, >=25ms, >=40ms, >=50ms, >=75ms, >=100ms, >=200ms, >=400ms, >=600ms, >=800ms, >=1s, >=2s, >=4s, >=6s, >=10s, >-20s] 0, 5, 10, 25, 40, 50, 75, 100, 200, 400, 600, 800, 1000, 2000, 4000, 6000, 10000, 20000 ])) view_manager = stats.Stats().view_manager view_manager.register_view(calls_view) view_manager.register_view(latency_view)
def test_create_timeseries_str_tagvalue_count_aggregtation( self, monitor_resource_mock): view_manager, stats_recorder, exporter = \ self.setup_create_timeseries_test() agg_1 = aggregation_module.CountAggregation(count=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) time_series_list = exporter.create_time_series_list( v_data, "global", "kubernetes.io/myorg/") self.assertEqual(len(time_series_list), 1) time_series = time_series_list[0] self.assertEqual(time_series.metric.type, "kubernetes.io/myorg/view-name1") self.assertCorrectLabels(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() expected_value.int64_value = 3 self.assertEqual(time_series.points[0].value, expected_value)
def __init__(self, dialog_id: str = None): super(BookingDialog, self).__init__(dialog_id or BookingDialog.__name__) self.add_dialog(TextPrompt(TextPrompt.__name__)) self.add_dialog(ConfirmPrompt(ConfirmPrompt.__name__)) self.add_dialog(DateResolverDialog(DateResolverDialog.__name__)) self.add_dialog( WaterfallDialog( WaterfallDialog.__name__, [ self.destination_step, self.origin_step, self.from_date_step, self.to_date_step, self.budget_step, self.confirm_step, self.final_step, ], )) self.initial_dialog_id = WaterfallDialog.__name__ self.logger = None self.stats = stats_module.stats self.view_manager = self.stats.view_manager self.stats_recorder = self.stats.stats_recorder self.bot_measure = measure_module.MeasureInt("botdefects", "number of bot defects", "botdefects") self.bot_view = view_module.View("defect view", "number of bot defects", [], self.bot_measure, aggregation_module.CountAggregation()) self.view_manager.register_view(self.bot_view) self.mmap = self.stats_recorder.new_measurement_map() self.tmap = tag_map_module.TagMap() self.metrics_exporter = None self.message_history = set()
# The latency in milliseconds MEASURE = measure_module.MeasureFloat("number", "A number!", "things") GAUGE_VIEWS = { "last": view_module.View( "last", "A last value", ("tag",), MEASURE, aggregation_module.LastValueAggregation(), ) } COUNT_VIEWS = { "count": view_module.View( "count", "A count", ("tag",), MEASURE, aggregation_module.CountAggregation() ), "sum": view_module.View( "sum", "A sum", ("tag",), MEASURE, aggregation_module.SumAggregation() ), } DISTRIBUTION_VIEWS = { "distribution": view_module.View( "distribution", "A distribution", ("tag",), MEASURE, aggregation_module.DistributionAggregation([50.0, 200.0]), ) } VIEWS = {}
from opencensus.ext.azure import metrics_exporter from opencensus.stats import aggregation as aggregation_module from opencensus.stats import measure as measure_module from opencensus.stats import stats as stats_module from opencensus.stats import view as view_module from opencensus.tags import tag_map as tag_map_module stats = stats_module.stats view_manager = stats.view_manager stats_recorder = stats.stats_recorder CARROTS_MEASURE = measure_module.MeasureInt("carrots", "number of carrots", "carrots") CARROTS_VIEW = view_module.View("carrots_view", "number of carrots", [], CARROTS_MEASURE, aggregation_module.CountAggregation()) def main(): # Enable metrics # Set the interval in seconds in which you want to send metrics # TODO: you need to specify the instrumentation key in a connection string # and place it in the APPLICATIONINSIGHTS_CONNECTION_STRING # environment variable. exporter = metrics_exporter.new_metrics_exporter() view_manager.register_exporter(exporter) view_manager.register_view(CARROTS_VIEW) mmap = stats_recorder.new_measurement_map() tmap = tag_map_module.TagMap()
def test_constructor_defaults(self): count_aggregation = aggregation_module.CountAggregation() self.assertEqual(0, count_aggregation.count.count_data) self.assertEqual(aggregation_module.Type.COUNT, count_aggregation.aggregation_type)
def register_views(): all_tag_keys = [key_method, key_error, key_status] calls_view = view.View("redispy/calls", "The number of calls", all_tag_keys, m_latency_ms, aggregation.CountAggregation()) latency_view = view.View( "redispy/latency", "The distribution of the latencies per method", all_tag_keys, m_latency_ms, aggregation.DistributionAggregation([ # Latency in buckets: # [ # >=0ms, >=5ms, >=10ms, >=25ms, >=40ms, >=50ms, >=75ms, >=100ms, >=200ms, >=400ms, # >=600ms, >=800ms, >=1s, >=2s, >=4s, >=6s, >=10s, >-20s, >=50s, >=100s # ] 0, 5, 10, 25, 40, 50, 75, 1e2, 2e2, 4e2, 6e2, 8e2, 1e3, 2e3, 4e3, 6e3, 1e4, 2e4, 5e4, 10e5 ])) key_lengths_view = view.View( "redispy/key_lengths", "The distribution of the key lengths", all_tag_keys, m_key_length, aggregation.DistributionAggregation([ # Key length buckets: # [ # 0B, 5B, 10B, 20B, 50B, 100B, 200B, 500B, 1000B, 2000B, 5000B # ] 0, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000 ])) value_lengths_view = view.View( "redispy/value_lengths", "The distribution of the value lengths", all_tag_keys, m_value_length, aggregation.DistributionAggregation([ # Value length buckets: # [ # 0B, 5B, 10B, 20B, 50B, 100B, 200B, 500B, 1000B, 2000B, 5000B, 10000B, 20000B # ] 0, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000 ])) view_manager = stats.stats.view_manager for each_view in [ calls_view, latency_view, key_lengths_view, value_lengths_view ]: view_manager.register_view(each_view)
def test_new_aggregation_data_explicit(self): count_aggregation = aggregation_module.CountAggregation(count=4) agg_data = count_aggregation.new_aggregation_data() self.assertEqual(4, agg_data.count_data)
def test_new_aggregation_data_defaults(self): count_aggregation = aggregation_module.CountAggregation() agg_data = count_aggregation.new_aggregation_data() self.assertEqual(0, agg_data.count_data)