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",