openstack
/
ironic-prometheus-exporter
Code Issues Proposed changes

Move to client_python from Prometheus 

- update oslo.notifier and ipmi parser to use the prometheus client_python
- update tests to use prometheus client_python
- removal of the manager since doesn't seems to be necessary
- update flask application to run under uWSGI using command line
- update requirements to use the prometheus client_python and uwsgi
- update README with information about how to run under uWSGI
This commit is contained in:
Iury Gregory Melo Ferreira 2019-04-30 17:53:54 +02:00
parent 39e02f2687
commit 8bb8c739fc
8 changed files with 320 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
README.md
View File

@ -62,3 +62,10 @@ $ export FLASK_RUN_PORT=5000
```
$ python -m flask run &
```
**Running under uWSGI**
Reproduce the Steps 1 and 2 (You don't need to set `FLASK_APP` variable) and run the command below:
```
$ uwsgi --socket $FLASK_RUN_HOST:$FLASK_RUN_PORT --protocol=http -w ironic_prometheus_exporter.app.wsgi
```

6
ironic_prometheus_exporter/app/exporter.py
View File

@ -3,11 +3,11 @@ import logging
import os
from flask import abort, Flask, Response
app = Flask(__name__)
application = Flask(__name__)
LOG = logging.getLogger(__name__)
@app.route('/metrics', methods=['GET'])
@application.route('/metrics', methods=['GET'])
def prometheus_metrics():
try:
config = configparser.ConfigParser()
@ -28,4 +28,4 @@ def prometheus_metrics():
if __name__ == '__main__':
app.run()
application.run()

4
ironic_prometheus_exporter/app/wsgi.py Normal file
View File

@ -0,0 +1,4 @@
from ironic_prometheus_exporter.app.exporter import application
if __name__ == '__main__':
application.run()

24
ironic_prometheus_exporter/messaging.py
View File

@ -1,9 +1,10 @@
import logging
import os
from ironic_prometheus_exporter.parsers import manager
from ironic_prometheus_exporter.parsers import ipmi
from oslo_config import cfg
from oslo_messaging.notify import notifier
from prometheus_client import write_to_textfile, CollectorRegistry
LOG = logging.getLogger(__name__)
@ -23,23 +24,22 @@ class PrometheusFileDriver(notifier.Driver):
def __init__(self, conf, topics, transport):
self.location = conf.oslo_messaging_notifications.location
self.temporary_location = '/tmp/temporary_data'
if not os.path.exists(self.location):
os.makedirs(self.location)
if not os.path.exists(self.temporary_location):
os.makedirs(self.temporary_location)
super(PrometheusFileDriver, self).__init__(conf, topics, transport)
def notify(self, ctxt, message, priority, retry):
try:
node_parser_manager = manager.ParserManager(message)
node_metrics = node_parser_manager.merge_information()
node_name = message['payload']['node_name']
tmpFile = os.path.join(self.temporary_location, node_name)
nodeFile = os.path.join(self.location, node_name)
with open(tmpFile, 'w') as file:
file.write(node_metrics)
os.rename(tmpFile, nodeFile)
if message['event_type'] == 'hardware.ipmi.metrics':
registry = CollectorRegistry()
node_name = message['payload']['node_name']
node_payload = message['payload']['payload']
for category in node_payload:
ipmi.category_registry(category.lower(),
node_payload[category], node_name,
registry)
nodeFile = os.path.join(self.location, node_name)
write_to_textfile(nodeFile, registry)
except Exception as e:
LOG.error(e)

47
ironic_prometheus_exporter/parsers/ipmi.py
View File

@ -1,6 +1,8 @@
import logging
import re
from prometheus_client import Gauge
# NOTE (iurygregory): most of the sensor readings come in the ipmi format
# each type of sensor consider a different range of values that aren't integers
# (eg: 0h, 2eh), 0h will be published as 0 and the other values as 1, this way
@ -11,14 +13,6 @@ import re
LOG = logging.getLogger(__name__)
def add_prometheus_help(name, description):
return'# HELP %s %s' % (name, description)
def add_prometheus_type(name, metric_type):
return '# TYPE %s %s' % (name, metric_type)
def metric_names(payload, prefix, sufix, **kwargs):
LOG.info('metric_names function called with payload=%s' % str(payload))
LOG.info('prefix=%s | sufix=%s | kwargs=%s' %
@ -59,7 +53,8 @@ def extract_labels(entries, payload, node_name):
""" This function extract the labels to be used by a metric
If a metric has many entries we add the 'Sensor ID' information as label
otherwise we will only use the default label that is the node name.
otherwise we will only use the default label that is the 'node_name' and
'Entity ID'.
e.g: for Temperature we have two entries for baremetal_temperature_celsius
metric ('Temp (0x1)' and 'Temp (0x2)') and one entry for 'Inlet Temp (0x5)'
@ -71,22 +66,23 @@ def extract_labels(entries, payload, node_name):
'Temp (0x1)': '{node_name=...,sensor=Temp1}',
'Temp (0x2)': '{node_name=...,sensor=Temp2}'}
returns: a dictionarty of dictionaries {<entry>: {label_name: label_value}}
"""
LOG.info('extract_labels function called with: entries=%s | payload=%s | \
node_name=%s' % (str(entries), str(payload), node_name))
default_label = 'node_name="%s"' % node_name
if len(entries) == 1:
default_label += ',entity_id=%s' % payload[entries[0]]['Entity ID']
return {entries[0]: '{%s}' % default_label}
labels = {'node_name': node_name,
'entity_id': payload[entries[0]]['Entity ID']}
return {entries[0]: labels}
entries_labels = {}
for entry in entries:
try:
entity_id = payload[entry]['Entity ID']
sensor_id = payload[entry]['Sensor ID']
metric_label = [default_label,
'entity_id="%s"' % entity_id,
'sensor_id="%s"' % sensor_id]
entries_labels[entry] = '{%s}' % ','.join(metric_label)
metric_label = {'node_name': node_name,
'entity_id': entity_id,
'sensor_id': sensor_id}
entries_labels[entry] = metric_label
except Exception as e:
LOG.exception(e)
return entries_labels
@ -118,8 +114,8 @@ def extract_values(entries, payload, use_ipmi_format=True):
return values
def prometheus_format(payload, node_name, available_metrics, use_ipmi_format):
prometheus_info = []
def prometheus_format(payload, node_name, ipmi_metric_registry,
available_metrics, use_ipmi_format):
for metric in available_metrics:
entries = available_metrics[metric]
labels = extract_labels(entries, payload, node_name)
@ -127,13 +123,12 @@ def prometheus_format(payload, node_name, available_metrics, use_ipmi_format):
use_ipmi_format=use_ipmi_format)
if all(v is None for v in values.values()):
continue
prometheus_info.append(add_prometheus_help(metric, ''))
prometheus_info.append(add_prometheus_type(metric, 'gauge'))
g = Gauge(metric, '', labelnames=labels.get(entries[0]).keys(),
registry=ipmi_metric_registry)
for e in entries:
if values[e] is None:
continue
prometheus_info.append("%s%s %s" % (metric, labels[e], values[e]))
return '\n'.join(prometheus_info)
g.labels(**labels[e]).set(values[e])
CATEGORY_PARAMS = {
@ -160,14 +155,12 @@ CATEGORY_PARAMS = {
}
def category(category_name, payload, node_name):
def category_registry(category_name, payload, node_name, ipmi_metric_registry):
if category_name in CATEGORY_PARAMS:
prefix = CATEGORY_PARAMS[category_name]['prefix']
sufix = CATEGORY_PARAMS[category_name]['sufix']
extra = CATEGORY_PARAMS[category_name]['extra_params']
available_metrics = metric_names(payload, prefix, sufix, **extra)
use_ipmi_format = CATEGORY_PARAMS[category_name]['use_ipmi_format']
return prometheus_format(payload, node_name, available_metrics,
use_ipmi_format)
else:
return None
prometheus_format(payload, node_name, ipmi_metric_registry,
available_metrics, use_ipmi_format)

26
ironic_prometheus_exporter/parsers/manager.py
View File

@ -1,26 +0,0 @@
from ironic_prometheus_exporter.parsers import ipmi
class ParserManager(object):
def __init__(self, data):
self.driver_information = []
if data['event_type'] == 'hardware.ipmi.metrics':
self.driver_information = self._ipmi_driver(data)
def _ipmi_driver(self, data):
node_name = data['payload']['node_name']
payload = data['payload']['payload']
ipmi_information = []
for category in payload:
category_output = ipmi.category(category.lower(),
payload[category], node_name)
if category_output:
ipmi_information.append(category_output)
return ipmi_information
def merge_information(self):
info = ''
for obj in self.driver_information:
info += obj + '\n'
return info.rstrip('\n')

325
ironic_prometheus_exporter/tests/test_ipmi_parser.py
View File

@ -1,7 +1,8 @@
import json
import unittest
from ironic_prometheus_exporter.parsers import ipmi, manager
from ironic_prometheus_exporter.parsers import ipmi
from prometheus_client import CollectorRegistry
DATA = json.load(open('./ironic_prometheus_exporter/tests/data.json'))
@ -12,69 +13,150 @@ 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'],
'baremetal_', '')
prefix, sufix, **extra)
self.assertEqual(len(management_metrics_name), 1)
self.assertIn('baremetal_front_led_panel', management_metrics_name)
management_parser = ipmi.category('management',
self.payload['Management'],
self.node_name)
self.assertEqual(len(management_parser.split('\n')), 3)
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'], 'baremetal_', '_celcius')
self.payload['Temperature'], prefix, sufix, **extra)
self.assertEqual(len(temperature_metrics_name), 3)
self.assertIn('baremetal_temp_celcius', temperature_metrics_name)
self.assertIn('baremetal_exhaust_temp_celcius',
self.assertIn('baremetal_temp_celsius', temperature_metrics_name)
self.assertIn('baremetal_exhaust_temp_celsius',
temperature_metrics_name)
self.assertIn('baremetal_inlet_temp_celcius', temperature_metrics_name)
self.assertIn('baremetal_inlet_temp_celsius', temperature_metrics_name)
temperature_parser = ipmi.category('temperature',
self.payload['Temperature'],
self.node_name)
self.assertEqual(len(temperature_parser.split('\n')), 10)
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'],
'baremetal_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)
system_parser = ipmi.category('system', self.payload['System'],
self.node_name)
self.assertEqual(len(system_parser.split('\n')), 3)
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'],
'baremetal_', '')
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)
current_parser = ipmi.category('current', self.payload['Current'],
self.node_name)
self.assertEqual(len(current_parser.split('\n')), 7)
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'],
'baremetal_', '')
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)
version_parser = ipmi.category('version', self.payload['Version'],
self.node_name)
self.assertEqual(len(version_parser.split('\n')), 6)
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):
memory_metrics_name = ipmi.metric_names(self.payload['Memory'],
'baremetal_', '',
**{'special_label': 'memory'})
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)
@ -90,47 +172,184 @@ class TestPayloadsParser(unittest.TestCase):
memory_metrics_name)
self.assertIn('baremetal_memory_spared', memory_metrics_name)
memory_parser = ipmi.category('memory', self.payload['Memory'],
self.node_name)
self.assertEqual(len(memory_parser.split('\n')), 24)
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):
power_metrics_name = ipmi.metric_names(self.payload['Power'],
'baremetal_power_', '')
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)
power_parser = ipmi.category('power', self.payload['Power'],
self.node_name)
self.assertEqual(len(power_parser.split('\n')), 4)
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'],
'baremetal_', '')
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)
watchdog_parser = ipmi.category('watchdog2', self.payload['Watchdog2'],
self.node_name)
self.assertEqual(len(watchdog_parser.split('\n')), 6)
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):
fan_metrics_name = ipmi.metric_names(self.payload['Fan'], 'baremetal_',
'', **{'extract_unit': True,
'special_label': 'fan'})
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)
fan_parser = ipmi.category('fan', self.payload['Fan'], self.node_name)
self.assertEqual(len(fan_parser.split('\n')), 21)
ipmi.prometheus_format(self.payload['Fan'], self.node_name,
self.metric_registry, fan_metrics_name,
ipmi_format)
class TestIpmiManager(unittest.TestCase):
def test_manager(self):
node_manager = manager.ParserManager(DATA)
node_metrics = node_manager.merge_information()
self.assertEqual(len(node_metrics.split('\n')), 84)
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)'}))

2
requirements.txt
View File

@ -1,4 +1,6 @@
pbr!=2.1.0,>=2.0.0 # Apache-2.0
stevedore>=1.20.0 # Apache-2.0
oslo.messaging>=9.4.0 # Apache-2.0
uWSGI # Apache-2.0
Flask>=0.11,!=0.12.3
prometheus_client # Apache-2.0