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
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_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 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 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'])
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'}))
