def create_metrics(platform: Platform) -> List[Metric]: """Creates a list of Metric objects from data in Platform object""" platform_metrics = [] platform_metrics.extend([ Metric.create_metric_with_metadata(MetricName.PLATFORM_TOPOLOGY_CORES, value=platform.cores), Metric.create_metric_with_metadata(MetricName.PLATFORM_TOPOLOGY_CPUS, value=platform.cpus), Metric.create_metric_with_metadata(MetricName.PLATFORM_TOPOLOGY_SOCKETS, value=platform.sockets), Metric.create_metric_with_metadata(MetricName.PLATFORM_LAST_SEEN, value=time.time()), ]) # Exporting measurements into metrics. platform_metrics.extend(export_metrics_from_measurements(platform.measurements)) platform_metrics.append( Metric.create_metric_with_metadata( MetricName.WCA_INFORMATION, value=1, labels=dict( sockets=str(platform.sockets), cores=str(platform.cores), cpus=str(platform.cpus), cpu_model=platform.cpu_model, wca_version=get_wca_version(), ) ) ) return platform_metrics
def test_parse(mock_print): input_ = StringIO( "2018-08-22 17:33:25:811 581 sec: 581117 operations; " "975 current ops/sec; " "est completion in 2 hours 36 minutes " "[READ: Count=462, Max=554, Min=273, Avg=393.39, 90=457, " "99=525, 99.9=554, 99.99=554] [UPDATE: Count=513, Max=699, " "Min=254, Avg=383.83, 90=441, 99=512, 99.9=589, 99.99=699] # noq") expected = [ Metric("cassandra_operations", value=581117, type=MetricType.GAUGE, help="Done operations in Cassandra"), Metric("cassandra_ops_per_sec", value=975, type=MetricType.GAUGE, help="Ops per sec Cassandra"), Metric("cassandra_read_p9999", value=554.0, type=MetricType.GAUGE, help="99.99th percentile of read latency in Cassandra"), Metric("cassandra_update_p9999", value=699.0, type=MetricType.GAUGE, help="99.99th percentile of update latency in Cassandra"), ] assert expected == parse(input_, None, None, {}, 'cassandra_')
def test_parse_scan_mode(): data = """ #type avg min 1st 5th 10th 90th 95th 99th QPS target read 76.3 346.3 21.1 23.5 24.5 34.3 38.7 2056.6 1002.0 1000""" number_of_reads = len(data.splitlines()) input_ = StringIO(data) got = [] for _ in range(number_of_reads): got.extend(parse(input_, '', None, {}, 'twemcache_')) expected = [ Metric('twemcache_scan_qps', value=1002.0, labels={}, type=MetricType.GAUGE, help="QPS"), Metric('twemcache_scan_read_avg', value=76.3, labels={}, type=MetricType.GAUGE, help="Average"), Metric('twemcache_scan_read_p90', value=34.3, labels={}, type=MetricType.GAUGE, help="90th percentile of read latency"), Metric('twemcache_scan_read_p95', value=38.7, labels={}, type=MetricType.GAUGE, help="95th percentile of read latency"), Metric('twemcache_scan_read_p99', value=2056.6, labels={}, type=MetricType.GAUGE, help="99th percentile of read latency") ] assert expected == got
def calculate_variance(app_name, node_name: str, requested_fraction: Dict[ResourceType, float], bar_weights: Dict[ResourceType, float]) -> \ Tuple[float, List[Metric]]: """Return variance using bar_weights""" # Mean - priority according to variance of dimensions metrics = [] mean = sum([v for v in requested_fraction.values()]) / len(requested_fraction) log.log(TRACE, "[Prioritize][app=%s][node=%s][bar] Mean: %s", app_name, node_name, mean) metrics.append( Metric(name=MetricName.BAR_MEAN, value=mean, labels=dict(app=app_name, node=node_name), type=MetricType.GAUGE)) # Variance if len(requested_fraction) > 2: variance = sum([((fraction - mean) * (fraction - mean)) * bar_weights.get(rt, 1) for rt, fraction in requested_fraction.items()]) \ / len(requested_fraction) elif len(requested_fraction) == 2: values = list(requested_fraction.values()) variance = abs(values[0] - values[1]) else: variance = 0 log.log(TRACE, "[Prioritize][app=%s][node=%s][bar] " "Variance(weighted quadratic sum of requested_fraction-mean): %s", app_name, node_name, variance) metrics.append( Metric(name=MetricName.BAR_VARIANCE, value=variance, labels=dict(app=app_name, node=node_name), type=MetricType.GAUGE)) return variance, metrics
def test_parse(): data = """#type avg std min 5th 10th 90th 95th 99th read 801.9 155.0 304.5 643.7 661.1 1017.8 1128.2 1386.5 update 804.6 157.8 539.4 643.4 661.2 1026.1 1136.1 1404.3 op_q 1.0 0.0 1.0 1.0 1.0 1.1 1.1 1.1 Total QPS = 159578.5 (1595835 / 10.0s) Misses = 0 (0.0%) Skipped TXs = 0 (0.0%) RX 382849511 bytes : 36.5 MB/s TX 67524708 bytes : 6.4 MB/s """ number_of_reads = len(data.splitlines()) input_ = StringIO(data) got = [] for _ in range(number_of_reads): got.extend(parse(input_, '', None, {}, 'twemcache_')) expected = [ Metric('twemcache_read_avg', value=801.9, labels={}, type=MetricType.GAUGE, help="Average"), Metric('twemcache_read_p90', value=1017.8, labels={}, type=MetricType.GAUGE, help="90th percentile of read latency"), Metric('twemcache_read_p95', value=1128.2, labels={}, type=MetricType.GAUGE, help="95th percentile of read latency"), Metric('twemcache_read_p99', value=1386.5, labels={}, type=MetricType.GAUGE, help="99th percentile of read latency"), Metric('twemcache_qps', value=159578.5, labels={}, type=MetricType.GAUGE, help="QPS")] assert expected == got
def test_grouping_metrics_by_metadata(sample_metrics_mixed): got_grouped = storage.group_metrics_by_name(sample_metrics_mixed) expected_grouped = [ ('bar', [ Metric(name='bar', value=89, type=None, help='bar-help'), ]), ('bar2', [ Metric(name='bar2', value=89), ]), ('foo', [ Metric(name='foo', value=1, labels=dict(a='1'), type=MetricType.COUNTER, help='foo-help'), Metric(name='foo', value=1, labels=dict(a='3'), type=MetricType.COUNTER, help='foo-help'), Metric(name='foo', value=1, labels=dict(a='20'), type=MetricType.COUNTER, help='foo-help'), ]), ] assert got_grouped == expected_grouped
def parse(input: TextIOWrapper, regexp: str, separator: str = None, labels: Dict[str, str] = {}, metric_name_prefix: str = '') -> List[Metric]: """Custom parse function for YCSB. Parses lines similar to (added new line characters to improve readibility): 2018-08-22 17:33:25:811 581 sec: 581117 operations; 975 current ops/sec; est completion in 2 hours 36 minutes [READ: Count=462, Max=554, Min=273, Avg=393.39, 90=457, 99=525, 99.9=554, 99.99=554] [UPDATE: Count=513, Max=699, Min=254, Avg=383.83, 90=441, 99=512, 99.9=589, 99.99=699] # noqa """ new_metrics = [] new_line = readline_with_check(input) if "operations" in new_line: operations_and_ops = \ re.search(r'(?P<operations>\d+) operations;', new_line).groupdict() operations = float(operations_and_ops['operations']) new_metrics.append( Metric(metric_name_prefix + 'operations', operations, type=MetricType.GAUGE, labels=labels, help="Done operations in Cassandra")) if "current ops" in new_line: operations_and_ops = \ re.search(r'(?P<ops_per_sec>\d+(\.\d+)?) current ops\/sec', new_line).groupdict() ops_per_sec = float(operations_and_ops['ops_per_sec']) new_metrics.append( Metric(metric_name_prefix + 'ops_per_sec', ops_per_sec, type=MetricType.GAUGE, labels=labels, help="Ops per sec Cassandra")) if "READ" in new_line: read = re.search(r'\[READ.*?99\.99=(\d+).*?\]', new_line) p9999 = float(read.group(1)) new_metrics.append( Metric(metric_name_prefix + 'read_p9999', p9999, type=MetricType.GAUGE, labels=labels, help="99.99th percentile of read latency in Cassandra")) if "UPDATE" in new_line: update = re.search(r'\[UPDATE.*?99\.99=(\d+).*?\]', new_line) p9999 = float(update.group(1)) new_metrics.append( Metric(metric_name_prefix + 'update_p9999', p9999, type=MetricType.GAUGE, labels=labels, help="99.99th percentile of update latency in Cassandra")) return new_metrics
def _log_initial_state(tasks_data, balanced_memory, extra_metrics): log.log( TRACE, "Current state of the system, balanced_memory=%s[bytes]" % balanced_memory) log.debug( "Current task assigments to nodes, expressed " "in sum of memory limits of pinned tasks: %s[bytes]" % { node: sum(t[1] for t in tasks) / 2**10 for node, tasks in balanced_memory.items() }) log.debug("Current task assigments: %s" % {node: len(tasks) for node, tasks in balanced_memory.items()}) log.debug( "Current task assigments: %s" % { node: [task[0] for task in tasks] for node, tasks in balanced_memory.items() }) for node, tasks_with_memory in balanced_memory.items(): extra_metrics.extend([ Metric('numa__balanced_memory_tasks', value=len(tasks_with_memory), labels=dict(numa_node=str(node))), Metric('numa__balanced_memory_size', value=sum([m for t, m in tasks_with_memory]), labels=dict(numa_node=str(node))), Metric('numa__task_tasks_count', value=len(tasks_data)), ])
def test_parse(mock_print): input_ = StringIO( "Results:" "Op rate : 14,997 op/s [WRITE: 14,997 op/s]" "Partition rate : 14,997 pk/s [WRITE: 14,997 pk/s]" "Row rate : 14,997 row/s [WRITE: 14,997 row/s]" "Latency mean : 1.9 ms [WRITE: 1.9 ms]" "Latency median : 0.3 ms [WRITE: 0.3 ms]" "Latency 95th percentile : 0.4 ms [WRITE: 0.4 ms]" "Latency 99th percentile : 74.0 ms [WRITE: 74.0 ms]" "Latency 99.9th percentile : 146.8 ms [WRITE: 146.8 ms]" "Latency max : 160.2 ms [WRITE: 160.2 ms]" "Total partitions : 1,350,028 [WRITE: 1,350,028]" "Total errors : 0 [WRITE: 0]" "Total GC count : 0" "Total GC memory : 0.000 KiB" "Total GC time : 0.0 seconds" "Avg GC time : NaN ms" "StdDev GC time : 0.0 ms" "Total operation time : 00:01:30" ) expected = [ Metric('cassandra_qps', value=14997, type=MetricType.GAUGE, help="QPS"), Metric('cassandra_p99', value=74.0, type=MetricType.GAUGE, help="99th percentile") ] assert expected == parse(input_, None, None, {}, 'cassandra_')
def test_parse(mock_print): input_ = StringIO( "2018-09-13 08:15:43.404 INFO [rpc-perf] -----" "2018-09-13 08:15:43.404 INFO [rpc-perf] Window: 155" "2018-09-13 08:15:43.404 INFO [rpc-perf] Connections: Ok: 0 Error: 0 Timeout: 0 Open: 80" "2018-09-13 08:15:43.404 INFO [rpc-perf] Sockets: Create: 0 Close: 0 Read: 31601 Write: " + "15795 Flush: 0" "2018-09-13 08:15:43.404 INFO [rpc-perf] Requests: Sent: 15795 Prepared: 16384 " + "In-Flight: 40" "2018-09-13 08:15:43.404 INFO [rpc-perf] Responses: Ok: 15793 Error: 0 Timeout: 0 Hit: " + "3144 Miss: 6960" "2018-09-13 08:15:43.404 INFO [rpc-perf] Rate: 15823.74 rps Success: 100.00 % Hit Rate:" + " 31.12 %" "2018-09-13 08:15:43.404 INFO [rpc-perf] Percentiles: Response OK (us): min: 47 p50: 389" + " p90: 775 p99: 86436 p999: 89120 p9999: 89657 max: 89657") expected = [ Metric("rpcperf_p9999", value=89657, type=MetricType.GAUGE, help="99.99th percentile of latency in rpc-perf"), Metric("rpcperf_p999", value=89120, type=MetricType.GAUGE, help="99.9th percentile of latency in rpc-perf"), Metric("rpcperf_p99", value=86436, type=MetricType.GAUGE, help="99th percentile of latency in rpc-perf"), Metric("rpcperf_p90", value=775, type=MetricType.GAUGE, help="90th percentile of latency in rpc-perf"), Metric("rpcperf_p50", value=389, type=MetricType.GAUGE, help="50th percentile of latency in rpc-perf"), Metric("rpcperf_min", value=47, type=MetricType.GAUGE, help="min of latency in rpc-perf"), Metric("rpcperf_max", value=89657, type=MetricType.GAUGE, help="max of latency in rpc-perf"), Metric("rpcperf_hit_rate", value=31.12, type=MetricType.GAUGE, help="Hit rate in rpc-perf"), Metric("rpcperf_success", value=100.00, type=MetricType.GAUGE, help="Success responses in rpc-perf"), Metric("rpcperf_rate", value=15823.74, type=MetricType.GAUGE, help="Rate in rpc-perf"), ] assert expected == parse(input_, None, None, {}, 'rpcperf_')
def sample_metrics(): return [ Metric(name='average_latency_miliseconds', value=8, labels={'user': '******', 'node': 'slave_1'}, type=MetricType.COUNTER, help='latency measured in miliseconds'), Metric(name='percentile_99th_miliseconds', value=89, labels={'user': '******', 'node': 'slave_1'}, type=MetricType.COUNTER, help='99th percentile in miliseconds') ]
def generate_metrics(self) -> List[Metric]: """Encode RDT Allocation as metrics. Note: - cache allocation: generated two metrics, with number of cache ways and mask of bits (encoded as int) - memory bandwidth: is encoded as int, representing MB/s or percentage """ # Empty object generate no metric. if not self.rdt_allocation.l3 and not self.rdt_allocation.mb: return [] group_name = self.get_resgroup_name() metrics = [] if self.rdt_allocation.l3: domains = _parse_schemata_file_row(self.rdt_allocation.l3) for domain_id, raw_value in domains.items(): metrics.extend([ Metric(name='allocation_rdt_l3_cache_ways', value=_count_enabled_bits(raw_value), type=MetricType.GAUGE, labels=dict( allocation_type='rdt_l3_cache_ways', group_name=group_name, domain_id=domain_id, container_name=self.container_name, )), Metric(name='allocation_rdt_l3_mask', value=int(raw_value, 16), type=MetricType.GAUGE, labels=dict( allocation_type='rdt_l3_mask', group_name=group_name, domain_id=domain_id, container_name=self.container_name, )) ]) if self.rdt_allocation.mb: domains = _parse_schemata_file_row(self.rdt_allocation.mb) for domain_id, raw_value in domains.items(): # NOTE: raw_value is treated as int, ignoring unit used (MB or %) value = int(raw_value) metrics.append( Metric(name='allocation_rdt_mb', value=value, type=MetricType.GAUGE, labels=dict( allocation_type='rdt_mb', group_name=group_name, domain_id=domain_id, container_name=self.container_name, ))) self.labels_updater.update_labels(metrics) return metrics
def sample_metrics_mixed(): return [ Metric(name='bar', value=89, type=None, help='bar-help'), Metric(name='foo', value=1, labels=dict(a='3'), type=MetricType.COUNTER, help='foo-help'), Metric(name='foo', value=1, labels=dict(a='20'), type=MetricType.COUNTER, help='foo-help'), Metric(name='foo', value=1, labels=dict(a='1'), type=MetricType.COUNTER, help='foo-help'), Metric(name='bar2', value=89), ]
def create_metrics(platform: Platform) -> List[Metric]: """Creates a list of Metric objects from data in Platform object""" platform_metrics = list() platform_metrics.append( Metric.create_metric_with_metadata(name=MetricName.MEM_USAGE, value=platform.total_memory_used)) for cpu_id, cpu_usage in platform.cpus_usage.items(): platform_metrics.append( Metric.create_metric_with_metadata( name=MetricName.CPU_USAGE_PER_CPU, value=cpu_usage, labels={"cpu": str(cpu_id)})) return platform_metrics
def _log_moved_pages(self, extra_metrics: List[Metric], tasks_data: TasksData): """modify extra_metrics""" for task, page_to_move in self._pages_to_move.items(): data: TaskData = tasks_data[task] extra_metrics.append( Metric('numa__task_pages_to_move', value=page_to_move, labels=data.labels)) total_pages_to_move = sum(p for p in self._pages_to_move.values()) extra_metrics.append( Metric('numa__total_pages_to_move', value=total_pages_to_move)) log.log(TRACE, 'Pages to move: %r', self._pages_to_move)
def get_logging_metrics() -> List[Metric]: metrics = [] for logger_name, counter in _module_record_counters.items(): metrics.extend([ Metric(name="wca_warning_count", type=MetricType.COUNTER, value=counter[logging.WARNING], labels={"module": logger_name}), Metric(name="wca_error_count", type=MetricType.COUNTER, value=counter[logging.ERROR], labels={"module": logger_name}), ]) return metrics
def parse(input: TextIOWrapper, regexp: str, separator: str = None, labels: Dict[str, str] = {}, metric_name_prefix: str = '') -> List[Metric]: """Custom parse function for cassandra-stress. Results: Op rate : 14,997 op/s [WRITE: 14,997 op/s] Partition rate : 14,997 pk/s [WRITE: 14,997 pk/s] Row rate : 14,997 row/s [WRITE: 14,997 row/s] Latency mean : 1.9 ms [WRITE: 1.9 ms] Latency median : 0.3 ms [WRITE: 0.3 ms] Latency 95th percentile : 0.4 ms [WRITE: 0.4 ms] Latency 99th percentile : 74.0 ms [WRITE: 74.0 ms] Latency 99.9th percentile : 146.8 ms [WRITE: 146.8 ms] Latency max : 160.2 ms [WRITE: 160.2 ms] Total partitions : 1,350,028 [WRITE: 1,350,028] Total errors : 0 [WRITE: 0] Total GC count : 0 Total GC memory : 0.000 KiB Total GC time : 0.0 seconds Avg GC time : NaN ms StdDev GC time : 0.0 ms Total operation time : 00:01:30 """ new_metrics = [] new_line = readline_with_check(input, EOF_line) if "Op rate" in new_line: read_op_rate = re.search(r'Op rate[ ]*:[ ]*([0-9,]*) op/s', new_line) op_rate = float(''.join(read_op_rate.group(1).split(','))) new_metrics.append( Metric(metric_name_prefix + 'qps', op_rate, type=MetricType.GAUGE, labels=labels, help="QPS")) if "Latency 99th percentile" in new_line: read = re.search( r'Latency 99th percentile[ ]*:[ ]*([0-9]*\.[0-9]*) ms', new_line) p99 = float(read.group(1)) new_metrics.append( Metric(metric_name_prefix + 'p99', p99, type=MetricType.GAUGE, labels=labels, help="99th percentile")) return new_metrics
def sample_metrics_unconvertable_to_PEF(): """for testing for proper float representation""" return [ Metric(name='latency-miliseconds', value=8.223, labels={'user': '******', 'node': 'slave_1'}, type=MetricType.COUNTER, help='latency measured in miliseconds'), ]
def parse(input: TextIOWrapper, regexp: str, separator: str = None, labels: Dict[str, str] = {}, metric_name_prefix: str = '') -> List[Metric]: """Custom parse function for gauge tpm from mysql. TPM: 87060.0 TPM: 95220.0 TPM: 93600.0 TPM: 90000.0 """ new_metrics = [] new_line = readline_with_check(input, EOF_line='end') if "TPM:" in new_line: regex = re.findall(r'TPM: (?P<tpm>\d*.\d*)', new_line) tpm = float(regex[0]) new_metrics.append( Metric(metric_name_prefix + 'tpm', tpm, type=MetricType.GAUGE, labels=labels, help="TPM (transaction per minute) from mysql")) return new_metrics
def _get_internal_metrics(tasks: List[Task]) -> List[Metric]: """Internal wca metrics e.g. memory usage, profiling information.""" # Memory usage. memory_usage_rss_self = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss memory_usage_rss_children = resource.getrusage(resource.RUSAGE_CHILDREN).ru_maxrss memory_usage_rss = memory_usage_rss_self + memory_usage_rss_children metrics = [ Metric(name='wca_up', type=MetricType.COUNTER, value=time.time()), Metric(name='wca_tasks', type=MetricType.GAUGE, value=len(tasks)), Metric(name='wca_memory_usage_bytes', type=MetricType.GAUGE, value=int(memory_usage_rss * 1024)), ] return metrics
def sample_metrics_with_quote(): """for testing for proper escaping""" return [ Metric(name='average_latency_miliseconds', value=8, labels={'user': '******', 'node': 'slave_1 called "brave heart"'}, # quoted type=MetricType.COUNTER, help='latency measured in miliseconds'), ]
def get_requested_fraction(app_name, apps_spec, assigned_apps, node_name, nodes_capacities, dimensions) -> Tuple[Resources, List[Metric]]: """ returns requested_fraction, metrics """ # Current node context: used and free currently used, free, requested, capacity, membw_read_write_ratio, metrics = \ used_free_requested(node_name, app_name, dimensions, nodes_capacities, assigned_apps, apps_spec) # SUM requested by app and already used on node try: requested_and_used = sum_resources(requested, used) except ValueError as e: msg = 'cannot sum app=%s requested=%s and node=%s used=%s: %s' % ( app_name, requested, node_name, used, e) log.error(msg) raise DataMissingException(msg) from e # FRACTION requested_fraction = divide_resources(requested_and_used, capacity, membw_read_write_ratio) for resource, fraction in requested_fraction.items(): metrics.append( Metric(name=MetricName.BAR_REQUESTED_FRACTION, value=fraction, labels=dict(app=app_name, resource=resource), type=MetricType.GAUGE)) return requested_fraction, metrics
def _get_internal_metrics(tasks: List[Task]) -> List[Metric]: """Internal wca metrics e.g. memory usage, profiling information.""" # Memory usage. memory_usage_rss_self = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss memory_usage_rss_children = resource.getrusage(resource.RUSAGE_CHILDREN).ru_maxrss memory_usage_rss = memory_usage_rss_self + memory_usage_rss_children metrics = [ Metric.create_metric_with_metadata(MetricName.WCA_UP, value=time.time()), Metric.create_metric_with_metadata(MetricName.WCA_TASKS, value=len(tasks)), Metric.create_metric_with_metadata(MetricName.WCA_MEM_USAGE_BYTES, value=int(memory_usage_rss * 1024)), ] return metrics
def anomaly_metrics(contended_task_id: TaskId, contending_task_ids: List[TaskId], contending_workload_instances: Dict[TaskId, str] = {}, labels: Dict[TaskId, Dict[str, str]] = {}): """Helper method to create metric based on anomaly. uuid is used if provided. """ metrics = [] for task_id in contending_task_ids: uuid = _create_uuid_from_tasks_ids(contending_task_ids + [contended_task_id]) metric = Metric( name='anomaly', value=1, labels=dict( contended_task_id=contended_task_id, contending_task_id=task_id, resource=ContendedResource.MEMORY_BW, uuid=uuid, type='contention', contending_workload_instance=contending_workload_instances[ task_id], workload_instance=contending_workload_instances[ contended_task_id]), type=MetricType.COUNTER) if contended_task_id in labels: metric.labels.update(labels[contended_task_id]) metrics.append(metric) return metrics
def test_log_storage(*mocks): open_mock = Mock() with patch('builtins.open', open_mock): metric = Metric(name='foo', value=8) log_storage = LogStorage(output_filename='mocked_file_name.log') log_storage.store([metric]) assert open_mock.return_value.write.call_count == 2 assert open_mock.return_value.method_calls[0] == call.write('foo 8 1\n')
def test_log_storage_overwrite_mode(logfile_mock, get_current_time_mock, pathlib_rename_mock): metric = Metric(name='foo', value=8) log_storage = LogStorage(output_filename='mocked_file_name.log', overwrite=True) log_storage.store([metric]) logfile_mock.assert_has_calls([call().__enter__().write('foo 8\n')]) pathlib_rename_mock.assert_called_once()
def _get_allocations_statistics_metrics(allocations_count, allocations_errors, allocation_duration): """Extra external plugin allocations statistics.""" metrics = [ Metric(name='allocations_count', type=MetricType.COUNTER, value=allocations_count), Metric(name='allocations_errors', type=MetricType.COUNTER, value=allocations_errors), ] if allocation_duration is not None: metrics.extend([ Metric(name='allocation_duration', type=MetricType.GAUGE, value=allocation_duration) ]) return metrics
def test_parse(): input_ = StringIO("180 images/sec: 74.9 +/- 0.5 (jitter = 8.9) 2.409") expected = [ Metric('tensorflow_benchmark_training_speed', value=74.9, type=MetricType.GAUGE, help="tensorflow benchmark training speed") ] assert expected == parse(input_, None, None, {}, 'tensorflow_benchmark_')
def get_metrics(self, anomalies: List[Anomaly]) -> List[Metric]: """Extra external plugin anomaly statistics.""" self.validate(anomalies) if len(anomalies): self._anomaly_last_occurrence = time.time() self._anomaly_counter += len(anomalies) statistics_metrics = [ Metric(name='anomaly_count', type=MetricType.COUNTER, value=self._anomaly_counter), ] if self._anomaly_last_occurrence: statistics_metrics.extend([ Metric(name='anomaly_last_occurrence', type=MetricType.COUNTER, value=self._anomaly_last_occurrence), ]) return statistics_metrics
def test_parse(): input_ = StringIO("580 248.7 examples/sec") expected = [ Metric('tensorflow_benchmark_prediction_speed', value=248.7, type=MetricType.GAUGE, help="tensorflow benchmark prediction speed") ] assert expected == parse(input_, None, None, {}, 'tensorflow_benchmark_')