#!/usr/bin/env python3 import contextlib import sys import time from typing import Any, Dict, Iterable, Optional, Sequence, Union sys.path.append("/home/zulip/deployments/current") from scripts.lib.setup_path import setup_path setup_path() import bmemcached from prometheus_client import start_http_server from prometheus_client.core import REGISTRY, CounterMetricFamily, GaugeMetricFamily from prometheus_client.metrics_core import Metric from prometheus_client.registry import Collector from prometheus_client.samples import Sample from typing_extensions import override from zproject import settings class MemcachedCollector(Collector): @override def collect(self) -> Iterable[Metric]: def gauge( name: str, doc: str, value: Optional[Union[float, bytes]] = None, labels: Optional[Sequence[str]] = None, ) -> GaugeMetricFamily: return GaugeMetricFamily( f"memcached_{name}", doc, float(value) if value else None, labels ) def counter( name: str, doc: str, labels: Optional[Iterable[str]] = None, ) -> CounterMetricFamily: return CounterMetricFamily( f"memcached_{name}", doc, labels=list(labels) if labels is not None else None ) def counter_value( name: str, doc: str, value: Union[bytes, float], labels: Optional[Dict[str, str]] = None, ) -> CounterMetricFamily: if labels is None: labels = {} metric = counter(name, doc, labels=labels.keys()) # CounterMetricFamily strips off a trailing "_total" from # the metric's .name, and force-appends "_total" when you # use .add_metric. Since we have counters that don't end # in _total, manually add samples, re-appending _total # only if we originally ended with it. append_total = name.endswith("_total") metric.samples.append( Sample(metric.name + ("_total" if append_total else ""), labels, float(value), None) ) return metric cache: Dict[str, Any] = settings.CACHES["default"] client = None with contextlib.suppress(Exception): client = bmemcached.Client((cache["LOCATION"],), **cache["OPTIONS"]) yield gauge("up", "If memcached is up", value=client is not None) if client is None: return raw_stats = client.stats() stats: Dict[str, bytes] = next(iter(raw_stats.values())) version_gauge = gauge( "version", "The version of this memcached server.", labels=["version"] ) version_gauge.add_metric(value=1, labels=[stats["version"].decode()]) yield version_gauge yield counter_value( "uptime_seconds", "Number of seconds since the server started.", value=stats["uptime"] ) commands_counter = counter( "commands_total", "Total number of all requests broken down by command (get, set, etc.) and status.", labels=["command", "status"], ) for op in ("get", "delete", "incr", "decr", "cas", "touch"): commands_counter.add_metric(value=float(stats[f"{op}_hits"]), labels=[op, "hit"]) commands_counter.add_metric(value=float(stats[f"{op}_misses"]), labels=[op, "miss"]) commands_counter.add_metric(value=float(stats["cas_badval"]), labels=["cas", "badval"]) commands_counter.add_metric(value=float(stats["cmd_flush"]), labels=["flush", "hit"]) # memcached includes cas operations again in cmd_set commands_counter.add_metric( value=int(stats["cmd_set"]) - (int(stats["cas_hits"]) + int(stats["cas_hits"]) + int(stats["cas_badval"])), labels=["set", "hit"], ) yield commands_counter yield counter_value( "process_user_cpu_seconds_total", "Accumulated user time for this process.", value=stats["rusage_user"], ) yield counter_value( "process_system_cpu_seconds_total", "Accumulated system time for this process.", value=stats["rusage_system"], ) yield gauge( "current_bytes", "Current number of bytes used to store items.", value=stats["bytes"] ) yield gauge( "limit_bytes", "Number of bytes this server is allowed to use for storage.", value=stats["limit_maxbytes"], ) yield gauge( "current_items", "Current number of items stored by this instance.", value=stats["curr_items"], ) yield counter_value( "items_total", "Total number of items stored during the life of this instance.", value=stats["total_items"], ) yield counter_value( "read_bytes_total", "Total number of bytes read by this server from network.", value=stats["bytes_read"], ) yield counter_value( "written_bytes_total", "Total number of bytes sent by this server to network.", value=stats["bytes_written"], ) yield gauge( "current_connections", "Current number of open connections.", value=stats["curr_connections"], ) yield counter_value( "connections_total", "Total number of connections opened since the server started running.", value=stats["total_connections"], ) yield counter_value( "connections_rejected_total", "Total number of connections rejected due to hitting the memcached's -c limit in maxconns_fast mode.", value=stats["rejected_connections"], ) yield counter_value( "connections_yielded_total", "Total number of connections yielded running due to hitting the memcached's -R limit.", value=stats["conn_yields"], ) yield counter_value( "connections_listener_disabled_total", "Number of times that memcached has hit its connections limit and disabled its listener.", value=stats["listen_disabled_num"], ) yield counter_value( "items_evicted_total", "Total number of valid items removed from cache to free memory for new items.", value=stats["evictions"], ) yield counter_value( "items_reclaimed_total", "Total number of times an entry was stored using memory from an expired entry.", value=stats["reclaimed"], ) if "store_too_large" in stats: yield counter_value( "item_too_large_total", "The number of times an item exceeded the max-item-size when being stored.", value=stats["store_too_large"], ) if "store_no_memory" in stats: yield counter_value( "item_no_memory_total", "The number of times an item could not be stored due to no more memory.", value=stats["store_no_memory"], ) raw_stats = client.stats("settings") settings_stats = next(iter(raw_stats.values())) yield counter_value( "max_connections", "Maximum number of clients allowed.", value=settings_stats["maxconns"], ) yield counter_value( "max_item_size_bytes", "Maximum item size.", value=settings_stats["item_size_max"], ) raw_stats = client.stats("slabs") slab_stats = next(iter(raw_stats.values())) yield counter_value( "malloced_bytes", "Number of bytes of memory allocated to slab pages.", value=slab_stats["total_malloced"], ) slabs = {key.split(":", 1)[0] for key in slab_stats if ":" in key} slab_commands = counter( "slab_commands_total", "Total number of all requests broken down by command (get, set, etc.) and status per slab.", labels=["slab", "command", "status"], ) for slab_no in slabs: for op in ("get", "delete", "incr", "decr", "cas", "touch"): slab_commands.add_metric( labels=[slab_no, op, "hit"], value=slab_stats[f"{slab_no}:{op}_hits"] ) slab_commands.add_metric( labels=[slab_no, "cas", "badval"], value=slab_stats[f"{slab_no}:cas_badval"] ) slab_commands.add_metric( labels=[slab_no, "set", "hit"], value=float(slab_stats[f"{slab_no}:cmd_set"]) - ( float(slab_stats[f"{slab_no}:cas_hits"]) + float(slab_stats[f"{slab_no}:cas_badval"]) ), ) yield slab_commands def slab_counter(name: str, doc: str) -> CounterMetricFamily: return counter(f"slab_{name}", doc, labels=["slab"]) def slab_gauge(name: str, doc: str) -> GaugeMetricFamily: return gauge(f"slab_{name}", doc, labels=["slab"]) slab_metrics = { "chunk_size": slab_gauge("chunk_size_bytes", "The amount of space each chunk uses."), "chunks_per_page": slab_gauge( "chunks_per_page", "How many chunks exist within one page." ), "total_pages": slab_gauge( "current_pages", "Total number of pages allocated to the slab class." ), "total_chunks": slab_gauge( "current_chunks", "Total number of chunks allocated to the slab class." ), "used_chunks": slab_gauge( "chunks_used", "How many chunks have been allocated to items." ), "free_chunks": slab_gauge( "chunks_free", "Chunks not yet allocated to items, or freed via delete." ), "free_chunks_end": slab_gauge( "chunks_free_end", "Number of free chunks at the end of the last allocated page." ), } for slab_no in slabs: for key, slab_metric in slab_metrics.items(): slab_metric.samples.append( Sample( slab_metric.name, {"slab": slab_no}, slab_stats.get(f"{slab_no}:{key}", b"0"), ) ) for slab_metric in slab_metrics.values(): yield slab_metric raw_stats = client.stats("items") item_stats = next(iter(raw_stats.values())) item_hits_counter = counter( "slab_lru_hits_total", "Number of get_hits to the LRU.", labels=["slab", "lru"] ) for slab_no in slabs: for lru in ("hot", "warm", "cold", "temp"): item_hits_counter.add_metric( labels=[slab_no, lru], value=item_stats.get(f"items:{slab_no}:hits_to_{lru}", b"0"), ) yield item_hits_counter item_metrics = { "number": slab_gauge( "current_items", "Number of items presently stored in this class." ), "number_hot": slab_gauge( "hot_items", "Number of items presently stored in the HOT LRU." ), "number_warm": slab_gauge( "warm_items", "Number of items presently stored in the WARM LRU." ), "number_cold": slab_gauge( "cold_items", "Number of items presently stored in the COLD LRU." ), "number_temp": slab_gauge( "temporary_items", "Number of items presently stored in the TEMPORARY LRU." ), "age_hot": slab_gauge("hot_age_seconds", "Age of the oldest item in HOT LRU."), "age_warm": slab_gauge("warm_age_seconds", "Age of the oldest item in WARM LRU."), "age": slab_gauge("items_age_seconds", "Age of the oldest item in the LRU."), "mem_requested": slab_gauge( "mem_requested_bytes", "Number of bytes requested to be stored in this LRU." ), "evicted": slab_counter( "items_evicted_total", "Total number of times an item had to be evicted from the LRU before it expired.", ), "evicted_nonzero": slab_counter( "items_evicted_nonzero_total", "Number of times an item which had an explicit expire time set had to be evicted from the LRU before it expired.", ), "evicted_time": slab_gauge( "items_evicted_time_seconds", "Seconds since the last access for the most recent item evicted from this class.", ), "outofmemory": slab_counter( "items_outofmemory_total", " Number of times the underlying slab class was unable to store a new item.", ), "tailrepairs": slab_counter( "items_tailrepairs_total", "Number of times we self-healed a slab with a refcount leak.", ), "reclaimed": slab_counter( "items_reclaimed_total", "Number of times an entry was stored using memory from an expired entry.", ), "expired_unfetched": slab_counter( "items_expired_unfetched_total", "Number of expired items reclaimed from the LRU which were never touched after being set.", ), "evicted_unfetched": slab_counter( "items_evicted_unfetched_total", "Number of valid items evicted from the LRU which were never touched after being set.", ), "evicted_active": slab_counter( "items_evicted_active_total", "Number of valid items evicted from the LRU which were recently touched but were evicted before being moved to the top of the LRU again.", ), "crawler_reclaimed": slab_counter( "items_crawler_reclaimed_total", "Number of items freed by the LRU Crawler." ), "lrutail_reflocked": slab_counter( "items_lrutail_reflocked_total", "Number of items found to be refcount locked in the LRU tail.", ), "moves_to_cold": slab_counter( "moves_to_cold_total", "Number of items moved from HOT or WARM into COLD." ), "moves_to_warm": slab_counter( "moves_to_warm_total", "Number of items moved from COLD to WARM." ), "moves_within_lru": slab_counter( "moves_within_lru_total", "Number of times active items were bumped within HOW or WARM.", ), } for slab_no in slabs: for key, item_metric in item_metrics.items(): item_metric.samples.append( Sample( item_metric.name, {"slab": slab_no}, item_stats.get(f"items:{slab_no}:{key}", b"0"), ) ) for item_metric in item_metrics.values(): yield item_metric raw_stats = client.stats("sizes") sizes_stats = next(iter(raw_stats.values())) if sizes_stats.get("sizes_status") == b"disabled" or sizes_stats == {}: return sizes = sorted([int(x) for x in sizes_stats]) yield gauge( "item_max_bytes", "Largest item (rounded to 32 bytes) in bytes.", value=sizes[-1] ) if __name__ == "__main__": REGISTRY.register(MemcachedCollector()) start_http_server(11212) while True: time.sleep(60)