import cherrypy
from collections import defaultdict
from pkg_resources import packaging # type: ignore
import json
import math
import os
import re
import threading
import time
import enum
from mgr_module import CLIReadCommand, MgrModule, MgrStandbyModule, PG_STATES, Option, ServiceInfoT, HandleCommandResult, CLIWriteCommand
from mgr_util import get_default_addr, profile_method, build_url
from rbd import RBD
from collections import namedtuple
import yaml
from typing import DefaultDict, Optional, Dict, Any, Set, cast, Tuple, Union, List, Callable
LabelValues = Tuple[str, ...]
Number = Union[int, float]
MetricValue = Dict[LabelValues, Number]
# Defaults for the Prometheus HTTP server. Can also set in config-key
# see https://github.com/prometheus/prometheus/wiki/Default-port-allocations
# for Prometheus exporter port registry
DEFAULT_PORT = 9283
# When the CherryPy server in 3.2.2 (and later) starts it attempts to verify
# that the ports its listening on are in fact bound. When using the any address
# "::" it tries both ipv4 and ipv6, and in some environments (e.g. kubernetes)
# ipv6 isn't yet configured / supported and CherryPy throws an uncaught
# exception.
if cherrypy is not None:
Version = packaging.version.Version
v = Version(cherrypy.__version__)
# the issue was fixed in 3.2.3. it's present in 3.2.2 (current version on
# centos:7) and back to at least 3.0.0.
if Version("3.1.2") <= v < Version("3.2.3"):
# https://github.com/cherrypy/cherrypy/issues/1100
from cherrypy.process import servers
servers.wait_for_occupied_port = lambda host, port: None
# cherrypy likes to sys.exit on error. don't let it take us down too!
def os_exit_noop(status: int) -> None:
pass
os._exit = os_exit_noop # type: ignore
# to access things in class Module from subclass Root. Because
# it's a dict, the writer doesn't need to declare 'global' for access
_global_instance = None # type: Optional[Module]
cherrypy.config.update({
'response.headers.server': 'Ceph-Prometheus'
})
def health_status_to_number(status: str) -> int:
if status == 'HEALTH_OK':
return 0
elif status == 'HEALTH_WARN':
return 1
elif status == 'HEALTH_ERR':
return 2
raise ValueError(f'unknown status "{status}"')
DF_CLUSTER = ['total_bytes', 'total_used_bytes', 'total_used_raw_bytes']
DF_POOL = ['max_avail', 'avail_raw', 'stored', 'stored_raw', 'objects', 'dirty',
'quota_bytes', 'quota_objects', 'rd', 'rd_bytes', 'wr', 'wr_bytes',
'compress_bytes_used', 'compress_under_bytes', 'bytes_used', 'percent_used']
OSD_POOL_STATS = ('recovering_objects_per_sec', 'recovering_bytes_per_sec',
'recovering_keys_per_sec', 'num_objects_recovered',
'num_bytes_recovered', 'num_bytes_recovered')
OSD_FLAGS = ('noup', 'nodown', 'noout', 'noin', 'nobackfill', 'norebalance',
'norecover', 'noscrub', 'nodeep-scrub')
FS_METADATA = ('data_pools', 'fs_id', 'metadata_pool', 'name')
MDS_METADATA = ('ceph_daemon', 'fs_id', 'hostname', 'public_addr', 'rank',
'ceph_version')
MON_METADATA = ('ceph_daemon', 'hostname',
'public_addr', 'rank', 'ceph_version')
MGR_METADATA = ('ceph_daemon', 'hostname', 'ceph_version')
MGR_STATUS = ('ceph_daemon',)
MGR_MODULE_STATUS = ('name',)
MGR_MODULE_CAN_RUN = ('name',)
OSD_METADATA = ('back_iface', 'ceph_daemon', 'cluster_addr', 'device_class',
'front_iface', 'hostname', 'objectstore', 'public_addr',
'ceph_version')
OSD_STATUS = ['weight', 'up', 'in']
OSD_STATS = ['apply_latency_ms', 'commit_latency_ms']
POOL_METADATA = ('pool_id', 'name', 'type', 'description', 'compression_mode')
RGW_METADATA = ('ceph_daemon', 'hostname', 'ceph_version', 'instance_id')
RBD_MIRROR_METADATA = ('ceph_daemon', 'id', 'instance_id', 'hostname',
'ceph_version')
DISK_OCCUPATION = ('ceph_daemon', 'device', 'db_device',
'wal_device', 'instance', 'devices', 'device_ids')
NUM_OBJECTS = ['degraded', 'misplaced', 'unfound']
alert_metric = namedtuple('alert_metric', 'name description')
HEALTH_CHECKS = [
alert_metric('SLOW_OPS', 'OSD or Monitor requests taking a long time to process'),
]
HEALTHCHECK_DETAIL = ('name', 'severity')
class Severity(enum.Enum):
ok = "HEALTH_OK"
warn = "HEALTH_WARN"
error = "HEALTH_ERR"
class Format(enum.Enum):
plain = 'plain'
json = 'json'
json_pretty = 'json-pretty'
yaml = 'yaml'
class HealthCheckEvent:
def __init__(self, name: str, severity: Severity, first_seen: float, last_seen: float, count: int, active: bool = True):
self.name = name
self.severity = severity
self.first_seen = first_seen
self.last_seen = last_seen
self.count = count
self.active = active
def as_dict(self) -> Dict[str, Any]:
"""Return the instance as a dictionary."""
return self.__dict__
class HealthHistory:
kv_name = 'health_history'
titles = "{healthcheck_name:<24} {first_seen:<20} {last_seen:<20} {count:>5} {active:^6}"
date_format = "%Y/%m/%d %H:%M:%S"
def __init__(self, mgr: MgrModule):
self.mgr = mgr
self.lock = threading.Lock()
self.healthcheck: Dict[str, HealthCheckEvent] = {}
self._load()
def _load(self) -> None:
"""Load the current state from the mons KV store."""
data = self.mgr.get_store(self.kv_name)
if data:
try:
healthcheck_data = json.loads(data)
except json.JSONDecodeError:
self.mgr.log.warn(
f"INVALID data read from mgr/prometheus/{self.kv_name}. Resetting")
self.reset()
return
else:
for k, v in healthcheck_data.items():
self.healthcheck[k] = HealthCheckEvent(
name=k,
severity=v.get('severity'),
first_seen=v.get('first_seen', 0),
last_seen=v.get('last_seen', 0),
count=v.get('count', 1),
active=v.get('active', True))
else:
self.reset()
def reset(self) -> None:
"""Reset the healthcheck history."""
with self.lock:
self.mgr.set_store(self.kv_name, "{}")
self.healthcheck = {}
def save(self) -> None:
"""Save the current in-memory healthcheck history to the KV store."""
with self.lock:
self.mgr.set_store(self.kv_name, self.as_json())
def check(self, health_checks: Dict[str, Any]) -> None:
"""Look at the current health checks and compare existing the history.
Args:
health_checks (Dict[str, Any]): current health check data
"""
current_checks = health_checks.get('checks', {})
changes_made = False
# first turn off any active states we're tracking
for seen_check in self.healthcheck:
check = self.healthcheck[seen_check]
if check.active and seen_check not in current_checks:
check.active = False
changes_made = True
# now look for any additions to track
now = time.time()
for name, info in current_checks.items():
if name not in self.healthcheck:
# this healthcheck is new, so start tracking it
changes_made = True
self.healthcheck[name] = HealthCheckEvent(
name=name,
severity=info.get('severity'),
first_seen=now,
last_seen=now,
count=1,
active=True
)
else:
# seen it before, so update its metadata
check = self.healthcheck[name]
if check.active:
# check has been registered as active already, so skip
continue
else:
check.last_seen = now
check.count += 1
check.active = True
changes_made = True
if changes_made:
self.save()
def __str__(self) -> str:
"""Print the healthcheck history.
Returns:
str: Human readable representation of the healthcheck history
"""
out = []
if len(self.healthcheck.keys()) == 0:
out.append("No healthchecks have been recorded")
else:
out.append(self.titles.format(
healthcheck_name="Healthcheck Name",
first_seen="First Seen (UTC)",
last_seen="Last seen (UTC)",
count="Count",
active="Active")
)
for k in sorted(self.healthcheck.keys()):
check = self.healthcheck[k]
out.append(self.titles.format(
healthcheck_name=check.name,
first_seen=time.strftime(self.date_format, time.localtime(check.first_seen)),
last_seen=time.strftime(self.date_format, time.localtime(check.last_seen)),
count=check.count,
active="Yes" if check.active else "No")
)
out.extend([f"{len(self.healthcheck)} health check(s) listed", ""])
return "\n".join(out)
def as_dict(self) -> Dict[str, Any]:
"""Return the history in a dictionary.
Returns:
Dict[str, Any]: dictionary indexed by the healthcheck name
"""
return {name: self.healthcheck[name].as_dict() for name in self.healthcheck}
def as_json(self, pretty: bool = False) -> str:
"""Return the healthcheck history object as a dict (JSON).
Args:
pretty (bool, optional): whether to json pretty print the history. Defaults to False.
Returns:
str: str representation of the healthcheck in JSON format
"""
if pretty:
return json.dumps(self.as_dict(), indent=2)
else:
return json.dumps(self.as_dict())
def as_yaml(self) -> str:
"""Return the healthcheck history in yaml format.
Returns:
str: YAML representation of the healthcheck history
"""
return yaml.safe_dump(self.as_dict(), explicit_start=True, default_flow_style=False)
class Metric(object):
def __init__(self, mtype: str, name: str, desc: str, labels: Optional[LabelValues] = None) -> None:
self.mtype = mtype
self.name = name
self.desc = desc
self.labelnames = labels # tuple if present
self.value: Dict[LabelValues, Number] = {}
def clear(self) -> None:
self.value = {}
def set(self, value: Number, labelvalues: Optional[LabelValues] = None) -> None:
# labelvalues must be a tuple
labelvalues = labelvalues or ('',)
self.value[labelvalues] = value
def str_expfmt(self) -> str:
def promethize(path: str) -> str:
''' replace illegal metric name characters '''
result = re.sub(r'[./\s]|::', '_', path).replace('+', '_plus')
# Hyphens usually turn into underscores, unless they are
# trailing
if result.endswith("-"):
result = result[0:-1] + "_minus"
else:
result = result.replace("-", "_")
return "ceph_{0}".format(result)
def floatstr(value: float) -> str:
''' represent as Go-compatible float '''
if value == float('inf'):
return '+Inf'
if value == float('-inf'):
return '-Inf'
if math.isnan(value):
return 'NaN'
return repr(float(value))
name = promethize(self.name)
expfmt = '''
# HELP {name} {desc}
# TYPE {name} {mtype}'''.format(
name=name,
desc=self.desc,
mtype=self.mtype,
)
for labelvalues, value in self.value.items():
if self.labelnames:
labels_list = zip(self.labelnames, labelvalues)
labels = ','.join('%s="%s"' % (k, v) for k, v in labels_list)
else:
labels = ''
if labels:
fmtstr = '\n{name}{{{labels}}} {value}'
else:
fmtstr = '\n{name} {value}'
expfmt += fmtstr.format(
name=name,
labels=labels,
value=floatstr(value),
)
return expfmt
def group_by(
self,
keys: List[str],
joins: Dict[str, Callable[[List[str]], str]],
name: Optional[str] = None,
) -> "Metric":
"""
Groups data by label names.
Label names not passed are being removed from the resulting metric but
by providing a join function, labels of metrics can be grouped.
The purpose of this method is to provide a version of a metric that can
be used in matching where otherwise multiple results would be returned.
As grouping is possible in Prometheus, the only additional value of this
method is the possibility to join labels when grouping. For that reason,
passing joins is required. Please use PromQL expressions in all other
cases.
>>> m = Metric('type', 'name', '', labels=('label1', 'id'))
>>> m.value = {
... ('foo', 'x'): 1,
... ('foo', 'y'): 1,
... }
>>> m.group_by(['label1'], {'id': lambda ids: ','.join(ids)}).value
{('foo', 'x,y'): 1}
The functionality of group by could roughly be compared with Prometheus'
group (ceph_disk_occupation) by (device, instance)
with the exception that not all labels which aren't used as a condition
to group a metric are discarded, but their values can are joined and the
label is thereby preserved.
This function takes the value of the first entry of a found group to be
used for the resulting value of the grouping operation.
>>> m = Metric('type', 'name', '', labels=('label1', 'id'))
>>> m.value = {
... ('foo', 'x'): 555,
... ('foo', 'y'): 10,
... }
>>> m.group_by(['label1'], {'id': lambda ids: ','.join(ids)}).value
{('foo', 'x,y'): 555}
"""
assert self.labelnames, "cannot match keys without label names"
for key in keys:
assert key in self.labelnames, "unknown key: {}".format(key)
assert joins, "joins must not be empty"
assert all(callable(c) for c in joins.values()), "joins must be callable"
# group
grouped: Dict[LabelValues, List[Tuple[Dict[str, str], Number]]] = defaultdict(list)
for label_values, metric_value in self.value.items():
labels = dict(zip(self.labelnames, label_values))
if not all(k in labels for k in keys):
continue
group_key = tuple(labels[k] for k in keys)
grouped[group_key].append((labels, metric_value))
# as there is nothing specified on how to join labels that are not equal
# and Prometheus `group` aggregation functions similarly, we simply drop
# those labels.
labelnames = tuple(
label for label in self.labelnames if label in keys or label in joins
)
superfluous_labelnames = [
label for label in self.labelnames if label not in labelnames
]
# iterate and convert groups with more than one member into a single
# entry
values: MetricValue = {}
for group in grouped.values():
labels, metric_value = group[0]
for label in superfluous_labelnames:
del labels[label]
if len(group) > 1:
for key, fn in joins.items():
labels[key] = fn(list(labels[key] for labels, _ in group))
values[tuple(labels.values())] = metric_value
new_metric = Metric(self.mtype, name if name else self.name, self.desc, labelnames)
new_metric.value = values
return new_metric
class MetricCounter(Metric):
def __init__(self,
name: str,
desc: str,
labels: Optional[LabelValues] = None) -> None:
super(MetricCounter, self).__init__('counter', name, desc, labels)
self.value = defaultdict(lambda: 0)
def clear(self) -> None:
pass # Skip calls to clear as we want to keep the counters here.
def set(self,
value: Number,
labelvalues: Optional[LabelValues] = None) -> None:
msg = 'This method must not be used for instances of MetricCounter class'
raise NotImplementedError(msg)
def add(self,
value: Number,
labelvalues: Optional[LabelValues] = None) -> None:
# labelvalues must be a tuple
labelvalues = labelvalues or ('',)
self.value[labelvalues] += value
class MetricCollectionThread(threading.Thread):
def __init__(self, module: 'Module') -> None:
self.mod = module
self.active = True
self.event = threading.Event()
super(MetricCollectionThread, self).__init__(target=self.collect)
def collect(self) -> None:
self.mod.log.info('starting metric collection thread')
while self.active:
self.mod.log.debug('collecting cache in thread')
if self.mod.have_mon_connection():
start_time = time.time()
try:
data = self.mod.collect()
except Exception:
# Log any issues encountered during the data collection and continue
self.mod.log.exception("failed to collect metrics:")
self.event.wait(self.mod.scrape_interval)
continue
duration = time.time() - start_time
self.mod.log.debug('collecting cache in thread done')
sleep_time = self.mod.scrape_interval - duration
if sleep_time < 0:
self.mod.log.warning(
'Collecting data took more time than configured scrape interval. '
'This possibly results in stale data. Please check the '
'`stale_cache_strategy` configuration option. '
'Collecting data took {:.2f} seconds but scrape interval is configured '
'to be {:.0f} seconds.'.format(
duration,
self.mod.scrape_interval,
)
)
sleep_time = 0
with self.mod.collect_lock:
self.mod.collect_cache = data
self.mod.collect_time = duration
self.event.wait(sleep_time)
else:
self.mod.log.error('No MON connection')
self.event.wait(self.mod.scrape_interval)
def stop(self) -> None:
self.active = False
self.event.set()
class Module(MgrModule):
MODULE_OPTIONS = [
Option(
'server_addr'
),
Option(
'server_port',
type='int',
default=DEFAULT_PORT,
desc='the port on which the module listens for HTTP requests',
runtime=True
),
Option(
'scrape_interval',
type='float',
default=15.0
),
Option(
'stale_cache_strategy',
default='log'
),
Option(
'cache',
type='bool',
default=True,
),
Option(
'rbd_stats_pools',
default=''
),
Option(
name='rbd_stats_pools_refresh_interval',
type='int',
default=300
),
Option(
name='standby_behaviour',
type='str',
default='default',
enum_allowed=['default', 'error'],
runtime=True
),
Option(
name='standby_error_status_code',
type='int',
default=500,
min=400,
max=599,
runtime=True
)
]
STALE_CACHE_FAIL = 'fail'
STALE_CACHE_RETURN = 'return'
def __init__(self, *args: Any, **kwargs: Any) -> None:
super(Module, self).__init__(*args, **kwargs)
self.metrics = self._setup_static_metrics()
self.shutdown_event = threading.Event()
self.collect_lock = threading.Lock()
self.collect_time = 0.0
self.scrape_interval: float = 15.0
self.cache = True
self.stale_cache_strategy: str = self.STALE_CACHE_FAIL
self.collect_cache: Optional[str] = None
self.rbd_stats = {
'pools': {},
'pools_refresh_time': 0,
'counters_info': {
'write_ops': {'type': self.PERFCOUNTER_COUNTER,
'desc': 'RBD image writes count'},
'read_ops': {'type': self.PERFCOUNTER_COUNTER,
'desc': 'RBD image reads count'},
'write_bytes': {'type': self.PERFCOUNTER_COUNTER,
'desc': 'RBD image bytes written'},
'read_bytes': {'type': self.PERFCOUNTER_COUNTER,
'desc': 'RBD image bytes read'},
'write_latency': {'type': self.PERFCOUNTER_LONGRUNAVG,
'desc': 'RBD image writes latency (msec)'},
'read_latency': {'type': self.PERFCOUNTER_LONGRUNAVG,
'desc': 'RBD image reads latency (msec)'},
},
} # type: Dict[str, Any]
global _global_instance
_global_instance = self
self.metrics_thread = MetricCollectionThread(_global_instance)
self.health_history = HealthHistory(self)
def _setup_static_metrics(self) -> Dict[str, Metric]:
metrics = {}
metrics['health_status'] = Metric(
'untyped',
'health_status',
'Cluster health status'
)
metrics['mon_quorum_status'] = Metric(
'gauge',
'mon_quorum_status',
'Monitors in quorum',
('ceph_daemon',)
)
metrics['fs_metadata'] = Metric(
'untyped',
'fs_metadata',
'FS Metadata',
FS_METADATA
)
metrics['mds_metadata'] = Metric(
'untyped',
'mds_metadata',
'MDS Metadata',
MDS_METADATA
)
metrics['mon_metadata'] = Metric(
'untyped',
'mon_metadata',
'MON Metadata',
MON_METADATA
)
metrics['mgr_metadata'] = Metric(
'gauge',
'mgr_metadata',
'MGR metadata',
MGR_METADATA
)
metrics['mgr_status'] = Metric(
'gauge',
'mgr_status',
'MGR status (0=standby, 1=active)',
MGR_STATUS
)
metrics['mgr_module_status'] = Metric(
'gauge',
'mgr_module_status',
'MGR module status (0=disabled, 1=enabled, 2=auto-enabled)',
MGR_MODULE_STATUS
)
metrics['mgr_module_can_run'] = Metric(
'gauge',
'mgr_module_can_run',
'MGR module runnable state i.e. can it run (0=no, 1=yes)',
MGR_MODULE_CAN_RUN
)
metrics['osd_metadata'] = Metric(
'untyped',
'osd_metadata',
'OSD Metadata',
OSD_METADATA
)
# The reason for having this separate to OSD_METADATA is
# so that we can stably use the same tag names that
# the Prometheus node_exporter does
metrics['disk_occupation'] = Metric(
'untyped',
'disk_occupation',
'Associate Ceph daemon with disk used',
DISK_OCCUPATION
)
metrics['disk_occupation_human'] = Metric(
'untyped',
'disk_occupation_human',
'Associate Ceph daemon with disk used for displaying to humans,'
' not for joining tables (vector matching)',
DISK_OCCUPATION, # label names are automatically decimated on grouping
)
metrics['pool_metadata'] = Metric(
'untyped',
'pool_metadata',
'POOL Metadata',
POOL_METADATA
)
metrics['rgw_metadata'] = Metric(
'untyped',
'rgw_metadata',
'RGW Metadata',
RGW_METADATA
)
metrics['rbd_mirror_metadata'] = Metric(
'untyped',
'rbd_mirror_metadata',
'RBD Mirror Metadata',
RBD_MIRROR_METADATA
)
metrics['pg_total'] = Metric(
'gauge',
'pg_total',
'PG Total Count per Pool',
('pool_id',)
)
metrics['health_detail'] = Metric(
'gauge',
'health_detail',
'healthcheck status by type (0=inactive, 1=active)',
HEALTHCHECK_DETAIL
)
for flag in OSD_FLAGS:
path = 'osd_flag_{}'.format(flag)
metrics[path] = Metric(
'untyped',
path,
'OSD Flag {}'.format(flag)
)
for state in OSD_STATUS:
path = 'osd_{}'.format(state)
metrics[path] = Metric(
'untyped',
path,
'OSD status {}'.format(state),
('ceph_daemon',)
)
for stat in OSD_STATS:
path = 'osd_{}'.format(stat)
metrics[path] = Metric(
'gauge',
path,
'OSD stat {}'.format(stat),
('ceph_daemon',)
)
for stat in OSD_POOL_STATS:
path = 'pool_{}'.format(stat)
metrics[path] = Metric(
'gauge',
path,
"OSD pool stats: {}".format(stat),
('pool_id',)
)
for state in PG_STATES:
path = 'pg_{}'.format(state)
metrics[path] = Metric(
'gauge',
path,
'PG {} per pool'.format(state),
('pool_id',)
)
for state in DF_CLUSTER:
path = 'cluster_{}'.format(state)
metrics[path] = Metric(
'gauge',
path,
'DF {}'.format(state),
)
for state in DF_POOL:
path = 'pool_{}'.format(state)
metrics[path] = Metric(
'counter' if state in ('rd', 'rd_bytes', 'wr', 'wr_bytes') else 'gauge',
path,
'DF pool {}'.format(state),
('pool_id',)
)
for state in NUM_OBJECTS:
path = 'num_objects_{}'.format(state)
metrics[path] = Metric(
'gauge',
path,
'Number of {} objects'.format(state),
)
for check in HEALTH_CHECKS:
path = 'healthcheck_{}'.format(check.name.lower())
metrics[path] = Metric(
'gauge',
path,
check.description,
)
return metrics
def get_server_addr(self) -> str:
"""
Return the current mgr server IP.
"""
server_addr = cast(str, self.get_localized_module_option('server_addr', get_default_addr()))
if server_addr in ['::', '0.0.0.0']:
return self.get_mgr_ip()
return server_addr
def config_notify(self) -> None:
"""
This method is called whenever one of our config options is changed.
"""
# https://stackoverflow.com/questions/7254845/change-cherrypy-port-and-restart-web-server
# if we omit the line: cherrypy.server.httpserver = None
# then the cherrypy server is not restarted correctly
self.log.info('Restarting engine...')
cherrypy.engine.stop()
cherrypy.server.httpserver = None
server_port = cast(int, self.get_localized_module_option('server_port', DEFAULT_PORT))
self.set_uri(build_url(scheme='http', host=self.get_server_addr(), port=server_port, path='/'))
cherrypy.config.update({'server.socket_port': server_port})
cherrypy.engine.start()
self.log.info('Engine started.')
@profile_method()
def get_health(self) -> None:
def _get_value(message: str, delim: str = ' ', word_pos: int = 0) -> Tuple[int, int]:
"""Extract value from message (default is 1st field)"""
v_str = message.split(delim)[word_pos]
if v_str.isdigit():
return int(v_str), 0
return 0, 1
health = json.loads(self.get('health')['json'])
# set overall health
self.metrics['health_status'].set(
health_status_to_number(health['status'])
)
# Examine the health to see if any health checks triggered need to
# become a specific metric with a value from the health detail
active_healthchecks = health.get('checks', {})
active_names = active_healthchecks.keys()
for check in HEALTH_CHECKS:
path = 'healthcheck_{}'.format(check.name.lower())
if path in self.metrics:
if check.name in active_names:
check_data = active_healthchecks[check.name]
message = check_data['summary'].get('message', '')
v, err = 0, 0
if check.name == "SLOW_OPS":
# 42 slow ops, oldest one blocked for 12 sec, daemons [osd.0, osd.3] have
# slow ops.
v, err = _get_value(message)
if err:
self.log.error(
"healthcheck %s message format is incompatible and has been dropped",
check.name)
# drop the metric, so it's no longer emitted
del self.metrics[path]
continue
else:
self.metrics[path].set(v)
else:
# health check is not active, so give it a default of 0
self.metrics[path].set(0)
self.health_history.check(health)
for name, info in self.health_history.healthcheck.items():
v = 1 if info.active else 0
self.metrics['health_detail'].set(
v, (
name,
str(info.severity))
)
@profile_method()
def get_pool_stats(self) -> None:
# retrieve pool stats to provide per pool recovery metrics
# (osd_pool_stats moved to mgr in Mimic)
pstats = self.get('osd_pool_stats')
for pool in pstats['pool_stats']:
for stat in OSD_POOL_STATS:
self.metrics['pool_{}'.format(stat)].set(
pool['recovery_rate'].get(stat, 0),
(pool['pool_id'],)
)
@profile_method()
def get_df(self) -> None:
# maybe get the to-be-exported metrics from a config?
df = self.get('df')
for stat in DF_CLUSTER:
self.metrics['cluster_{}'.format(stat)].set(df['stats'][stat])
for pool in df['pools']:
for stat in DF_POOL:
self.metrics['pool_{}'.format(stat)].set(
pool['stats'][stat],
(pool['id'],)
)
@profile_method()
def get_fs(self) -> None:
fs_map = self.get('fs_map')
servers = self.get_service_list()
self.log.debug('standbys: {}'.format(fs_map['standbys']))
# export standby mds metadata, default standby fs_id is '-1'
for standby in fs_map['standbys']:
id_ = standby['name']
host, version, _ = servers.get((id_, 'mds'), ('', '', ''))
addr, rank = standby['addr'], standby['rank']
self.metrics['mds_metadata'].set(1, (
'mds.{}'.format(id_), '-1',
cast(str, host),
cast(str, addr),
cast(str, rank),
cast(str, version)
))
for fs in fs_map['filesystems']:
# collect fs metadata
data_pools = ",".join([str(pool)
for pool in fs['mdsmap']['data_pools']])
self.metrics['fs_metadata'].set(1, (
data_pools,
fs['id'],
fs['mdsmap']['metadata_pool'],
fs['mdsmap']['fs_name']
))
self.log.debug('mdsmap: {}'.format(fs['mdsmap']))
for gid, daemon in fs['mdsmap']['info'].items():
id_ = daemon['name']
host, version, _ = servers.get((id_, 'mds'), ('', '', ''))
self.metrics['mds_metadata'].set(1, (
'mds.{}'.format(id_), fs['id'],
host, daemon['addr'],
daemon['rank'], version
))
@profile_method()
def get_quorum_status(self) -> None:
mon_status = json.loads(self.get('mon_status')['json'])
servers = self.get_service_list()
for mon in mon_status['monmap']['mons']:
rank = mon['rank']
id_ = mon['name']
mon_version = servers.get((id_, 'mon'), ('', '', ''))
self.metrics['mon_metadata'].set(1, (
'mon.{}'.format(id_), mon_version[0],
mon['public_addr'].rsplit(':', 1)[0], rank,
mon_version[1]
))
in_quorum = int(rank in mon_status['quorum'])
self.metrics['mon_quorum_status'].set(in_quorum, (
'mon.{}'.format(id_),
))
@profile_method()
def get_mgr_status(self) -> None:
mgr_map = self.get('mgr_map')
servers = self.get_service_list()
active = mgr_map['active_name']
standbys = [s.get('name') for s in mgr_map['standbys']]
all_mgrs = list(standbys)
all_mgrs.append(active)
all_modules = {module.get('name'): module.get('can_run')
for module in mgr_map['available_modules']}
for mgr in all_mgrs:
host, version, _ = servers.get((mgr, 'mgr'), ('', '', ''))
if mgr == active:
_state = 1
else:
_state = 0
self.metrics['mgr_metadata'].set(1, (
f'mgr.{mgr}', host, version
))
self.metrics['mgr_status'].set(_state, (
f'mgr.{mgr}',))
always_on_modules = mgr_map['always_on_modules'].get(self.release_name, [])
active_modules = list(always_on_modules)
active_modules.extend(mgr_map['modules'])
for mod_name in all_modules.keys():
if mod_name in always_on_modules:
_state = 2
elif mod_name in active_modules:
_state = 1
else:
_state = 0
_can_run = 1 if all_modules[mod_name] else 0
self.metrics['mgr_module_status'].set(_state, (mod_name,))
self.metrics['mgr_module_can_run'].set(_can_run, (mod_name,))
@profile_method()
def get_pg_status(self) -> None:
pg_summary = self.get('pg_summary')
for pool in pg_summary['by_pool']:
num_by_state: DefaultDict[str, int] = defaultdict(int)
for state_name, count in pg_summary['by_pool'][pool].items():
for state in state_name.split('+'):
num_by_state[state] += count
num_by_state['total'] += count
for state, num in num_by_state.items():
try:
self.metrics["pg_{}".format(state)].set(num, (pool,))
except KeyError:
self.log.warning("skipping pg in unknown state {}".format(state))
@profile_method()
def get_osd_stats(self) -> None:
osd_stats = self.get('osd_stats')
for osd in osd_stats['osd_stats']:
id_ = osd['osd']
for stat in OSD_STATS:
val = osd['perf_stat'][stat]
self.metrics['osd_{}'.format(stat)].set(val, (
'osd.{}'.format(id_),
))
def get_service_list(self) -> Dict[Tuple[str, str], Tuple[str, str, str]]:
ret = {}
for server in self.list_servers():
host = cast(str, server.get('hostname', ''))
for service in cast(List[ServiceInfoT], server.get('services', [])):
ret.update({(service['id'], service['type']): (host, service['ceph_version'], service.get('name', ''))})
return ret
@profile_method()
def get_metadata_and_osd_status(self) -> None:
osd_map = self.get('osd_map')
osd_flags = osd_map['flags'].split(',')
for flag in OSD_FLAGS:
self.metrics['osd_flag_{}'.format(flag)].set(
int(flag in osd_flags)
)
osd_devices = self.get('osd_map_crush')['devices']
servers = self.get_service_list()
for osd in osd_map['osds']:
# id can be used to link osd metrics and metadata
id_ = osd['osd']
# collect osd metadata
p_addr = osd['public_addr'].rsplit(':', 1)[0]
c_addr = osd['cluster_addr'].rsplit(':', 1)[0]
if p_addr == "-" or c_addr == "-":
self.log.info(
"Missing address metadata for osd {0}, skipping occupation"
" and metadata records for this osd".format(id_)
)
continue
dev_class = None
for osd_device in osd_devices:
if osd_device['id'] == id_:
dev_class = osd_device.get('class', '')
break
if dev_class is None:
self.log.info("OSD {0} is missing from CRUSH map, "
"skipping output".format(id_))
continue
osd_version = servers.get((str(id_), 'osd'), ('', '', ''))
# collect disk occupation metadata
osd_metadata = self.get_metadata("osd", str(id_))
if osd_metadata is None:
continue
obj_store = osd_metadata.get('osd_objectstore', '')
f_iface = osd_metadata.get('front_iface', '')
b_iface = osd_metadata.get('back_iface', '')
self.metrics['osd_metadata'].set(1, (
b_iface,
'osd.{}'.format(id_),
c_addr,
dev_class,
f_iface,
osd_version[0],
obj_store,
p_addr,
osd_version[1]
))
# collect osd status
for state in OSD_STATUS:
status = osd[state]
self.metrics['osd_{}'.format(state)].set(status, (
'osd.{}'.format(id_),
))
osd_dev_node = None
osd_wal_dev_node = ''
osd_db_dev_node = ''
if obj_store == "filestore":
# collect filestore backend device
osd_dev_node = osd_metadata.get(
'backend_filestore_dev_node', None)
# collect filestore journal device
osd_wal_dev_node = osd_metadata.get('osd_journal', '')
osd_db_dev_node = ''
elif obj_store == "bluestore":
# collect bluestore backend device
osd_dev_node = osd_metadata.get(
'bluestore_bdev_dev_node', None)
# collect bluestore wal backend
osd_wal_dev_node = osd_metadata.get('bluefs_wal_dev_node', '')
# collect bluestore db backend
osd_db_dev_node = osd_metadata.get('bluefs_db_dev_node', '')
if osd_dev_node and osd_dev_node == "unknown":
osd_dev_node = None
# fetch the devices and ids (vendor, model, serial) from the
# osd_metadata
osd_devs = osd_metadata.get('devices', '') or 'N/A'
osd_dev_ids = osd_metadata.get('device_ids', '') or 'N/A'
osd_hostname = osd_metadata.get('hostname', None)
if osd_dev_node and osd_hostname:
self.log.debug("Got dev for osd {0}: {1}/{2}".format(
id_, osd_hostname, osd_dev_node))
self.metrics['disk_occupation'].set(1, (
"osd.{0}".format(id_),
osd_dev_node,
osd_db_dev_node,
osd_wal_dev_node,
osd_hostname,
osd_devs,
osd_dev_ids,
))
else:
self.log.info("Missing dev node metadata for osd {0}, skipping "
"occupation record for this osd".format(id_))
if 'disk_occupation' in self.metrics:
try:
self.metrics['disk_occupation_human'] = \
self.metrics['disk_occupation'].group_by(
['device', 'instance'],
{'ceph_daemon': lambda daemons: ', '.join(daemons)},
name='disk_occupation_human',
)
except Exception as e:
self.log.error(e)
ec_profiles = osd_map.get('erasure_code_profiles', {})
def _get_pool_info(pool: Dict[str, Any]) -> Tuple[str, str]:
pool_type = 'unknown'
description = 'unknown'
if pool['type'] == 1:
pool_type = "replicated"
description = f"replica:{pool['size']}"
elif pool['type'] == 3:
pool_type = "erasure"
name = pool.get('erasure_code_profile', '')
profile = ec_profiles.get(name, {})
if profile:
description = f"ec:{profile['k']}+{profile['m']}"
else:
description = "ec:unknown"
return pool_type, description
for pool in osd_map['pools']:
compression_mode = 'none'
pool_type, pool_description = _get_pool_info(pool)
if 'options' in pool:
compression_mode = pool['options'].get('compression_mode', 'none')
self.metrics['pool_metadata'].set(
1, (
pool['pool'],
pool['pool_name'],
pool_type,
pool_description,
compression_mode)
)
# Populate other servers metadata
for key, value in servers.items():
service_id, service_type = key
if service_type == 'rgw':
hostname, version, name = value
self.metrics['rgw_metadata'].set(
1,
('{}.{}'.format(service_type, name),
hostname, version, service_id)
)
elif service_type == 'rbd-mirror':
mirror_metadata = self.get_metadata('rbd-mirror', service_id)
if mirror_metadata is None:
continue
mirror_metadata['ceph_daemon'] = '{}.{}'.format(service_type,
service_id)
rbd_mirror_metadata = cast(LabelValues,
(mirror_metadata.get(k, '')
for k in RBD_MIRROR_METADATA))
self.metrics['rbd_mirror_metadata'].set(
1, rbd_mirror_metadata
)
@profile_method()
def get_num_objects(self) -> None:
pg_sum = self.get('pg_summary')['pg_stats_sum']['stat_sum']
for obj in NUM_OBJECTS:
stat = 'num_objects_{}'.format(obj)
self.metrics[stat].set(pg_sum[stat])
@profile_method()
def get_rbd_stats(self) -> None:
# Per RBD image stats is collected by registering a dynamic osd perf
# stats query that tells OSDs to group stats for requests associated
# with RBD objects by pool, namespace, and image id, which are
# extracted from the request object names or other attributes.
# The RBD object names have the following prefixes:
# - rbd_data.{image_id}. (data stored in the same pool as metadata)
# - rbd_data.{pool_id}.{image_id}. (data stored in a dedicated data pool)
# - journal_data.{pool_id}.{image_id}. (journal if journaling is enabled)
# The pool_id in the object name is the id of the pool with the image
# metdata, and should be used in the image spec. If there is no pool_id
# in the object name, the image pool is the pool where the object is
# located.
# Parse rbd_stats_pools option, which is a comma or space separated
# list of pool[/namespace] entries. If no namespace is specifed the
# stats are collected for every namespace in the pool. The wildcard
# '*' can be used to indicate all pools or namespaces
pools_string = cast(str, self.get_localized_module_option('rbd_stats_pools'))
pool_keys = []
for x in re.split(r'[\s,]+', pools_string):
if not x:
continue
s = x.split('/', 2)
pool_name = s[0]
namespace_name = None
if len(s) == 2:
namespace_name = s[1]
if pool_name == "*":
# collect for all pools
osd_map = self.get('osd_map')
for pool in osd_map['pools']:
if 'rbd' not in pool.get('application_metadata', {}):
continue
pool_keys.append((pool['pool_name'], namespace_name))
else:
pool_keys.append((pool_name, namespace_name))
pools = {} # type: Dict[str, Set[str]]
for pool_key in pool_keys:
pool_name = pool_key[0]
namespace_name = pool_key[1]
if not namespace_name or namespace_name == "*":
# empty set means collect for all namespaces
pools[pool_name] = set()
continue
if pool_name not in pools:
pools[pool_name] = set()
elif not pools[pool_name]:
continue
pools[pool_name].add(namespace_name)
rbd_stats_pools = {}
for pool_id in self.rbd_stats['pools'].keys():
name = self.rbd_stats['pools'][pool_id]['name']
if name not in pools:
del self.rbd_stats['pools'][pool_id]
else:
rbd_stats_pools[name] = \
self.rbd_stats['pools'][pool_id]['ns_names']
pools_refreshed = False
if pools:
next_refresh = self.rbd_stats['pools_refresh_time'] + \
self.get_localized_module_option(
'rbd_stats_pools_refresh_interval', 300)
if rbd_stats_pools != pools or time.time() >= next_refresh:
self.refresh_rbd_stats_pools(pools)
pools_refreshed = True
pool_ids = list(self.rbd_stats['pools'])
pool_ids.sort()
pool_id_regex = '^(' + '|'.join([str(x) for x in pool_ids]) + ')$'
nspace_names = []
for pool_id, pool in self.rbd_stats['pools'].items():
if pool['ns_names']:
nspace_names.extend(pool['ns_names'])
else:
nspace_names = []
break
if nspace_names:
namespace_regex = '^(' + \
"|".join([re.escape(x)
for x in set(nspace_names)]) + ')$'
else:
namespace_regex = '^(.*)$'
if ('query' in self.rbd_stats
and (pool_id_regex != self.rbd_stats['query']['key_descriptor'][0]['regex']
or namespace_regex != self.rbd_stats['query']['key_descriptor'][1]['regex'])):
self.remove_osd_perf_query(self.rbd_stats['query_id'])
del self.rbd_stats['query_id']
del self.rbd_stats['query']
if not self.rbd_stats['pools']:
return
counters_info = self.rbd_stats['counters_info']
if 'query_id' not in self.rbd_stats:
query = {
'key_descriptor': [
{'type': 'pool_id', 'regex': pool_id_regex},
{'type': 'namespace', 'regex': namespace_regex},
{'type': 'object_name',
'regex': r'^(?:rbd|journal)_data\.(?:([0-9]+)\.)?([^.]+)\.'},
],
'performance_counter_descriptors': list(counters_info),
}
query_id = self.add_osd_perf_query(query)
if query_id is None:
self.log.error('failed to add query %s' % query)
return
self.rbd_stats['query'] = query
self.rbd_stats['query_id'] = query_id
res = self.get_osd_perf_counters(self.rbd_stats['query_id'])
assert res
for c in res['counters']:
# if the pool id is not found in the object name use id of the
# pool where the object is located
if c['k'][2][0]:
pool_id = int(c['k'][2][0])
else:
pool_id = int(c['k'][0][0])
if pool_id not in self.rbd_stats['pools'] and not pools_refreshed:
self.refresh_rbd_stats_pools(pools)
pools_refreshed = True
if pool_id not in self.rbd_stats['pools']:
continue
pool = self.rbd_stats['pools'][pool_id]
nspace_name = c['k'][1][0]
if nspace_name not in pool['images']:
continue
image_id = c['k'][2][1]
if image_id not in pool['images'][nspace_name] and \
not pools_refreshed:
self.refresh_rbd_stats_pools(pools)
pool = self.rbd_stats['pools'][pool_id]
pools_refreshed = True
if image_id not in pool['images'][nspace_name]:
continue
counters = pool['images'][nspace_name][image_id]['c']
for i in range(len(c['c'])):
counters[i][0] += c['c'][i][0]
counters[i][1] += c['c'][i][1]
label_names = ("pool", "namespace", "image")
for pool_id, pool in self.rbd_stats['pools'].items():
pool_name = pool['name']
for nspace_name, images in pool['images'].items():
for image_id in images:
image_name = images[image_id]['n']
counters = images[image_id]['c']
i = 0
for key in counters_info:
counter_info = counters_info[key]
stattype = self._stattype_to_str(counter_info['type'])
labels = (pool_name, nspace_name, image_name)
if counter_info['type'] == self.PERFCOUNTER_COUNTER:
path = 'rbd_' + key
if path not in self.metrics:
self.metrics[path] = Metric(
stattype,
path,
counter_info['desc'],
label_names,
)
self.metrics[path].set(counters[i][0], labels)
elif counter_info['type'] == self.PERFCOUNTER_LONGRUNAVG:
path = 'rbd_' + key + '_sum'
if path not in self.metrics:
self.metrics[path] = Metric(
stattype,
path,
counter_info['desc'] + ' Total',
label_names,
)
self.metrics[path].set(counters[i][0], labels)
path = 'rbd_' + key + '_count'
if path not in self.metrics:
self.metrics[path] = Metric(
'counter',
path,
counter_info['desc'] + ' Count',
label_names,
)
self.metrics[path].set(counters[i][1], labels)
i += 1
def refresh_rbd_stats_pools(self, pools: Dict[str, Set[str]]) -> None:
self.log.debug('refreshing rbd pools %s' % (pools))
rbd = RBD()
counters_info = self.rbd_stats['counters_info']
for pool_name, cfg_ns_names in pools.items():
try:
pool_id = self.rados.pool_lookup(pool_name)
with self.rados.open_ioctx(pool_name) as ioctx:
if pool_id not in self.rbd_stats['pools']:
self.rbd_stats['pools'][pool_id] = {'images': {}}
pool = self.rbd_stats['pools'][pool_id]
pool['name'] = pool_name
pool['ns_names'] = cfg_ns_names
if cfg_ns_names:
nspace_names = list(cfg_ns_names)
else:
nspace_names = [''] + rbd.namespace_list(ioctx)
for nspace_name in pool['images']:
if nspace_name not in nspace_names:
del pool['images'][nspace_name]
for nspace_name in nspace_names:
if nspace_name and\
not rbd.namespace_exists(ioctx, nspace_name):
self.log.debug('unknown namespace %s for pool %s' %
(nspace_name, pool_name))
continue
ioctx.set_namespace(nspace_name)
if nspace_name not in pool['images']:
pool['images'][nspace_name] = {}
namespace = pool['images'][nspace_name]
images = {}
for image_meta in RBD().list2(ioctx):
image = {'n': image_meta['name']}
image_id = image_meta['id']
if image_id in namespace:
image['c'] = namespace[image_id]['c']
else:
image['c'] = [[0, 0] for x in counters_info]
images[image_id] = image
pool['images'][nspace_name] = images
except Exception as e:
self.log.error('failed listing pool %s: %s' % (pool_name, e))
self.rbd_stats['pools_refresh_time'] = time.time()
def shutdown_rbd_stats(self) -> None:
if 'query_id' in self.rbd_stats:
self.remove_osd_perf_query(self.rbd_stats['query_id'])
del self.rbd_stats['query_id']
del self.rbd_stats['query']
self.rbd_stats['pools'].clear()
def add_fixed_name_metrics(self) -> None:
"""
Add fixed name metrics from existing ones that have details in their names
that should be in labels (not in name).
For backward compatibility, a new fixed name metric is created (instead of replacing)
and details are put in new labels.
Intended for RGW sync perf. counters but extendable as required.
See: https://tracker.ceph.com/issues/45311
"""
new_metrics = {}
for metric_path, metrics in self.metrics.items():
# Address RGW sync perf. counters.
match = re.search(r'^data-sync-from-(.*)\.', metric_path)
if match:
new_path = re.sub('from-([^.]*)', 'from-zone', metric_path)
if new_path not in new_metrics:
new_metrics[new_path] = Metric(
metrics.mtype,
new_path,
metrics.desc,
cast(LabelValues, metrics.labelnames) + ('source_zone',)
)
for label_values, value in metrics.value.items():
new_metrics[new_path].set(value, label_values + (match.group(1),))
self.metrics.update(new_metrics)
def get_collect_time_metrics(self) -> None:
sum_metric = self.metrics.get('prometheus_collect_duration_seconds_sum')
count_metric = self.metrics.get('prometheus_collect_duration_seconds_count')
if sum_metric is None:
sum_metric = MetricCounter(
'prometheus_collect_duration_seconds_sum',
'The sum of seconds took to collect all metrics of this exporter',
('method',))
self.metrics['prometheus_collect_duration_seconds_sum'] = sum_metric
if count_metric is None:
count_metric = MetricCounter(
'prometheus_collect_duration_seconds_count',
'The amount of metrics gathered for this exporter',
('method',))
self.metrics['prometheus_collect_duration_seconds_count'] = count_metric
# Collect all timing data and make it available as metric, excluding the
# `collect` method because it has not finished at this point and hence
# there's no `_execution_duration` attribute to be found. The
# `_execution_duration` attribute is added by the `profile_method`
# decorator.
for method_name, method in Module.__dict__.items():
duration = getattr(method, '_execution_duration', None)
if duration is not None:
cast(MetricCounter, sum_metric).add(duration, (method_name,))
cast(MetricCounter, count_metric).add(1, (method_name,))
def get_pg_repaired_objects(self) -> None:
dump = self.get('pg_dump')
for stats in dump['pool_stats']:
path = f'pg_objects_repaired{stats["poolid"]}'
self.metrics[path] = Metric(
'counter',
'pg_objects_repaired',
'Number of objects repaired in a pool Count',
('poolid',)
)
self.metrics[path].set(stats['stat_sum']['num_objects_repaired'],
labelvalues=(stats['poolid'],))
@profile_method(True)
def collect(self) -> str:
# Clear the metrics before scraping
for k in self.metrics.keys():
self.metrics[k].clear()
self.get_health()
self.get_df()
self.get_pool_stats()
self.get_fs()
self.get_osd_stats()
self.get_quorum_status()
self.get_mgr_status()
self.get_metadata_and_osd_status()
self.get_pg_status()
self.get_pg_repaired_objects()
self.get_num_objects()
for daemon, counters in self.get_all_perf_counters().items():
for path, counter_info in counters.items():
# Skip histograms, they are represented by long running avgs
stattype = self._stattype_to_str(counter_info['type'])
if not stattype or stattype == 'histogram':
self.log.debug('ignoring %s, type %s' % (path, stattype))
continue
path, label_names, labels = self._perfpath_to_path_labels(
daemon, path)
# Get the value of the counter
value = self._perfvalue_to_value(
counter_info['type'], counter_info['value'])
# Represent the long running avgs as sum/count pairs
if counter_info['type'] & self.PERFCOUNTER_LONGRUNAVG:
_path = path + '_sum'
if _path not in self.metrics:
self.metrics[_path] = Metric(
stattype,
_path,
counter_info['description'] + ' Total',
label_names,
)
self.metrics[_path].set(value, labels)
_path = path + '_count'
if _path not in self.metrics:
self.metrics[_path] = Metric(
'counter',
_path,
counter_info['description'] + ' Count',
label_names,
)
self.metrics[_path].set(counter_info['count'], labels,)
else:
if path not in self.metrics:
self.metrics[path] = Metric(
stattype,
path,
counter_info['description'],
label_names,
)
self.metrics[path].set(value, labels)
self.add_fixed_name_metrics()
self.get_rbd_stats()
self.get_collect_time_metrics()
# Return formatted metrics and clear no longer used data
_metrics = [m.str_expfmt() for m in self.metrics.values()]
for k in self.metrics.keys():
self.metrics[k].clear()
return ''.join(_metrics) + '\n'
@CLIReadCommand('prometheus file_sd_config')
def get_file_sd_config(self) -> Tuple[int, str, str]:
'''
Return file_sd compatible prometheus config for mgr cluster
'''
servers = self.list_servers()
targets = []
for server in servers:
hostname = server.get('hostname', '')
for service in cast(List[ServiceInfoT], server.get('services', [])):
if service['type'] != 'mgr':
continue
id_ = service['id']
port = self._get_module_option('server_port', DEFAULT_PORT, id_)
targets.append(f'{hostname}:{port}')
ret = [
{
"targets": targets,
"labels": {}
}
]
return 0, json.dumps(ret), ""
def self_test(self) -> None:
self.collect()
self.get_file_sd_config()
def serve(self) -> None:
class Root(object):
# collapse everything to '/'
def _cp_dispatch(self, vpath: str) -> 'Root':
cherrypy.request.path = ''
return self
@cherrypy.expose
def index(self) -> str:
return '''
Ceph Exporter
Ceph Exporter
Metrics
'''
@cherrypy.expose
def metrics(self) -> Optional[str]:
# Lock the function execution
assert isinstance(_global_instance, Module)
with _global_instance.collect_lock:
return self._metrics(_global_instance)
@staticmethod
def _metrics(instance: 'Module') -> Optional[str]:
if not self.cache:
self.log.debug('Cache disabled, collecting and returning without cache')
cherrypy.response.headers['Content-Type'] = 'text/plain'
return self.collect()
# Return cached data if available
if not instance.collect_cache:
raise cherrypy.HTTPError(503, 'No cached data available yet')
def respond() -> Optional[str]:
assert isinstance(instance, Module)
cherrypy.response.headers['Content-Type'] = 'text/plain'
return instance.collect_cache
if instance.collect_time < instance.scrape_interval:
# Respond if cache isn't stale
return respond()
if instance.stale_cache_strategy == instance.STALE_CACHE_RETURN:
# Respond even if cache is stale
instance.log.info(
'Gathering data took {:.2f} seconds, metrics are stale for {:.2f} seconds, '
'returning metrics from stale cache.'.format(
instance.collect_time,
instance.collect_time - instance.scrape_interval
)
)
return respond()
if instance.stale_cache_strategy == instance.STALE_CACHE_FAIL:
# Fail if cache is stale
msg = (
'Gathering data took {:.2f} seconds, metrics are stale for {:.2f} seconds, '
'returning "service unavailable".'.format(
instance.collect_time,
instance.collect_time - instance.scrape_interval,
)
)
instance.log.error(msg)
raise cherrypy.HTTPError(503, msg)
return None
# Make the cache timeout for collecting configurable
self.scrape_interval = cast(float, self.get_localized_module_option('scrape_interval'))
self.stale_cache_strategy = cast(
str, self.get_localized_module_option('stale_cache_strategy'))
if self.stale_cache_strategy not in [self.STALE_CACHE_FAIL,
self.STALE_CACHE_RETURN]:
self.stale_cache_strategy = self.STALE_CACHE_FAIL
server_addr = cast(str, self.get_localized_module_option(
'server_addr', get_default_addr()))
server_port = cast(int, self.get_localized_module_option(
'server_port', DEFAULT_PORT))
self.log.info(
"server_addr: %s server_port: %s" %
(server_addr, server_port)
)
self.cache = cast(bool, self.get_localized_module_option('cache', True))
if self.cache:
self.log.info('Cache enabled')
self.metrics_thread.start()
else:
self.log.info('Cache disabled')
cherrypy.config.update({
'server.socket_host': server_addr,
'server.socket_port': server_port,
'engine.autoreload.on': False
})
# Publish the URI that others may use to access the service we're
# about to start serving
self.set_uri(build_url(scheme='http', host=self.get_server_addr(), port=server_port, path='/'))
cherrypy.tree.mount(Root(), "/")
self.log.info('Starting engine...')
cherrypy.engine.start()
self.log.info('Engine started.')
# wait for the shutdown event
self.shutdown_event.wait()
self.shutdown_event.clear()
# tell metrics collection thread to stop collecting new metrics
self.metrics_thread.stop()
cherrypy.engine.stop()
cherrypy.server.httpserver = None
self.log.info('Engine stopped.')
self.shutdown_rbd_stats()
# wait for the metrics collection thread to stop
self.metrics_thread.join()
def shutdown(self) -> None:
self.log.info('Stopping engine...')
self.shutdown_event.set()
@CLIReadCommand('healthcheck history ls')
def _list_healthchecks(self, format: Format = Format.plain) -> HandleCommandResult:
"""List all the healthchecks being tracked
The format options are parsed in ceph_argparse, before they get evaluated here so
we can safely assume that what we have to process is valid. ceph_argparse will throw
a ValueError if the cast to our Format class fails.
Args:
format (Format, optional): output format. Defaults to Format.plain.
Returns:
HandleCommandResult: return code, stdout and stderr returned to the caller
"""
out = ""
if format == Format.plain:
out = str(self.health_history)
elif format == Format.yaml:
out = self.health_history.as_yaml()
else:
out = self.health_history.as_json(format == Format.json_pretty)
return HandleCommandResult(retval=0, stdout=out)
@CLIWriteCommand('healthcheck history clear')
def _clear_healthchecks(self) -> HandleCommandResult:
"""Clear the healthcheck history"""
self.health_history.reset()
return HandleCommandResult(retval=0, stdout="healthcheck history cleared")
class StandbyModule(MgrStandbyModule):
MODULE_OPTIONS = Module.MODULE_OPTIONS
def __init__(self, *args: Any, **kwargs: Any) -> None:
super(StandbyModule, self).__init__(*args, **kwargs)
self.shutdown_event = threading.Event()
def serve(self) -> None:
server_addr = self.get_localized_module_option(
'server_addr', get_default_addr())
server_port = self.get_localized_module_option(
'server_port', DEFAULT_PORT)
self.log.info("server_addr: %s server_port: %s" %
(server_addr, server_port))
cherrypy.config.update({
'server.socket_host': server_addr,
'server.socket_port': server_port,
'engine.autoreload.on': False,
'request.show_tracebacks': False
})
module = self
class Root(object):
@cherrypy.expose
def index(self) -> str:
standby_behaviour = module.get_module_option('standby_behaviour')
if standby_behaviour == 'default':
active_uri = module.get_active_uri()
return '''
Ceph Exporter
Ceph Exporter
Metrics
'''.format(active_uri)
else:
status = module.get_module_option('standby_error_status_code')
raise cherrypy.HTTPError(status, message="Keep on looking")
@cherrypy.expose
def metrics(self) -> str:
cherrypy.response.headers['Content-Type'] = 'text/plain'
return ''
cherrypy.tree.mount(Root(), '/', {})
self.log.info('Starting engine...')
cherrypy.engine.start()
self.log.info('Engine started.')
# Wait for shutdown event
self.shutdown_event.wait()
self.shutdown_event.clear()
cherrypy.engine.stop()
cherrypy.server.httpserver = None
self.log.info('Engine stopped.')
def shutdown(self) -> None:
self.log.info("Stopping engine...")
self.shutdown_event.set()
self.log.info("Stopped engine")