def __init__(self):
self.registry = CollectorRegistry()
self.prodstack = {}
with open(config['cache_file'], 'rb') as f:
self.prodstack = pickle.load(f)[0]
self.tenant_map = {
t['id']: t['name']
for t in self.prodstack['tenants']
}
self.network_map = {
n['id']: n['name']
for n in self.prodstack['networks']
}
self.subnet_map = {
n['id']: {
'name': n['name'],
'pool': n['allocation_pools']
}
for n in self.prodstack['subnets']
}
#self.routers = self.prodstack['routers']
self.ports = self.prodstack['ports']
def main(args=None):
print('Requesting data')
parser = argparse.ArgumentParser()
parser.add_argument('job_id', type=int, help='A job id')
args = parser.parse_args(args)
res = requests.post(f'{JOB_SERVER_BASE_URL}/worktime',
json={'id': int(args.job_id)})
worker = res.json()
print(f'Worker {worker["name"]} starts working!')
for _ in range(0, worker['worktime']):
print(f'{worker["name"]} working!')
time.sleep(worker['worktime'] * 0.1)
registry = CollectorRegistry()
g = Gauge('job_last_success_unixtime',
'Last time a batch job successfully finished',
registry=registry)
g.set_to_current_time()
push_to_gateway(PROMETHEUS_SERVER, job=worker["name"], registry=registry)
print('Finished!')
def generate_latest_metrics(self, request):
""" gets the latest metrics """
section = request.args.get(b'section', [b'default'])[0].decode('utf-8')
if section not in self.config.keys():
log("{} is not a valid section, using default".format(section))
section = 'default'
if self.config[section].get('vsphere_host') and self.config[section].get('vsphere_host') != "None":
vsphere_host = self.config[section].get('vsphere_host')
elif request.args.get(b'target', [None])[0]:
vsphere_host = request.args.get(b'target', [None])[0].decode('utf-8')
elif request.args.get(b'vsphere_host', [None])[0]:
vsphere_host = request.args.get(b'vsphere_host')[0].decode('utf-8')
else:
request.setResponseCode(500)
log("No vsphere_host or target defined")
request.write(b'No vsphere_host or target defined!\n')
request.finish()
return
collector = VmwareCollector(
vsphere_host,
self.config[section]['vsphere_user'],
self.config[section]['vsphere_password'],
self.config[section]['collect_only'],
self.config[section]['ignore_ssl'],
)
metrics = yield collector.collect()
registry = CollectorRegistry()
registry.register(ListCollector(metrics))
output = generate_latest(registry)
request.setHeader("Content-Type", "text/plain; charset=UTF-8")
request.setResponseCode(200)
request.write(output)
request.finish()
def parse_config():
registry = CollectorRegistry()
config = configparser.ConfigParser()
config.read_file(
open(
os.environ.get(
"BORG_REPO_EXPORTER_CONFIG_PATH",
"/usr/local/etc/borg_repo_exporter/config.conf",
)))
output_path = config.get(
"borg_repo_exporter",
"output_path",
fallback="/var/tmp/node_exporter/borg_repo_exporter.prom",
)
instance = config.get("borg_repo_exporter",
"instance",
fallback=socket.gethostname())
collectors = []
gauges = {}
for section in config.sections():
if section == "borg_repo_exporter":
continue
c = config[section]
passphrase = c["passphrase"]
path = c["path"]
ignorelist = c.get("ignorelist", "").split(",")
prefix = c.get("prefix", "")
collectors.append(
BorgCollector(gauges, registry, passphrase, path, ignorelist,
prefix))
return {
"collectors": collectors,
"output_path": output_path,
"registry": registry,
"instance": instance,
}
def generate_prometheus_exporter_from_storage():
registry = CollectorRegistry()
common_p_metric = ['yhat', 'yhat_lower', 'yhat_upper']
t_gap = timedelta(minutes=3)
# cst_tz = timezone('Asia/Shanghai')
# tn = datetime.now().replace(tzinfo=cst_tz)
tn = datetime.now()
stn_str = (tn-t_gap).strftime('%Y-%m-%d %H:%M')
etn_str = (tn+t_gap).strftime('%Y-%m-%d %H:%M')
g_map = {}
if not os.path.exists(TMP_FILE) or time.time() - os.path.getmtime(TMP_FILE) > (4 * 60):
for x in storage.read_all():
nearest_index = x['data'].index.get_loc(tn, method='nearest')
if nearest_index >= (len(x['data'])-1):
continue
# print(len(x['data'].to_csv(index=True)))
for pm in common_p_metric:
#metric = "%s_%s_%d" % (pm, x['model'].register_metric.name, x['model'].pk)
metric = "%s_%s" % (pm, x['model'].register_metric.name)
if metric not in g_map:
g_map[metric] = Gauge(
name=metric,
documentation=metric,
labelnames=list([y.k for y in x['model'].labels.all()]),
# labelvalues=list([y.v for y in x['model'].labels.all()]),
registry=registry
)
print(str(x['model'].labels.all()))
try:
g_map[metric].labels(**({y.k: y.v for y in x['model'].labels.all()})).set(x['data'].iloc[[nearest_index]][pm])
except ValueError as e:
logging.error("[pt:%d]wrong label: %s" % (x['model'].pk, str(e)))
write_to_textfile(TMP_FILE, registry)
with open(TMP_FILE, 'r') as fd:
return fd.read()
def init_metrics(self):
"""
Launch the threads that will update the metrics.
"""
self.threads = []
self.registry = CollectorRegistry()
self.data = read_configuration()
for metric in self.data["config"]:
if "labels" in metric:
labels = metric["labels"]
else:
labels = []
if metric["type"].lower() == "counter":
instrument = Counter(metric["name"],
metric["description"],
labels,
registry=self.registry)
elif metric["type"].lower() == "gauge":
instrument = Gauge(metric["name"],
metric["description"],
labels,
registry=self.registry)
elif metric["type"].lower() == "summary":
instrument = Summary(metric["name"],
metric["description"],
labels,
registry=self.registry)
elif metric["type"].lower() == "histogram":
# TODO add support to overwrite buckets
instrument = Histogram(metric["name"],
metric["description"],
labels,
registry=self.registry)
t = threading.Thread(target=self.update_metrics,
args=(instrument, metric))
t.start()
self.threads.append(t)
def notify_success(self, source, hostname, filename, stats):
registry = CollectorRegistry()
s = Summary('backup_size',
'Size of backup file in bytes',
registry=registry)
s.observe(stats.size)
s = Summary(
'backup_dumptime',
'Time taken to dump and compress/encrypt backup in seconds',
registry=registry)
s.observe(stats.dumptime)
s = Summary('backup_uploadtime',
'Time taken to upload backup in seconds',
registry=registry)
s.observe(stats.uploadtime)
if stats.retained_copies is not None:
g = Gauge('backup_retained_copies',
'Number of retained backups found on destination',
registry=registry)
g.set(stats.retained_copies)
g = Gauge('backup_timestamp',
'Time backup completed as seconds-since-the-epoch',
registry=registry)
g.set_to_current_time()
def auth_handler(url, method, timeout, headers, data):
return basic_auth_handler(url, method, timeout, headers, data,
self.username, self.password)
push_to_gateway(self.url,
job=source.id,
registry=registry,
handler=auth_handler)
logging.info("Pushed metrics for job '%s' to gateway (%s)" %
(source.id, self.url))
def push(reporter_name, reporter_value, report_type):
if push.failures >= RETRIES:
return
registry = CollectorRegistry()
if report_type is ReportType.metric:
label_names = ['metric_name', 'push_gateway_type']
label_values = [reporter_name, 'metric']
gauge_name = REPORTER_PUSH_GATEWAY_METRIC_PREFIX + "_" + reporter_name
gauge_value = reporter_value
else:
label_names = ['param_name', 'param_value', 'push_gateway_type']
label_values = [reporter_name, reporter_value, 'parameter']
gauge_name = REPORTER_PUSH_GATEWAY_METRIC_PARAMETER + "_" + reporter_name
gauge_value = 1
gauge = Gauge(name=gauge_name,
documentation="",
labelnames=label_names,
registry=registry)
gauge.labels(*label_values).set(gauge_value)
try:
pushadd_to_gateway(
gateway=os.environ[GATEWAY_URL_KEY],
job=PUSH_GATEWAY_JOB_NAME,
registry=registry,
grouping_key={GROUPING_KEY: os.environ[GROUPING_KEY]})
push.failures = 0
except IOError as e:
runai.utils.log.error('Failed pushing registry to push gateway (%s)',
e)
push.failures += 1
def __init__(self, name, session=None):
self.config = Config()
fh = logging.handlers.WatchedFileHandler(self.config.LOG_FILE)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
self.logger = logging.Logger(name=name)
self.logger.addHandler(fh)
self.logger.setLevel(getattr(logging, self.config.LOG_LEVEL))
self.name = name
self.redis = redis.Redis(host='localhost',
port=6379,
db=0,
health_check_interval=30)
if self.config.PUSH_PROMETHEUS:
self.prom_registry = CollectorRegistry()
self.prom_gauges = {}
if not session:
self.session = requests.Session()
else:
self.session = session
self.get_bearer()
self.logger.debug("DO_POST = %s", self.config.DO_POST)
self.logger.debug("PUSH_PROMETHEUS = %s", self.config.PUSH_PROMETHEUS)
if self.config.DO_POST:
self.create_source_and_type()
if not self.data_types:
self.data_types = {
'default': {
'name': 'Default data type',
'units': 'default',
'description': 'Base class built in type'
}
}
self.data_queue = []
self.logger.debug("Init completed")
self.last_observation = None
def expose(self, app: Flask, endpoint: str = "/metrics") -> "self":
"""Exposes Prometheus metrics by adding endpoint to the given app.
**Important**: There are many different ways to expose metrics. This is
just one of them, suited for both multiprocess and singleprocess mode.
Refer to the Prometheus Python client documentation for more information.
:param app: Flask app where the endpoint should be added to.
:param endpoint: Route of the endpoint. Defaults to "/metrics".
:param return: self.
"""
from prometheus_client import (CONTENT_TYPE_LATEST, REGISTRY,
CollectorRegistry, generate_latest,
multiprocess)
if "prometheus_multiproc_dir" in os.environ:
pmd = os.environ["prometheus_multiproc_dir"]
if os.path.isdir(pmd):
registry = CollectorRegistry()
multiprocess.MultiProcessCollector(registry)
else:
raise ValueError(
f"Env var prometheus_multiproc_dir='{pmd}' not a directory."
)
else:
registry = REGISTRY
@app.route(endpoint)
def metrics():
data = generate_latest(registry)
headers = {
"Content-Type": CONTENT_TYPE_LATEST,
"Content-Length": str(len(data)),
}
return data, 200, headers
def setUp(self):
self.registry = CollectorRegistry()
self.counter = Gauge('g', 'help', registry=self.registry)
self.requests = requests = []
class TestHandler(BaseHTTPRequestHandler):
def do_PUT(self):
self.send_response(201)
length = int(self.headers['content-length'])
requests.append((self, self.rfile.read(length)))
do_POST = do_PUT
do_DELETE = do_PUT
httpd = HTTPServer(('', 0), TestHandler)
self.address = ':'.join([str(x) for x in httpd.server_address])
class TestServer(threading.Thread):
def run(self):
httpd.handle_request()
self.server = TestServer()
self.server.daemon = True
self.server.start()
def collect(team_name, dryrun=False):
"""Push upload data."""
date = datetime.now().date().strftime('%Y-%m-%d')
results = generate_upload_report(date, team_name)
print('%s: %s' % (date, results))
if not dryrun:
print('Pushing data...')
registry = CollectorRegistry()
Gauge('{}_uploads_daily_dev_total'.format(team_name),
'Uploads to dev release',
None,
registry=registry).set(results['dev'])
Gauge('{}_uploads_daily_sru_total'.format(team_name),
'Uploads to supported release (SRU)',
None,
registry=registry).set(results['sru'])
if team_name == 'server':
util.push2gateway('upload', registry)
else:
util.push2gateway('upload-%s' % team_name, registry)
def process(self, file):
self.parse_config()
prom_labels = ["database", "task"]
r = CollectorRegistry()
db_backup_ok = Gauge("backup_ok", "Full Backup of mysql or pgsql "
"databases.",
["database"],
registry=r)
db_backup_time_spent = Gauge("backup_time_spent",
"Time spent with a task on backup.",
prom_labels,
registry=r)
last_success = Gauge("backup_last_success_unixtime",
"Last time a backup job successfully finished",
["database"],
registry=r)
for i in dumpy.base.PROMETHEUS_MONIT_STATUS[self.db]:
db_backup_time_spent.labels(self.db, i['task']).set(i['spent_time'])
if dumpy.base.FILE_EXISTS_ON_S3:
db_backup_ok.labels(self.db).set(1)
elif False in dumpy.base.FAIL_STATE:
db_backup_ok.labels(self.db).set(0)
else:
db_backup_ok.labels(self.db).set(1)
last_success.labels(self.db).set_to_current_time()
try:
push_to_gateway(self.host, self.job_name, registry=r)
except BaseException as e:
logger.error("%s - %s - %s" % (self.db, self.__class__.__name__, e))
return file
def create_timeseries(self, data):
"""Create Prometheus timeseries.
Args:
data (dict): Metric data.
Returns:
object: Metric descriptor.
"""
name = data['name']
description = data['description']
prometheus_push_url = data['url']
prometheus_push_job_name = data.get('job', DEFAULT_PUSHGATEWAY_JOB)
value = data['value']
# Write timeseries w/ metric labels.
labels = data['labels']
registry = CollectorRegistry()
gauge = Gauge(name,
description,
registry=registry,
labelnames=labels.keys())
gauge.labels(*labels.values()).set(value)
# Handle headers
handler = default_handler
if 'username' in data and 'password' in data:
self.username = data['username']
self.password = data['password']
handler = PrometheusExporter.auth_handler
return push_to_gateway(prometheus_push_url,
job=prometheus_push_job_name,
grouping_key=labels,
registry=registry,
handler=handler)
def main(logger):
config = _init_config()
registry = CollectorRegistry()
for metric in COLLECTED_METRICS:
registry.register(metric)
job = _prometheus_job(config.kubernetes_namespace)
prometheus_shutdown = partial(push_to_gateway, config.prometheus_pushgateway, job, registry)
register_shutdown(prometheus_shutdown, "Pushing metrics")
Session = _init_db(config)
session = Session()
register_shutdown(session.get_bind().dispose, "Closing database")
event_producer = EventProducer(config)
register_shutdown(event_producer.close, "Closing producer")
shutdown_handler = ShutdownHandler()
shutdown_handler.register()
with session_guard(session):
run(config, logger, session, event_producer, shutdown_handler)
def lambda_handler(event, context):
# Create the registry
registry = CollectorRegistry()
thread = threading.Thread(target=gather_metrics_data, args=(registry, ))
stop_threads = False
thread.start()
# actual lambda handler code
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = record['s3']['object']['key']
original_img = '/tmp/original-{}'.format(key)
temp_img = '/tmp/temp-{}'.format(key)
s3_client.download_file(bucket, key, original_img)
for size_px in THUMBNAIL_SIZES_PX:
resize_image(original_img, temp_img, size_px)
new_name_key = key.replace(".jpg", "_" + str(size_px) + ".jpg")
s3_client.upload_file(temp_img, '{}-resized'.format(bucket),
new_name_key)
stop_threads = True
thread.join()
def init_prometheus(prometheus_hostname, node_hostname):
from prometheus_client import CollectorRegistry, Gauge
metrics = Metrics()
metrics.registry = CollectorRegistry()
metrics.grouping_keys = {}
metrics.hostname = prometheus_hostname
metric_current_tps_name = "exonum_node_tps_current"
metric_avg_tps_name = "exonum_node_tps_average"
metric_current_height_name = "exonum_node_current_height"
metrics.metric_avg_tps = Gauge(metric_avg_tps_name,
"Exonum's node average TPS",
registry=metrics.registry)
metrics.metric_current_height = Gauge(
metric_current_height_name,
"Exonum's node current height",
registry=metrics.registry,
)
metrics.metric_current_tps = Gauge(metric_current_tps_name,
"Exonum's node current TPS",
registry=metrics.registry)
metrics.grouping_keys["instance"] = urlparse(node_hostname).netloc
return metrics
def get_stats(self):
registry = CollectorRegistry()
labels = ['region', 'host', 'service', 'state']
services_stats_cache = self.get_cache_data()
for services_stat in services_stats_cache:
try:
stat_gauge = Gauge(
self.gauge_name_sanitize(
services_stat['stat_name']),
'Openstack Nova Service statistic',
labels,
registry=registry)
label_values = [self.osclient.region,
services_stat.get('host', ''),
services_stat.get('service', ''),
services_stat.get('state', '')]
stat_gauge.labels(*label_values).set(services_stat['stat_value'])
except ValueError:
logger.debug('Unchanged value for stat {} already present in '
'nova services registry for host {}; ignoring.'
.format(services_stat['stat_name'],
services_stat['host']))
return generate_latest(registry)
def collect(queue_name, dryrun=False):
"""Collect and push autopkgtest queue depth metrics."""
queue_details = QUEUES_JSON[queue_name]
for release in queue_details:
for arch in queue_details[release]:
count = len(queue_details[release][arch])
print('%s %s: %i' % (release.title(), arch, count))
if not dryrun:
print('Pushing data...')
registry = CollectorRegistry()
for release in queue_details:
for arch in queue_details[release]:
count = len(queue_details[release][arch])
Gauge('autopkgtest_queue_size_%s_%s_%s' %
(queue_name, release, arch),
"Autopkgtest queue size",
None,
registry=registry).set(count)
util.push2gateway('foundations-autopkgtest-%s' %
queue_name, registry)
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
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--outfile',
metavar='FILE.prom',
help='Output file (stdout)')
parser.add_argument('--statsfile',
metavar='FILE',
help='vhtcpd stats file (%(default)s)',
default='/tmp/vhtcpd.stats')
parser.add_argument('-d',
'--debug',
action='store_true',
help='Enable debug logging (false)')
args = parser.parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if args.outfile and not args.outfile.endswith('.prom'):
parser.error('Output file does not end with .prom')
if args.statsfile:
if args.statsfile == '-':
infile = sys.stdin
else:
infile = open(args.statsfile, 'r')
registry = CollectorRegistry()
collect_vhtcp_stats(infile, registry)
if args.outfile:
write_to_textfile(args.outfile, registry)
else:
sys.stdout.buffer.write(generate_latest(registry))
def setUp(self):
self.registry = CollectorRegistry()
self.data = ''
class TCPHandler(SocketServer.BaseRequestHandler):
def handle(s):
self.data = s.request.recv(1024)
server = SocketServer.TCPServer(('', 0), TCPHandler)
class ServingThread(threading.Thread):
def run(self):
server.handle_request()
server.socket.close()
self.t = ServingThread()
self.t.start()
# Explicitly use localhost as the target host, since connecting to 0.0.0.0 fails on Windows
self.address = ('localhost', server.server_address[1])
self.gb = GraphiteBridge(self.address,
self.registry,
_timer=fake_timer)
def test_gauge_config(self):
"""Test Gauge minimal config."""
faucet_conf1 = """
vlans:
100:
description: "100"
dps:
dp1:
dp_id: 0x1
interfaces:
1:
description: "1"
native_vlan: 100
"""
faucet_conf2 = """
vlans:
100:
description: "200"
dps:
dp1:
dp_id: 0x1
interfaces:
2:
description: "2"
native_vlan: 100
"""
os.environ['FAUCET_CONFIG'] = os.path.join(self.tmpdir, 'faucet.yaml')
self._write_config(os.environ['FAUCET_CONFIG'], faucet_conf1)
os.environ['GAUGE_CONFIG'] = os.path.join(self.tmpdir, 'gauge.yaml')
gauge_conf = """
faucet_configs:
- '%s'
watchers:
port_status_poller:
type: 'port_state'
all_dps: True
db: 'prometheus'
port_stats_poller:
type: 'port_stats'
all_dps: True
interval: 10
db: 'prometheus'
flow_table_poller:
type: 'flow_table'
all_dps: True
interval: 60
db: 'prometheus'
dbs:
prometheus:
type: 'prometheus'
prometheus_addr: '0.0.0.0'
prometheus_port: 0
""" % os.environ['FAUCET_CONFIG']
self._write_config(os.environ['GAUGE_CONFIG'], gauge_conf)
self.os_ken_app = gauge.Gauge(dpset={}, reg=CollectorRegistry())
self.os_ken_app.reload_config(None)
self.assertFalse(self.os_ken_app._config_files_changed())
self.assertTrue(self.os_ken_app.watchers)
self.os_ken_app.reload_config(None)
self.assertTrue(self.os_ken_app.watchers)
self.assertFalse(self.os_ken_app._config_files_changed())
# Load a new FAUCET config.
self._write_config(os.environ['FAUCET_CONFIG'], faucet_conf2)
self.assertTrue(self.os_ken_app._config_files_changed())
self.os_ken_app.reload_config(None)
self.assertTrue(self.os_ken_app.watchers)
self.assertFalse(self.os_ken_app._config_files_changed())
# Load an invalid Gauge config
self._write_config(os.environ['GAUGE_CONFIG'], 'invalid')
self.assertTrue(self.os_ken_app._config_files_changed())
self.os_ken_app.reload_config(None)
self.assertTrue(self.os_ken_app.watchers)
# Keep trying to load a valid version.
self.assertTrue(self.os_ken_app._config_files_changed())
# Load good Gauge config back
self._write_config(os.environ['GAUGE_CONFIG'], gauge_conf)
self.assertTrue(self.os_ken_app._config_files_changed())
self.os_ken_app.reload_config(None)
self.assertTrue(self.os_ken_app.watchers)
self.assertFalse(self.os_ken_app._config_files_changed())
from prometheus_client import Gauge
from prometheus_client import Counter
from prometheus_client import push_to_gateway
from thoth.common import init_logging
from thoth.common import OpenShift
from thoth.common import __version__ as __common__version__
__version__ = f"0.7.0+common.{__common__version__}"
init_logging()
_LOGGER = logging.getLogger("thoth.cleanup_job")
_DEFAULT_TTL = parse_ttl(os.getenv("THOTH_CLEANUP_DEFAULT_TTL") or "7d")
_CLEANUP_LABEL_SELECTOR = "mark=cleanup"
_PROMETHEUS_REGISTRY = CollectorRegistry()
_THOTH_METRICS_PUSHGATEWAY_URL = os.getenv("PROMETHEUS_PUSHGATEWAY_URL")
_METRIC_RUNTIME = Gauge("thoth_cleanup_job_runtime_seconds",
"Runtime of cleanup job in seconds.", [],
registry=_PROMETHEUS_REGISTRY)
_METRIC_INFO = Gauge("thoth_cleanup_job_info",
"Thoth Cleanup Job information", ["version"],
registry=_PROMETHEUS_REGISTRY)
_METRIC_DELETED_BUILDCONFIGS = Counter(
"thoth_cleanup_job_buildconfigs",
"Buildconfigs cleaned up.",
["namespace", "component", "resource"],
registry=_PROMETHEUS_REGISTRY,
)
_METRIC_DELETED_IMAGESTREAMS = Counter(
class GaugePrometheusTests(unittest.TestCase): # pytype: disable=module-attr
"""Tests the GaugePortStatsPrometheusPoller update method"""
prom_client = gauge_prom.GaugePrometheusClient(reg=CollectorRegistry())
@staticmethod
def parse_prom_output(output):
"""Parses the port stats from prometheus into a dictionary"""
parsed_output = {}
for line in output.split('\n'):
# discard comments and stats not related to port stats
if line.startswith('#') or not line.startswith(
gauge_prom.PROM_PORT_PREFIX):
continue
index = line.find('{')
# get the stat name e.g. of_port_rx_bytes and strip 'of_port_'
prefix = gauge_prom.PROM_PORT_PREFIX + gauge_prom.PROM_PREFIX_DELIM
stat_name = line[0:index].replace(prefix, '')
# get the labels within {}
labels = line[index + 1:line.find('}')].split(',')
for label in labels:
lab_name, lab_val = label.split('=', 1)
lab_val = lab_val.replace('"', '')
if lab_name == 'dp_id':
dp_id = int(lab_val, 16)
elif lab_name == 'port':
port_name = lab_val
key = (dp_id, port_name)
stat_val = line.split(' ')[-1]
if key not in parsed_output:
parsed_output[key] = []
parsed_output[key].append((stat_name, float(stat_val)))
return parsed_output
@staticmethod
def get_prometheus_stats(addr, port):
"""Attempts to contact the prometheus server
at the address to grab port stats."""
url = 'http://{}:{}'.format(addr, port)
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(max_retries=10)
session.mount('http://', adapter)
return session.get(url).text
def test_poller(self):
"""Test the update method to see if it pushes port stats"""
datapath = create_mock_datapath(2)
conf = mock.Mock(dp=datapath,
type='',
interval=1,
prometheus_port=9303,
prometheus_addr='localhost',
use_test_thread=True)
prom_poller = gauge_prom.GaugePortStatsPrometheusPoller(
conf, '__name__', self.prom_client)
prom_poller._running = True
msg = port_stats_msg(datapath)
prom_poller.update(time.time(), msg)
prom_lines = self.get_prometheus_stats(conf.prometheus_addr,
conf.prometheus_port)
prom_lines = self.parse_prom_output(prom_lines)
for port_num, port in datapath.ports.items():
port_stats = msg.body[int(port_num) - 1]
stats = prom_lines[(datapath.dp_id, port.name)]
stats_found = set()
for stat_name, stat_val in stats:
self.assertAlmostEqual(stat_val,
getattr(port_stats, stat_name))
stats_found.add(stat_name)
self.assertEqual(stats_found, set(gauge_prom.PROM_PORT_VARS))
def test_port_state(self):
"""Test the update method to see if it pushes port state"""
datapath = create_mock_datapath(2)
conf = mock.Mock(dp=datapath,
type='',
interval=1,
prometheus_port=9303,
prometheus_addr='localhost',
use_test_thread=True)
prom_poller = gauge_prom.GaugePortStatePrometheusPoller(
conf, '__name__', self.prom_client)
prom_poller._running = True
reasons = [
ofproto.OFPPR_ADD, ofproto.OFPPR_DELETE, ofproto.OFPPR_MODIFY
]
for i in range(1, len(conf.dp.ports) + 1):
msg = port_state_msg(conf.dp, i, reasons[i - 1])
port_name = conf.dp.ports[i].name
rcv_time = int(time.time())
prom_poller.update(rcv_time, msg)
prom_lines = self.get_prometheus_stats(conf.prometheus_addr,
conf.prometheus_port)
prom_lines = self.parse_prom_output(prom_lines)
stats = prom_lines[(datapath.dp_id, port_name)]
stats_found = set()
for stat_name, stat_val in stats:
msg_data = msg if stat_name == 'reason' else msg.desc
self.assertAlmostEqual(stat_val, getattr(msg_data, stat_name))
stats_found.add(stat_name)
self.assertEqual(stats_found, set(gauge_prom.PROM_PORT_STATE_VARS))
def test_flow_stats(self):
"""Check the update method of the GaugeFlowTablePrometheusPoller class"""
datapath = create_mock_datapath(2)
conf = mock.Mock(dp=datapath,
type='',
interval=1,
prometheus_port=9303,
prometheus_addr='localhost',
use_test_thread=True)
prom_poller = gauge_prom.GaugeFlowTablePrometheusPoller(
conf, '__name__', self.prom_client)
rcv_time = int(time.time())
instructions = [parser.OFPInstructionGotoTable(1)]
msg = flow_stats_msg(conf.dp, instructions)
prom_poller.update(rcv_time, msg)
# libp2p_peers
self.libp2p_peers = Gauge('libp2p_peers', 'Tracks number of libp2p peers', registry=registry) # noqa: E501
# On slot transition
self.beacon_slot = Gauge('beacon_slot', 'Latest slot of the beacon chain state', registry=registry) # noqa: E501
# On block transition
self.beacon_head_slot = Gauge('beacon_head_slot', 'Slot of the head block of the beacon chain', registry=registry) # noqa: E501
self.beacon_head_root = Gauge('beacon_head_root', 'Root of the head block of the beacon chain', registry=registry) # noqa: E501
# On epoch transition
self.beacon_previous_justified_epoch = Gauge('beacon_previous_justified_epoch', 'Current previously justified epoch', registry=registry) # noqa: E501
self.beacon_previous_justified_root = Gauge('beacon_previous_justified_root', 'Current previously justified root', registry=registry) # noqa: E501
self.beacon_current_justified_epoch = Gauge('beacon_current_justified_epoch', 'Current justified epoch', registry=registry) # noqa: E501
self.beacon_current_justified_root = Gauge('beacon_current_justified_root', 'Current justified root', registry=registry) # noqa: E501
self.beacon_finalized_epoch = Gauge('beacon_finalized_epoch', 'Current finalized epoch', registry=registry) # noqa: E501
self.beacon_finalized_root = Gauge('beacon_finalized_root', 'Current finalized root', registry=registry) # noqa: E501
#
# Other
#
# Validator
self.validator_proposed_blocks = Counter("validator_proposed_blocks", "counter of proposed blocks", registry=registry) # noqa: E501
self.validator_sent_attestation = Counter("validator_sent_attestation", "counter of attested", registry=registry) # noqa: E501
registry = CollectorRegistry()
metrics = AllMetrics(registry)
def metrics():
registry = CollectorRegistry()
multiprocess.MultiProcessCollector(registry)
return generate_latest(registry)
from thoth.common import init_logging
from thoth.common import OpenShift
from thoth.common import __version__ as __common__version__
from thoth.storages import __version__ as __storage__version__
from thoth.storages import GraphDatabase
__version__ = "0.1.0"
__service_version__ = (
f"{__version__}+storage.{__storage__version__}.common.{__common__version__}"
)
init_logging()
prometheus_registry = CollectorRegistry()
_GRAPH_DB = GraphDatabase()
_GRAPH_DB.connect()
_OPENSHIFT = OpenShift()
_LOGGER = logging.getLogger("thoth.graph_refresh_job")
_LOG_SOLVER = os.environ.get("THOTH_LOG_SOLVER") == "DEBUG"
_LOG_REVSOLVER = os.environ.get("THOTH_LOG_REVSOLVER") == "DEBUG"
THOTH_MY_NAMESPACE = os.getenv("NAMESPACE", "thoth-test-core")
_THOTH_METRICS_PUSHGATEWAY_URL = os.getenv("PROMETHEUS_PUSHGATEWAY_URL")
_METRIC_RUNTIME = Gauge(
"graph_refresh_job_runtime_seconds",
"Runtime of graph refresh job in seconds.",
def metrics():
return Response(
generate_latest(MultiProcessCollector(CollectorRegistry())),
mimetype=CONTENT_TYPE_LATEST,
)
def metrics(self, **kwargs):
registry = kwargs.pop('registry', CollectorRegistry(auto_describe=True))
return PrometheusMetrics(self.app, registry=registry, **kwargs)
