async def test_invalid_registry(self):
""" check only valid registry can be provided """
for invalid_registry in ["nope", dict(), list()]:
with self.assertRaises(Exception) as cm:
Service(registry=invalid_registry)
self.assertIn("registry must be a Registry, got:",
str(cm.exception))
Service(registry=Registry())
def __init__(self, bot: commands.Bot):
self.bot = bot
self.registry = Registry()
self.service = Service(self.registry)
self.events = Counter("events", "Discord API event counts.")
self.registry.register(self.events)
self.latency = Histogram("latency", "Discord API latency.")
self.registry.register(self.latency)
self.gc_started: typing.Optional[float] = None
self.gc_latency = Histogram(
"gc_latency", "CPython garbage collector execution times."
)
self.registry.register(self.gc_latency)
self.gc_stats = Counter("gc_stats", "CPython garbage collector stats.")
self.registry.register(self.gc_stats)
self.process = psutil.Process(os.getpid())
self.resources = Gauge("resources", "Process resource usage gauges.")
self.registry.register(self.resources)
self.hook_gc()
self.update_gc_and_resource_stats.start() # pylint: disable=no-member
self.serve.start() # pylint: disable=no-member
self.update_latency.start() # pylint: disable=no-member
async def test_stop_stopped_server(self):
""" check stopping a stopped server """
s = Service(registry=self.registry)
await s.start(addr="127.0.0.1")
await s.stop()
with unittest.mock.patch.object(aioprometheus.service.logger,
"warning") as mock_warn:
await s.stop()
self.assertEqual(mock_warn.call_count, 1)
mock_warn.assert_called_once_with(
"Prometheus metrics server is already stopped")
def __init__(self, bot):
self.bot = bot
self.msvr = Service()
if platform.system() == "Linux":
self.platform = platform
self.pid = os.path.join("/proc", "self")
self.pagesize = resource.getpagesize()
self.ticks = os.sysconf("SC_CLK_TCK")
self.btime = 0
with open(os.path.join("/proc", "stat"), "rb") as stat:
for line in stat:
if line.startswith(b"btime "):
self.btime = float(line.split()[1])
break
self.vmem = Gauge("process_virtual_memory_bytes",
"Virtual memory size in bytes.")
self.rss = Gauge("process_resident_memory_bytes",
"Resident memory size in bytes.")
self.start_time = Gauge(
"process_start_time_seconds",
"Start time of the process since unix epoch in seconds.")
self.cpu = Counter("process_cpu_seconds",
"Total user and system CPU time spent in seconds.")
self.fds = Gauge("process_open_fds",
"Number of open file descriptors.")
self.info = Gauge("python_info", "Python platform information.")
self.collected = Counter("python_gc_objects_collected",
"Objects collected during GC.")
self.uncollectable = Counter("python_gc_objects_uncollectable",
"Uncollectable objects found during GC.")
self.collections = Counter(
"python_gc_collections",
"Number of times this generation was collected.")
self.http = Counter("modmail_http_requests",
"The number of http requests sent to Discord.")
self.commands = Counter(
"modmail_commands",
"The total number of commands used on the bot.")
self.tickets = Counter(
"modmail_tickets",
"The total number of tickets created by the bot.")
self.tickets_message = Counter(
"modmail_tickets_message",
"The total number of messages sent in tickets.")
def test_fetch_url_before_starting_server(self):
""" check accessing a URL property raises expection if not available """
s = Service()
with self.assertRaises(Exception) as cm:
_ = s.root_url
self.assertIn(
"No URL available, Prometheus metrics server is not running",
str(cm.exception),
)
with self.assertRaises(Exception) as cm:
_ = s.metrics_url
self.assertIn(
"No URL available, Prometheus metrics server is not running",
str(cm.exception),
)
def run_async(metrics_list: list, addr: str, port: int,
collector: Callable) -> None:
"""
This function starts the async loop with the aio-prometheus server.
:param metrics_list:
:param addr:
:param port:
:param collector:
:return: None
"""
loop = asyncio.get_event_loop()
svr = Service()
try:
loop.run_until_complete(
server(svr, metrics_list, addr, port, collector))
except KeyboardInterrupt:
pass
finally:
loop.run_until_complete(svr.stop())
loop.close()
async def setUp(self):
self.registry = Registry()
self.server = Service(registry=self.registry)
await self.server.start(addr="127.0.0.1")
self.metrics_url = self.server.metrics_url
self.root_url = self.server.root_url
now = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
log_record["timestamp"] = now
if log_record.get("level"):
log_record["level"] = log_record["level"].upper()
else:
log_record["level"] = record.levelname
logger = logging.getLogger()
logger.setLevel(getenv("LOG_LEVEL") or 10)
logHandler = logging.StreamHandler()
formatter = CustomJsonFormatter()
logHandler.setFormatter(formatter)
logger.addHandler(logHandler)
prometheus_service = Service()
prometheus_service.registry = Registry()
prometheus_labels = {
"host": gethostname(),
}
ping_counter = Counter("health_check_counter", "total ping requests.")
latency_metric = Histogram(
"request_latency_seconds",
"request latency in seconds.",
const_labels=prometheus_labels,
buckets=[0.1, 0.5, 1.0, 5.0],
)
ram_metric = Gauge("memory_usage_bytes",
"memory usage in bytes.",
const_labels=prometheus_labels)
cpu_metric = Gauge("cpu_usage_percent",