class TestGCCollector(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.gc = _MockGC() def test_working(self): collector = GCCollector(registry=self.registry, gc=self.gc) self.gc.start_gc({'generation': 0}) self.gc.stop_gc({'generation': 0, 'collected': 10, 'uncollectable': 2}) self.assertEqual(1, self.registry.get_sample_value( 'python_gc_duration_seconds_count', labels={"generation": "0"})) self.assertEqual(1, self.registry.get_sample_value( 'python_gc_collected_objects_count', labels={"generation": "0"})) self.assertEqual(1, self.registry.get_sample_value( 'python_gc_uncollectable_objects_count', labels={"generation": "0"})) self.assertEqual(10, self.registry.get_sample_value( 'python_gc_collected_objects_sum', labels={"generation": "0"})) self.assertEqual(2, self.registry.get_sample_value( 'python_gc_uncollectable_objects_sum', labels={"generation": "0"}))
def test_failed(gordo_server: Flask, registry: CollectorRegistry): client = gordo_server.test_client() client.get("/failed/project1") sample_value = registry.get_sample_value( "gordo_server_request_duration_seconds_bucket", { "version": "0.60.0", "project": "project1", "model": "", "method": "GET", "path": "/failed/<gordo_project>", "status_code": "500", "le": "0.25", }, ) assert ( sample_value == 1.0 ), "Metric gordo_server_request_duration_seconds_bucket != 1.0" sample_value = registry.get_sample_value( "gordo_server_requests_total", { "version": "0.60.0", "project": "project1", "model": "", "method": "GET", "path": "/failed/<gordo_project>", "status_code": "500", }, ) assert sample_value == 1.0, "Metric gordo_server_requests_total != 1.0"
def test_ursula_info_metrics_collector(test_registry, blockchain_ursulas, agency): ursula = random.choice(blockchain_ursulas) collector = UrsulaInfoMetricsCollector(ursula=ursula) collector_registry = CollectorRegistry() prefix = 'test_ursula_info_metrics_collector' collector.initialize(metrics_prefix=prefix, registry=collector_registry) collector.collect() known_nodes = collector_registry.get_sample_value('test_ursula_info_metrics_collector_known_nodes') assert known_nodes == len(ursula.known_nodes) availability_score = collector_registry.get_sample_value('test_ursula_info_metrics_collector_availability_score') assert availability_score == (ursula._availability_tracker.score if (ursula._availability_tracker and ursula._availability_tracker.running) else -1) policies_held = collector_registry.get_sample_value('test_ursula_info_metrics_collector_policies_held') assert policies_held == 0 work_orders = collector_registry.get_sample_value('test_ursula_info_metrics_collector_work_orders') assert work_orders == 0 mode = 'running' if ursula._learning_task.running else 'stopped' learning_mode = collector_registry.get_sample_value('test_ursula_info_metrics_collector_node_discovery', labels={'test_ursula_info_metrics_collector_node_discovery': f'{mode}'}) assert learning_mode == 1
class TestSummary(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.summary = Summary('s', 'help', registry=self.registry) def test_summary(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) self.assertEqual(0, self.registry.get_sample_value('s_sum')) self.summary.observe(10) self.assertEqual(1, self.registry.get_sample_value('s_count')) self.assertEqual(10, self.registry.get_sample_value('s_sum')) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) @self.summary.time() def f(): pass f() self.assertEqual(1, self.registry.get_sample_value('s_count')) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) with self.summary.time(): pass self.assertEqual(1, self.registry.get_sample_value('s_count'))
def test_staker_metrics_collector(test_registry, stakers): staker = random.choice(stakers) collector = StakerMetricsCollector(domain=staker.network, staker_address=staker.checksum_address, contract_registry=test_registry) collector_registry = CollectorRegistry() prefix = 'test_staker_metrics_collector' collector.initialize(metrics_prefix=prefix, registry=collector_registry) collector.collect() current_period = collector_registry.get_sample_value(f'{prefix}_current_period') assert current_period == staker.staking_agent.get_current_period() # only floats can be stored eth_balance = collector_registry.get_sample_value(f'{prefix}_staker_eth_balance') assert eth_balance == float(staker.eth_balance) nu_balance = collector_registry.get_sample_value(f'{prefix}_staker_token_balance') assert nu_balance == float(int(staker.token_balance)) sub_stakes_count = collector_registry.get_sample_value(f'{prefix}_substakes_count') assert sub_stakes_count == \ staker.staking_agent.contract.functions.getSubStakesLength(staker.checksum_address).call() locked_tokens = collector_registry.get_sample_value(f'{prefix}_active_stake') assert locked_tokens == float(staker.locked_tokens().to_nunits()) owned_tokens = collector_registry.get_sample_value(f'{prefix}_owned_tokens') assert owned_tokens == float(staker.owned_tokens().to_nunits()) unlocked_tokens = collector_registry.get_sample_value(f'{prefix}_unlocked_tokens') assert unlocked_tokens == (owned_tokens - locked_tokens) missing_commitments = collector_registry.get_sample_value(f'{prefix}_missing_commitments') assert missing_commitments == staker.missing_commitments
def test_worker_metrics_collector(test_registry, blockchain_ursulas): ursula = random.choice(blockchain_ursulas) collector = WorkerMetricsCollector(domain=ursula.domain, worker_address=ursula.worker_address, contract_registry=test_registry) collector_registry = CollectorRegistry() prefix = 'test_worker_metrics_collector' collector.initialize(metrics_prefix=prefix, registry=collector_registry) collector.collect() worker_eth = collector_registry.get_sample_value(f'{prefix}_worker_eth_balance') assert worker_eth == float(ursula.eth_balance) worker_nunits = collector_registry.get_sample_value(f'{prefix}_worker_token_balance') assert worker_nunits == float(int(ursula.token_balance))
class TestGCCollector(unittest.TestCase): def setUp(self): gc.disable() gc.collect() self.registry = CollectorRegistry() def test_working(self): GCCollector(registry=self.registry) self.registry.collect() before = self.registry.get_sample_value( 'python_gc_objects_collected_total', labels={"generation": "0"}) # add targets for gc a = [] a.append(a) del a b = [] b.append(b) del b gc.collect(0) self.registry.collect() after = self.registry.get_sample_value( 'python_gc_objects_collected_total', labels={"generation": "0"}) self.assertEqual(2, after - before) self.assertEqual( 0, self.registry.get_sample_value( 'python_gc_objects_uncollectable_total', labels={"generation": "0"})) def test_empty(self): GCCollector(registry=self.registry) self.registry.collect() before = self.registry.get_sample_value( 'python_gc_objects_collected_total', labels={"generation": "0"}) gc.collect(0) self.registry.collect() after = self.registry.get_sample_value( 'python_gc_objects_collected_total', labels={"generation": "0"}) self.assertEqual(0, after - before) def tearDown(self): gc.enable()
def assert_pending_acoustic_sync_inc( metrics_registry: CollectorRegistry, count: int = 1, ): """Assert ctms_pending_acoustic_sync_total was incremented""" assert (metrics_registry.get_sample_value( "ctms_pending_acoustic_sync_total") == count)
def test_blockchain_metrics_collector(testerchain): collector = BlockchainMetricsCollector(provider_uri=TEST_PROVIDER_URI) collector_registry = CollectorRegistry() prefix = 'test_blockchain_metrics_collector' collector.initialize(metrics_prefix=prefix, registry=collector_registry) collector.collect() metric_name = f"{prefix}_current_eth_block_number" assert metric_name in collector_registry._names_to_collectors.keys() block_number = collector_registry.get_sample_value(metric_name) assert block_number == testerchain.get_block_number()
def assert_duration_metric_obs( metrics_registry: CollectorRegistry, method: str, path_template: str, status_code_family: str, limit: float = 0.1, count: int = 1, ): """Assert ctms_requests_duration_seconds with given labels was observed""" base_name = "ctms_requests_duration_seconds" labels = { "method": method, "path_template": path_template, "status_code_family": status_code_family, } bucket_labels = labels.copy() bucket_labels["le"] = str(limit) assert (metrics_registry.get_sample_value(f"{base_name}_bucket", bucket_labels) == count) assert metrics_registry.get_sample_value(f"{base_name}_count", labels) == count assert metrics_registry.get_sample_value(f"{base_name}_sum", labels) < limit
def test_ignore(gordo_server: Flask, registry: CollectorRegistry): client = gordo_server.test_client() client.get("/healthcheck") sample_value = registry.get_sample_value( "gordo_server_requests_total", { "version": "0.60.0", "project": "", "model": "", "method": "GET", "path": "/healthcheck", "status_code": "200", }, ) assert sample_value is None, "Metric gordo_server_requests_total is not None"
def assert_request_metric_inc( metrics_registry: CollectorRegistry, method: str, path_template: str, status_code: int, count: int = 1, ): """Assert ctms_requests_total with given labels was incremented""" labels = { "method": method, "path_template": path_template, "status_code": str(status_code), "status_code_family": str(status_code)[0] + "xx", } assert metrics_registry.get_sample_value("ctms_requests_total", labels) == count
def test_category_registry(self): metrics_registry = CollectorRegistry() redfish.category_registry(self.node_message, metrics_registry) label = { 'entity_id': 'HDD', 'instance_uuid': 'ac2aa2fd-6e1a-41c8-a114-2084c8705228', 'node_name': 'knilab-master-u9', 'node_uuid': 'ac2aa2fd-6e1a-41c8-a114-2084c8705228', 'sensor_id': '32ADF365C6C1B7BD:XXX-YYY-ZZZ@ZZZ-YYY-XXX' } sensor_value = metrics_registry.get_sample_value( 'baremetal_drive_status', label) self.assertEqual(0, sensor_value)
class TestCounter(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c', 'help', registry=self.registry) def test_increment(self): self.assertEqual(0, self.registry.get_sample_value('c')) self.counter.inc() self.assertEqual(1, self.registry.get_sample_value('c')) self.counter.inc(7) self.assertEqual(8, self.registry.get_sample_value('c')) def test_negative_increment_raises(self): self.assertRaises(ValueError, self.counter.inc, -1) def test_function_decorator(self): @self.counter.count_exceptions(ValueError) def f(r): if r: raise ValueError else: raise TypeError try: f(False) except TypeError: pass self.assertEqual(0, self.registry.get_sample_value('c')) try: f(True) except ValueError: raised = True self.assertEqual(1, self.registry.get_sample_value('c')) def test_block_decorator(self): with self.counter.count_exceptions(): pass self.assertEqual(0, self.registry.get_sample_value('c')) raised = False try: with self.counter.count_exceptions(): raise ValueError except: raised = True self.assertTrue(raised) self.assertEqual(1, self.registry.get_sample_value('c'))
class TestProcessCollector(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.test_proc = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'proc') def test_working(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 26231, registry=self.registry) collector._ticks = 100 self.assertEqual(17.21, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual(56274944.0, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual(8114176, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual(1418184099.75, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(2048.0, self.registry.get_sample_value('process_max_fds')) self.assertEqual(5.0, self.registry.get_sample_value('process_open_fds')) self.assertEqual(None, self.registry.get_sample_value('process_fake_namespace')) def test_namespace(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 26231, registry=self.registry, namespace='n') collector._ticks = 100 self.assertEqual(17.21, self.registry.get_sample_value('n_process_cpu_seconds_total')) self.assertEqual(56274944.0, self.registry.get_sample_value('n_process_virtual_memory_bytes')) self.assertEqual(8114176, self.registry.get_sample_value('n_process_resident_memory_bytes')) self.assertEqual(1418184099.75, self.registry.get_sample_value('n_process_start_time_seconds')) self.assertEqual(2048.0, self.registry.get_sample_value('n_process_max_fds')) self.assertEqual(5.0, self.registry.get_sample_value('n_process_open_fds')) self.assertEqual(None, self.registry.get_sample_value('process_cpu_seconds_total')) def test_working_584(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: "584\n", registry=self.registry) collector._ticks = 100 self.assertEqual(0.0, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual(10395648.0, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual(634880, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual(1418291667.75, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(None, self.registry.get_sample_value('process_max_fds')) self.assertEqual(None, self.registry.get_sample_value('process_open_fds')) def test_working_fake_pid(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 123, registry=self.registry) collector._ticks = 100 self.assertEqual(None, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual(None, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual(None, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual(None, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(None, self.registry.get_sample_value('process_max_fds')) self.assertEqual(None, self.registry.get_sample_value('process_open_fds')) self.assertEqual(None, self.registry.get_sample_value('process_fake_namespace'))
class TestPrometheusWatcher(unittest.TestCase): def setUp(self) -> None: # Create a custom registry, to avoid polluting the global one self.registry = CollectorRegistry() # Custom metric cache, to avoid polluting the global one prom_metrics: Dict[str, Any] = {} def prom_factory(sensor: aiokatcp.Sensor) -> Optional[PrometheusInfo]: if sensor.name == 'int-sensor': return PrometheusInfo(Counter, 'test_int_sensor', 'A counter', {}, self.registry) elif sensor.name == 'float-sensor': return PrometheusInfo(Gauge, 'test_float_sensor', 'A gauge', {}, self.registry) elif sensor.name == 'bool-sensor': return PrometheusInfo(Gauge, 'test_bool_sensor', 'A boolean gauge with labels', {'label2': 'labelvalue2'}, self.registry) elif sensor.name == 'histogram-sensor': return PrometheusInfo( functools.partial(Histogram, buckets=(1, 10)), 'test_histogram_sensor', 'A histogram', {}, self.registry) elif sensor.name == 'enum-sensor': return PrometheusInfo(Gauge, 'test_enum_sensor', 'An enum gauge', {}, self.registry) elif sensor.name == 'dynamic-sensor': return PrometheusInfo(Gauge, 'test_dynamic_sensor', 'Dynamic sensor', {}, self.registry) else: return None self.sensors = SensorSet() _add_sensors(self.sensors) self.watcher = PrometheusWatcher(self.sensors, {'label1': 'labelvalue1'}, prom_factory, prom_metrics) def _check_prom(self, name: str, value: Optional[float], status: Optional[Sensor.Status] = Sensor.Status.NOMINAL, suffix: str = '', extra_labels: Mapping[str, str] = None, extra_value_labels: Mapping[str, str] = None): labels = {'label1': 'labelvalue1'} if extra_labels is not None: labels.update(extra_labels) value_labels = dict(labels) if extra_value_labels is not None: value_labels.update(extra_value_labels) actual_value = self.registry.get_sample_value(name + suffix, value_labels) actual_status = self.registry.get_sample_value(name + '_status', labels) self.assertEqual(value, actual_value) self.assertEqual(status.value if status is not None else None, actual_status) def test_gauge(self) -> None: self._check_prom('test_float_sensor', 3.0) self.sensors['float-sensor'].value = 2.5 self._check_prom('test_float_sensor', 2.5) # Change to a status where the value is not valid. The Prometheus # Gauge must not change. self.sensors['float-sensor'].set_value(1.0, status=Sensor.Status.FAILURE) self._check_prom('test_float_sensor', 2.5, Sensor.Status.FAILURE) def test_enum_gauge(self) -> None: self.sensors['enum-sensor'].value = MyEnum.NO self._check_prom('test_enum_sensor', 1.0) def test_histogram(self) -> None: # Record some values, check the counts sensor = self.sensors['histogram-sensor'] sensor.value = 4.0 sensor.value = 5.0 sensor.value = 0.5 sensor.set_value(100.0, timestamp=12345) self._check_prom('test_histogram_sensor', 1, suffix='_bucket', extra_value_labels={'le': '1.0'}) self._check_prom('test_histogram_sensor', 3, suffix='_bucket', extra_value_labels={'le': '10.0'}) self._check_prom('test_histogram_sensor', 4, suffix='_bucket', extra_value_labels={'le': '+Inf'}) # Set same value and timestamp (spurious update) sensor.set_value(100.0, timestamp=12345) self._check_prom('test_histogram_sensor', 4, suffix='_bucket', extra_value_labels={'le': '+Inf'}) # Set invalid value sensor.set_value(6.0, status=Sensor.Status.FAILURE) self._check_prom('test_histogram_sensor', 4, Sensor.Status.FAILURE, suffix='_bucket', extra_value_labels={'le': '+Inf'}) def test_counter(self) -> None: sensor = self.sensors['int-sensor'] sensor.value = 4 self._check_prom('test_int_sensor', 4) # Increase the value sensor.value = 10 self._check_prom('test_int_sensor', 10) # Reset then increase the value. The counter must record the cumulative total sensor.value = 0 sensor.set_value(6, status=Sensor.Status.ERROR) self._check_prom('test_int_sensor', 16, Sensor.Status.ERROR) # Set to an invalid status. The counter value must not be affected. sensor.set_value(9, status=Sensor.Status.FAILURE) self._check_prom('test_int_sensor', 16, Sensor.Status.FAILURE) # Set back to a valid status sensor.value = 8 self._check_prom('test_int_sensor', 18) def test_add_sensor(self) -> None: # A non-Prometheus sensor, just to check that this doesn't break anything self.sensors.add(Sensor(int, 'another', 'another sensor', '')) self.sensors.add(Sensor(float, 'dynamic-sensor', 'dynamic sensor', '')) self.sensors['dynamic-sensor'].value = 345.0 self._check_prom('test_dynamic_sensor', 345.0) def test_remove_sensor(self) -> None: del self.sensors['int-sensor'] self._check_prom('test_int_sensor', None, status=None) def test_extra_labels(self) -> None: self.sensors['bool-sensor'].value = True self._check_prom('test_bool_sensor', 1, extra_labels={'label2': 'labelvalue2'}) def test_close(self) -> None: self.watcher.close() self._check_prom('test_int_sensor', None, status=None)
class TestHistogram(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.histogram = Histogram('h', 'help', registry=self.registry) self.labels = Histogram('hl', 'help', ['l'], registry=self.registry) def test_histogram(self): self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_sum')) self.histogram.observe(2) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual(2, self.registry.get_sample_value('h_sum')) self.histogram.observe(2.5) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(2, self.registry.get_sample_value('h_count')) self.assertEqual(4.5, self.registry.get_sample_value('h_sum')) self.histogram.observe(float("inf")) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 3, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(3, self.registry.get_sample_value('h_count')) self.assertEqual(float("inf"), self.registry.get_sample_value('h_sum')) def test_setting_buckets(self): h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2, float("inf")]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[float("inf")]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[3, 1]) def test_labels(self): self.labels.labels('a').observe(2) self.assertEqual( 0, self.registry.get_sample_value('hl_bucket', { 'le': '1.0', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '2.5', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '5.0', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '+Inf', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_count', {'l': 'a'})) self.assertEqual(2, self.registry.get_sample_value('hl_sum', {'l': 'a'})) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) @self.histogram.time() def f(): pass f() self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) with self.histogram.time(): pass self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'}))
class TestGauge(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.gauge = Gauge('g', 'help', registry=self.registry) def test_gauge(self): self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(1, self.registry.get_sample_value('g')) self.gauge.dec(3) self.assertEqual(-2, self.registry.get_sample_value('g')) self.gauge.set(9) self.assertEqual(9, self.registry.get_sample_value('g')) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.track_inprogress() def f(): self.assertEqual(1, self.registry.get_sample_value('g')) f() self.assertEqual(0, self.registry.get_sample_value('g')) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.track_inprogress(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(0, self.registry.get_sample_value('g')) def test_gauge_function(self): x = {} self.gauge.set_function(lambda: len(x)) self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(0, self.registry.get_sample_value('g')) x['a'] = None self.assertEqual(1, self.registry.get_sample_value('g'))
class TestMetricWrapper(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c', 'help', labelnames=['l'], registry=self.registry) self.two_labels = Counter('two', 'help', labelnames=['a', 'b'], registry=self.registry) def test_child(self): self.counter.labels('x').inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.two_labels.labels('x', 'y').inc(2) self.assertEqual(2, self.registry.get_sample_value('two', {'a': 'x', 'b': 'y'})) def test_remove(self): self.counter.labels('x').inc() self.counter.labels('y').inc(2) self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) self.counter.remove('x') self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) def test_incorrect_label_count_raises(self): self.assertRaises(ValueError, self.counter.labels) self.assertRaises(ValueError, self.counter.labels, 'a', 'b') self.assertRaises(ValueError, self.counter.remove) self.assertRaises(ValueError, self.counter.remove, 'a', 'b') def test_labels_coerced_to_string(self): self.counter.labels(None).inc() self.counter.labels({'l': None}).inc() self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'None'})) self.counter.remove(None) self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'None'})) def test_non_string_labels_raises(self): class Test(object): __str__ = None self.assertRaises(TypeError, self.counter.labels, Test()) self.assertRaises(TypeError, self.counter.labels, {'l': Test()}) def test_namespace_subsystem_concatenated(self): c = Counter('c', 'help', namespace='a', subsystem='b', registry=self.registry) c.inc() self.assertEqual(1, self.registry.get_sample_value('a_b_c')) def test_labels_by_dict(self): self.counter.labels({'l': 'x'}).inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertRaises(ValueError, self.counter.labels, {'l': 'x', 'm': 'y'}) self.assertRaises(ValueError, self.counter.labels, {'m': 'y'}) self.assertRaises(ValueError, self.counter.labels, {}) self.two_labels.labels({'a': 'x', 'b': 'y'}).inc() self.assertEqual(1, self.registry.get_sample_value('two', {'a': 'x', 'b': 'y'})) self.assertRaises(ValueError, self.two_labels.labels, {'a': 'x', 'b': 'y', 'c': 'z'}) self.assertRaises(ValueError, self.two_labels.labels, {'a': 'x', 'c': 'z'}) self.assertRaises(ValueError, self.two_labels.labels, {'b': 'y', 'c': 'z'}) self.assertRaises(ValueError, self.two_labels.labels, {'c': 'z'}) self.assertRaises(ValueError, self.two_labels.labels, {}) def test_invalid_names_raise(self): self.assertRaises(ValueError, Counter, '', 'help') self.assertRaises(ValueError, Counter, '^', 'help') self.assertRaises(ValueError, Counter, '', 'help', namespace='&') self.assertRaises(ValueError, Counter, '', 'help', subsystem='(') self.assertRaises(ValueError, Counter, 'c', '', labelnames=['^']) self.assertRaises(ValueError, Counter, 'c', '', labelnames=['__reserved']) self.assertRaises(ValueError, Summary, 'c', '', labelnames=['quantile'])
class TestProcessCollector(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.test_proc = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'proc') def test_working(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 26231, registry=self.registry) collector._ticks = 100 self.assertEqual( 17.21, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual( 56274944.0, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual( 8114176, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual( 1418184099.75, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(2048.0, self.registry.get_sample_value('process_max_fds')) self.assertEqual(5.0, self.registry.get_sample_value('process_open_fds')) self.assertEqual( None, self.registry.get_sample_value('process_fake_namespace')) def test_namespace(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 26231, registry=self.registry, namespace='n') collector._ticks = 100 self.assertEqual( 17.21, self.registry.get_sample_value('n_process_cpu_seconds_total')) self.assertEqual( 56274944.0, self.registry.get_sample_value('n_process_virtual_memory_bytes')) self.assertEqual( 8114176, self.registry.get_sample_value('n_process_resident_memory_bytes')) self.assertEqual( 1418184099.75, self.registry.get_sample_value('n_process_start_time_seconds')) self.assertEqual(2048.0, self.registry.get_sample_value('n_process_max_fds')) self.assertEqual(5.0, self.registry.get_sample_value('n_process_open_fds')) self.assertEqual( None, self.registry.get_sample_value('process_cpu_seconds_total')) def test_working_584(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: "584\n", registry=self.registry) collector._ticks = 100 self.assertEqual( 0.0, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual( 10395648.0, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual( 634880, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual( 1418291667.75, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(None, self.registry.get_sample_value('process_max_fds')) self.assertEqual(None, self.registry.get_sample_value('process_open_fds')) def test_working_fake_pid(self): collector = ProcessCollector(proc=self.test_proc, pid=lambda: 123, registry=self.registry) collector._ticks = 100 self.assertEqual( None, self.registry.get_sample_value('process_cpu_seconds_total')) self.assertEqual( None, self.registry.get_sample_value('process_virtual_memory_bytes')) self.assertEqual( None, self.registry.get_sample_value('process_resident_memory_bytes')) self.assertEqual( None, self.registry.get_sample_value('process_start_time_seconds')) self.assertEqual(None, self.registry.get_sample_value('process_max_fds')) self.assertEqual(None, self.registry.get_sample_value('process_open_fds')) self.assertEqual( None, self.registry.get_sample_value('process_fake_namespace'))
class TestPayloadsParser(unittest.TestCase): def setUp(self): self.node_name = DATA['payload']['node_name'] self.payload = DATA['payload']['payload'] self.metric_registry = CollectorRegistry() def test_management_parser(self): prefix = ipmi.CATEGORY_PARAMS['management']['prefix'] sufix = ipmi.CATEGORY_PARAMS['management']['sufix'] extra = ipmi.CATEGORY_PARAMS['management']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['management']['use_ipmi_format'] management_metrics_name = ipmi.metric_names(self.payload['Management'], prefix, sufix, **extra) self.assertEqual(len(management_metrics_name), 1) self.assertIn('baremetal_front_led_panel', management_metrics_name) ipmi.prometheus_format(self.payload['Management'], self.node_name, self.metric_registry, management_metrics_name, ipmi_format) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_front_led_panel', { 'node_name': 'knilab-master-u9', 'entity_id': '7.1 (System Board)' })) def test_temperature_parser(self): prefix = ipmi.CATEGORY_PARAMS['temperature']['prefix'] sufix = ipmi.CATEGORY_PARAMS['temperature']['sufix'] extra = ipmi.CATEGORY_PARAMS['temperature']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['temperature']['use_ipmi_format'] temperature_metrics_name = ipmi.metric_names( self.payload['Temperature'], prefix, sufix, **extra) self.assertEqual(len(temperature_metrics_name), 3) self.assertIn('baremetal_temp_celsius', temperature_metrics_name) self.assertIn('baremetal_exhaust_temp_celsius', temperature_metrics_name) self.assertIn('baremetal_inlet_temp_celsius', temperature_metrics_name) ipmi.prometheus_format(self.payload['Temperature'], self.node_name, self.metric_registry, temperature_metrics_name, ipmi_format) self.assertEqual( 21.0, self.metric_registry.get_sample_value( 'baremetal_inlet_temp_celsius', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) self.assertEqual( 36.0, self.metric_registry.get_sample_value( 'baremetal_exhaust_temp_celsius', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) self.assertEqual( 44.0, self.metric_registry.get_sample_value( 'baremetal_temp_celsius', { 'node_name': self.node_name, 'sensor_id': 'Temp (0x1)', 'entity_id': '3.1 (Processor)' })) self.assertEqual( 43.0, self.metric_registry.get_sample_value( 'baremetal_temp_celsius', { 'node_name': self.node_name, 'sensor_id': 'Temp (0x2)', 'entity_id': '3.2 (Processor)' })) def test_system_parser(self): prefix = ipmi.CATEGORY_PARAMS['system']['prefix'] sufix = ipmi.CATEGORY_PARAMS['system']['sufix'] extra = ipmi.CATEGORY_PARAMS['system']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['system']['use_ipmi_format'] system_metrics_name = ipmi.metric_names(self.payload['System'], prefix, sufix, **extra) self.assertEqual(len(system_metrics_name), 2) self.assertIn('baremetal_system_unknown', system_metrics_name) self.assertIn('baremetal_system_post_err', system_metrics_name) ipmi.prometheus_format(self.payload['System'], self.node_name, self.metric_registry, system_metrics_name, ipmi_format) self.assertEqual( 0.0, self.metric_registry.get_sample_value('baremetal_system_unknown', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( None, self.metric_registry.get_sample_value( 'baremetal_system_post_err', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) def test_current_parser(self): prefix = ipmi.CATEGORY_PARAMS['current']['prefix'] sufix = ipmi.CATEGORY_PARAMS['current']['sufix'] extra = ipmi.CATEGORY_PARAMS['current']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['current']['use_ipmi_format'] current_metrics_name = ipmi.metric_names(self.payload['Current'], prefix, sufix, **extra) self.assertEqual(len(current_metrics_name), 2) self.assertIn('baremetal_current', current_metrics_name) self.assertIn('baremetal_pwr_consumption', current_metrics_name) ipmi.prometheus_format(self.payload['Current'], self.node_name, self.metric_registry, current_metrics_name, ipmi_format) self.assertEqual( 264.0, self.metric_registry.get_sample_value( 'baremetal_pwr_consumption', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) self.assertEqual( 0.600, self.metric_registry.get_sample_value( 'baremetal_current', { 'node_name': self.node_name, 'entity_id': '10.1 (Power Supply)', 'sensor_id': 'Current 1 (0x6b)' })) self.assertEqual( 0.600, self.metric_registry.get_sample_value( 'baremetal_current', { 'node_name': self.node_name, 'entity_id': '10.2 (Power Supply)', 'sensor_id': 'Current 2 (0x6c)' })) def test_version_parser(self): prefix = ipmi.CATEGORY_PARAMS['version']['prefix'] sufix = ipmi.CATEGORY_PARAMS['version']['sufix'] extra = ipmi.CATEGORY_PARAMS['version']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['version']['use_ipmi_format'] version_metrics_name = ipmi.metric_names(self.payload['Version'], prefix, sufix, **extra) self.assertEqual(len(version_metrics_name), 3) self.assertIn('baremetal_tpm_presence', version_metrics_name) self.assertIn('baremetal_hdwr_version_err', version_metrics_name) self.assertIn('baremetal_chassis_mismatch', version_metrics_name) ipmi.prometheus_format(self.payload['Version'], self.node_name, self.metric_registry, version_metrics_name, ipmi_format) self.assertEqual( 1.0, self.metric_registry.get_sample_value('baremetal_tpm_presence', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( None, self.metric_registry.get_sample_value( 'baremetal_hdwr_version_err', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_chassis_mismatch', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) def test_memory_parser(self): prefix = ipmi.CATEGORY_PARAMS['memory']['prefix'] sufix = ipmi.CATEGORY_PARAMS['memory']['sufix'] extra = ipmi.CATEGORY_PARAMS['memory']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['memory']['use_ipmi_format'] memory_metrics_name = ipmi.metric_names(self.payload['Memory'], prefix, sufix, **extra) self.assertEqual(len(memory_metrics_name), 10) self.assertIn('baremetal_memory_ecc_corr_err', memory_metrics_name) self.assertIn('baremetal_idpt_mem_fail', memory_metrics_name) self.assertIn('baremetal_memory_ecc_uncorr_err', memory_metrics_name) self.assertIn('baremetal_memory_mirrored', memory_metrics_name) self.assertIn('baremetal_mem_ecc_warning', memory_metrics_name) self.assertIn('baremetal_memory_b', memory_metrics_name) self.assertIn('baremetal_memory_a', memory_metrics_name) self.assertIn('baremetal_memory_usb_over_current', memory_metrics_name) self.assertIn('baremetal_memory_post_pkg_repair', memory_metrics_name) self.assertIn('baremetal_memory_spared', memory_metrics_name) ipmi.prometheus_format(self.payload['Memory'], self.node_name, self.metric_registry, memory_metrics_name, ipmi_format) self.assertEqual( None, self.metric_registry.get_sample_value( 'baremetal_mem_ecc_warning', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 1.0, self.metric_registry.get_sample_value( 'baremetal_memory_post_pkg_repair', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value('baremetal_idpt_mem_fail', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value('baremetal_memory_spared', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_memory_mirrored', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( None, self.metric_registry.get_sample_value( 'baremetal_memory_usb_over_current', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 1.0, self.metric_registry.get_sample_value( 'baremetal_memory_ecc_uncorr_err', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_memory_b', { 'node_name': self.node_name, 'entity_id': '32.1 (Memory Device)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_memory_a', { 'node_name': self.node_name, 'entity_id': '32.1 (Memory Device)' })) self.assertEqual( 1.0, self.metric_registry.get_sample_value( 'baremetal_memory_ecc_corr_err', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) def test_power_parser(self): prefix = ipmi.CATEGORY_PARAMS['power']['prefix'] sufix = ipmi.CATEGORY_PARAMS['power']['sufix'] extra = ipmi.CATEGORY_PARAMS['power']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['power']['use_ipmi_format'] power_metrics_name = ipmi.metric_names(self.payload['Power'], prefix, sufix, **extra) self.assertEqual(len(power_metrics_name), 2) self.assertIn('baremetal_power_ps_redundancy', power_metrics_name) self.assertIn('baremetal_power_status', power_metrics_name) ipmi.prometheus_format(self.payload['Power'], self.node_name, self.metric_registry, power_metrics_name, ipmi_format) self.assertEqual( None, self.metric_registry.get_sample_value( 'baremetal_power_ps_redundancy', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_power_status', { 'node_name': self.node_name, 'sensor_id': 'Status (0x86)', 'entity_id': '10.2 (Power Supply)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_power_status', { 'node_name': self.node_name, 'sensor_id': 'Status (0x85)', 'entity_id': '10.1 (Power Supply)' })) def test_watchdog2_parser(self): print('WATCHDOG2') prefix = ipmi.CATEGORY_PARAMS['watchdog2']['prefix'] sufix = ipmi.CATEGORY_PARAMS['watchdog2']['sufix'] extra = ipmi.CATEGORY_PARAMS['watchdog2']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['watchdog2']['use_ipmi_format'] watchdog2_metrics_name = ipmi.metric_names(self.payload['Watchdog2'], prefix, sufix, **extra) self.assertEqual(len(watchdog2_metrics_name), 2) self.assertIn('baremetal_os_watchdog_time', watchdog2_metrics_name) self.assertIn('baremetal_os_watchdog', watchdog2_metrics_name) ipmi.prometheus_format(self.payload['Watchdog2'], self.node_name, self.metric_registry, watchdog2_metrics_name, ipmi_format) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_os_watchdog_time', { 'node_name': self.node_name, 'entity_id': '34.1 (BIOS)' })) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_os_watchdog', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) def test_fan_parser(self): prefix = ipmi.CATEGORY_PARAMS['fan']['prefix'] sufix = ipmi.CATEGORY_PARAMS['fan']['sufix'] extra = ipmi.CATEGORY_PARAMS['fan']['extra_params'] ipmi_format = ipmi.CATEGORY_PARAMS['fan']['use_ipmi_format'] fan_metrics_name = ipmi.metric_names(self.payload['Fan'], prefix, sufix, **extra) self.assertEqual(len(fan_metrics_name), 2) self.assertIn('baremetal_fan_redundancy_rpm', fan_metrics_name) self.assertIn('baremetal_fan_rpm', fan_metrics_name) ipmi.prometheus_format(self.payload['Fan'], self.node_name, self.metric_registry, fan_metrics_name, ipmi_format) self.assertEqual( 0.0, self.metric_registry.get_sample_value( 'baremetal_fan_redundancy_rpm', { 'node_name': self.node_name, 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9960.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan4A (0x3b)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan1B (0x40)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan8B (0x47)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9360.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan3A (0x3a)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9360.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan2A (0x39)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan6B (0x45)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9720.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan5A (0x3c)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan3B (0x42)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9360.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan7A (0x3e)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan7B (0x46)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5880.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan4B (0x43)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9360.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan1A (0x38)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9360.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan6A (0x3d)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5520.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan2B (0x41)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 5640.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan5B (0x44)', 'entity_id': '7.1 (System Board)' })) self.assertEqual( 9240.0, self.metric_registry.get_sample_value( 'baremetal_fan_rpm', { 'node_name': self.node_name, 'sensor_id': 'Fan8A (0x3f)', 'entity_id': '7.1 (System Board)' }))
class TestMetricWrapper(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c', 'help', labelnames=['l'], registry=self.registry) self.two_labels = Counter('two', 'help', labelnames=['a', 'b'], registry=self.registry) def test_child(self): self.counter.labels('x').inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.two_labels.labels('x', 'y').inc(2) self.assertEqual( 2, self.registry.get_sample_value('two', { 'a': 'x', 'b': 'y' })) def test_remove(self): self.counter.labels('x').inc() self.counter.labels('y').inc(2) self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) self.counter.remove('x') self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) def test_incorrect_label_count_raises(self): self.assertRaises(ValueError, self.counter.labels) self.assertRaises(ValueError, self.counter.labels, 'a', 'b') self.assertRaises(ValueError, self.counter.remove) self.assertRaises(ValueError, self.counter.remove, 'a', 'b') def test_labels_coerced_to_string(self): self.counter.labels(None).inc() self.counter.labels({'l': None}).inc() self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'None'})) self.counter.remove(None) self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'None'})) def test_non_string_labels_raises(self): class Test(object): __str__ = None self.assertRaises(TypeError, self.counter.labels, Test()) self.assertRaises(TypeError, self.counter.labels, {'l': Test()}) def test_namespace_subsystem_concatenated(self): c = Counter('c', 'help', namespace='a', subsystem='b', registry=self.registry) c.inc() self.assertEqual(1, self.registry.get_sample_value('a_b_c')) def test_labels_by_dict(self): self.counter.labels({'l': 'x'}).inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertRaises(ValueError, self.counter.labels, { 'l': 'x', 'm': 'y' }) self.assertRaises(ValueError, self.counter.labels, {'m': 'y'}) self.assertRaises(ValueError, self.counter.labels, {}) self.two_labels.labels({'a': 'x', 'b': 'y'}).inc() self.assertEqual( 1, self.registry.get_sample_value('two', { 'a': 'x', 'b': 'y' })) self.assertRaises(ValueError, self.two_labels.labels, { 'a': 'x', 'b': 'y', 'c': 'z' }) self.assertRaises(ValueError, self.two_labels.labels, { 'a': 'x', 'c': 'z' }) self.assertRaises(ValueError, self.two_labels.labels, { 'b': 'y', 'c': 'z' }) self.assertRaises(ValueError, self.two_labels.labels, {'c': 'z'}) self.assertRaises(ValueError, self.two_labels.labels, {}) def test_invalid_names_raise(self): self.assertRaises(ValueError, Counter, '', 'help') self.assertRaises(ValueError, Counter, '^', 'help') self.assertRaises(ValueError, Counter, '', 'help', namespace='&') self.assertRaises(ValueError, Counter, '', 'help', subsystem='(') self.assertRaises(ValueError, Counter, 'c', '', labelnames=['^']) self.assertRaises(ValueError, Counter, 'c', '', labelnames=['__reserved']) self.assertRaises(ValueError, Summary, 'c', '', labelnames=['quantile'])
def test_staking_events_metric_collectors(testerchain, blockchain_ursulas): ursula = random.choice(blockchain_ursulas) collector_registry = CollectorRegistry() prefix = 'test_staking_events_metric_collectors' event_collectors = create_staking_events_metric_collectors( ursula=ursula, metrics_prefix=prefix) initialize_collectors(metrics_collectors=event_collectors, testerchain=testerchain, collector_registry=collector_registry, prefix=prefix) # Since collectors only initialized, check base state i.e. current values # Restake restake_set = collector_registry.get_sample_value(f'{prefix}_restaking') assert restake_set == ursula.application_agent.is_restaking( ursula.checksum_address) # WindDown windown_set = collector_registry.get_sample_value(f'{prefix}_wind_down') assert windown_set == ursula.application_agent.is_winding_down( ursula.checksum_address) # Operator current_worker_is_me = collector_registry.get_sample_value( f'{prefix}_current_worker_is_me') assert current_worker_is_me == \ (ursula.application_agent.get_worker_from_staker(ursula.checksum_address) == ursula.operator_address) staker_power = TransactingPower(account=ursula.checksum_address, signer=Web3Signer(testerchain.client)) # # Update some values # # Change Restake ursula.application_agent.set_restaking(staker_power, not bool(restake_set)) # Change WindingDown ursula.application_agent.set_winding_down(staker_power, not bool(windown_set)) # Subsequent commit to next period testerchain.time_travel(periods=1) worker_power = TransactingPower(account=ursula.operator_address, signer=Web3Signer(testerchain.client)) ursula.application_agent.commit_to_next_period( transacting_power=worker_power) period_committed_to = ursula.application_agent.get_current_period() + 1 # Mint testerchain.time_travel(periods=2) _receipt = ursula.application_agent.mint(transacting_power=staker_power) minted_block_number = testerchain.get_block_number() minted_period = ursula.application_agent.get_current_period( ) - 1 # mint is for the previous period testerchain.time_travel(periods=1) # Force update of metrics collection for collector in event_collectors: collector.collect() # # Check updated values # updated_restake_set = collector_registry.get_sample_value( f'{prefix}_restaking') assert updated_restake_set == ursula.application_agent.is_restaking( ursula.checksum_address) assert updated_restake_set != restake_set updated_windown_set = collector_registry.get_sample_value( f'{prefix}_wind_down') assert updated_windown_set == ursula.application_agent.is_winding_down( ursula.checksum_address) assert updated_windown_set != windown_set committed_event_period = collector_registry.get_sample_value( f'{prefix}_activity_confirmed_period') assert committed_event_period == period_committed_to minted_event_period = collector_registry.get_sample_value( f'{prefix}_mined_period') minted_event_block_number = collector_registry.get_sample_value( f'{prefix}_mined_block_number') assert minted_event_period == minted_period assert minted_event_block_number == minted_block_number
class TestHistogram(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.histogram = Histogram('h', 'help', registry=self.registry) self.labels = Histogram('hl', 'help', ['l'], registry=self.registry) def test_histogram(self): self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_sum')) self.histogram.observe(2) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual(1, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual(1, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual(1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual(2, self.registry.get_sample_value('h_sum')) self.histogram.observe(2.5) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual(2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual(2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual(2, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(2, self.registry.get_sample_value('h_count')) self.assertEqual(4.5, self.registry.get_sample_value('h_sum')) self.histogram.observe(float("inf")) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual(2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual(2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual(3, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(3, self.registry.get_sample_value('h_count')) self.assertEqual(float("inf"), self.registry.get_sample_value('h_sum')) def test_setting_buckets(self): h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2, float("inf")]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[float("inf")]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[3, 1]) def test_labels(self): self.labels.labels('a').observe(2) self.assertEqual(0, self.registry.get_sample_value('hl_bucket', {'le': '1.0', 'l': 'a'})) self.assertEqual(1, self.registry.get_sample_value('hl_bucket', {'le': '2.5', 'l': 'a'})) self.assertEqual(1, self.registry.get_sample_value('hl_bucket', {'le': '5.0', 'l': 'a'})) self.assertEqual(1, self.registry.get_sample_value('hl_bucket', {'le': '+Inf', 'l': 'a'})) self.assertEqual(1, self.registry.get_sample_value('hl_count', {'l': 'a'})) self.assertEqual(2, self.registry.get_sample_value('hl_sum', {'l': 'a'})) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) @self.histogram.time() def f(): pass f() self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual(1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) with self.histogram.time(): pass self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual(1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'}))