system.asynchronous_metrics

Contient des métriques calculées périodiquement en arrière-plan. Par exemple, la quantité de RAM utilisée.

Une métrique est soit scalaire (un seul nombre dans la colonne value), soit de type clé-valeur, ventilée par entité, par exemple par cœur de CPU, périphérique de bloc, interface réseau ou disque. Les métriques clé-valeur sont représentées par une seule ligne avec un Map dans la colonne key_values (par exemple, CPUFrequencyMHz associe chaque numéro de cœur de CPU à sa fréquence), et leur colonne value est NaN.

• metric (String) — Nom de la métrique.
• value (Float64) — Valeur de la métrique. Pour les métriques clé-valeur (ventilées par cœur de CPU, périphérique de blocs, disque, …), elle est NaN et les valeurs se trouvent dans la colonne key_values.
• key_values (Map(LowCardinality(String), Float64)) — Valeurs d’une métrique clé-valeur, par exemple indexées par le numéro de cœur de CPU ou le nom du périphérique de blocs. Vide pour les métriques scalaires.
• description (String - Description de la métrique)

SELECT metric, value, key_values
FROM system.asynchronous_metrics
WHERE metric IN ('MemoryResident', 'OSUserTime', 'DiskTotal', 'BlockReadBytes', 'NetworkReceiveBytes')
ORDER BY metric

┌─metric──────────────┬─────────────value─┬─key_values──────────────────────────────────────┐
│ BlockReadBytes      │               nan │ {'nvme0n1':67420160}                            │
│ DiskTotal           │               nan │ {'backups':34359738368,'default':5199475388416} │
│ MemoryResident      │         970743808 │ {}                                              │
│ NetworkReceiveBytes │               nan │ {'docker0':0,'ens66':334554363}                 │
│ OSUserTime          │ 32.11807291562506 │ {}                                              │
└─────────────────────┴───────────────────┴─────────────────────────────────────────────────┘

Un élément d’une métrique clé-valeur peut être extrait à l’aide d’un indice de map :

SELECT key_values['default'] AS default_disk_total
FROM system.asynchronous_metrics
WHERE metric = 'DiskTotal'

Les descriptions ci-dessous sont générées à partir du code source C++ par utils/generate-async-metrics-docs. La référence qui fait foi est la chaîne littérale placée à côté de chaque appel d’enregistrement de métrique dans src/Common/AsynchronousMetrics.cpp, src/Interpreters/ServerAsynchronousMetrics.cpp et src/Coordination/KeeperAsynchronousMetrics.cpp. Les noms de métrriques qui incluent une partie variable (actuellement uniquement le groupe de pools de connexions HTTP) sont représentés par l’espace réservé *name* ; le serveur en cours d’exécution les expose avec le nom concret substitué.

Temps, en secondes, consacré au calcul des métriques asynchrones lourdes (liées aux tables) (il s'agit de la surcharge liée aux métriques asynchrones).

Intervalle de mise à jour des métriques lourdes relatives aux tables

Temps, en secondes, consacré au calcul des métriques asynchrones (il s’agit du surcoût des métriques asynchrones).

Intervalle de mise à jour des métriques

Nombre de messages asynchrones en file d’attente pour la journalisation, indexés par le nom du canal de journalisation.

Durée, en secondes, pendant laquelle les requêtes d’E/S étaient en file d’attente sur chaque périphérique de blocs. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Similaire à la métrique BlockActiveTime, mais la valeur est divisée par le nombre d’opérations d’E/S afin de calculer le temps par opération. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’octets libérés sur chaque périphérique de blocs. Ces opérations sont pertinentes pour les SSD. Les opérations de discard ne sont pas utilisées par ClickHouse, mais peuvent l’être par d’autres processus sur le système. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations de discard demandées à chaque périphérique de blocs et fusionnées par l’ordonnanceur d’E/S du système d’exploitation. Ces opérations sont pertinentes pour les SSD. Les opérations de discard ne sont pas utilisées par ClickHouse, mais peuvent l’être par d’autres processus du système. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations de discard demandées à chaque périphérique de blocs. Ces opérations sont pertinentes pour les SSD. Les opérations de discard ne sont pas utilisées par ClickHouse, mais peuvent l’être par d’autres processus du système. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Temps passé, en secondes, dans les opérations de discard demandées à chaque périphérique de blocs, cumulé sur l’ensemble des opérations. Ces opérations sont pertinentes pour les SSD. Les opérations de discard ne sont pas utilisées par ClickHouse, mais peuvent être utilisées par d’autres processus sur le système. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Cette valeur compte, pour chaque périphérique de blocs, le nombre de requêtes d’E/S envoyées au pilote de périphérique, mais pas encore terminées. Elle n’inclut pas les requêtes d’E/S qui se trouvent dans la file d’attente, mais qui n’ont pas encore été envoyées au pilote de périphérique. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Cette valeur compte le nombre de millisecondes pendant lesquelles les requêtes d’E/S ont attendu sur chaque périphérique de blocs. Si plusieurs requêtes d’E/S sont en attente, cette valeur augmente du produit du nombre de millisecondes par le nombre de requêtes en attente. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Similaire à la métrique BlockQueueTime, mais la valeur est divisée par le nombre d’opérations d’E/S afin de calculer le temps par opération. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’octets lus sur chaque périphérique de blocs. Il peut être inférieur au nombre d’octets lus depuis le système de fichiers en raison de l’utilisation du cache de pages de l’OS, qui économise les E/S. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations de lecture demandées à chaque périphérique de blocs et fusionnées par le planificateur d’E/S de l’OS. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations de lecture demandées à chaque périphérique de blocs. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Temps en secondes passé dans les opérations de lecture demandées à chaque périphérique de blocs, cumulé sur l’ensemble des opérations. Les clés correspondent aux noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’octets écrits sur chaque périphérique de blocs. Il peut être inférieur au nombre d’octets écrits sur le système de fichiers en raison de l’utilisation du cache de pages du système d’exploitation, qui réduit les E/S. Une écriture sur le périphérique de blocs peut se produire après l’écriture correspondante sur le système de fichiers en raison du cache en écriture immédiate. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations d’écriture demandées à chaque périphérique de blocs et fusionnées par le planificateur d’E/S de l’OS. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Nombre d’opérations d’écriture demandées pour chaque périphérique de blocs. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Temps passé, en secondes, dans les opérations d’écriture demandées à chaque périphérique de blocs, cumulé sur l’ensemble des opérations. Les clés sont les noms des périphériques de blocs. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Source : /sys/block. Voir https://www.kernel.org/doc/Documentation/block/stat.txt

Le nombre maximal de cœurs CPU selon les CGroups.

La quantité totale de mémoire du cgroup, en octets. Si elle est égale à zéro, la limite est la même que celle de OSMemoryTotal.

La quantité de mémoire utilisée par le cgroup, en octets. Avec cgroup v2, il s’agit de anon + sock + la mémoire noyau non récupérable ; avec cgroup v1, il s’agit de la RSS. Dans les deux cas, le cache de pages du système d’exploitation (cache de fichiers) du noyau est exclu.

La quantité de mémoire utilisée dans le cgroup, en octets, à l’exclusion du userspace page cache de ClickHouse. Il s’agit de CGroupMemoryUsed diminué de la taille du userspace page cache. Lorsque le userspace page cache est désactivé, cette valeur est égale à CGroupMemoryUsed.

La proportion du temps pendant laquelle le cœur du CPU exécutait du code du noyau du système d’exploitation (system).

La valeur est similaire à CGroupSystemTime, mais divisée par le nombre de cœurs de CPU disponibles afin d’être mesurée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. S’il est spécifié, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs de CPU, et dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

La proportion du temps pendant lequel le cœur du CPU exécutait du code en espace utilisateur. Cela inclut également le temps pendant lequel le CPU était sous-utilisé pour des raisons internes au CPU (chargements mémoire, blocages du pipeline, erreurs de prédiction de branchement, exécution sur un autre cœur SMT).

La valeur est similaire à CGroupUserTime, mais divisée par le nombre de cœurs CPU disponibles afin d’être mesurée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela vous permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, et d’obtenir malgré tout la métrique moyenne d’utilisation des ressources. Si elle est spécifiée, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs CPU, et dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Nombre maximal d’octets configuré pour le cache d’expressions compilées. Marge disponible = cette valeur moins CompiledExpressionCacheBytes (CurrentMetric).

Nombre maximal configuré d’entrées dans le cache d’expressions compilées. Marge disponible = cette valeur moins CompiledExpressionCacheCount (CurrentMetric).

La fréquence actuelle de chaque cœur de CPU, en MHz, indexée au numéro du cœur de CPU. La plupart des CPU modernes ajustent dynamiquement leur fréquence pour économiser de l'énergie et profiter du mode Turbo Boost.

Nombre estimé de blobs en attente de suppression du stockage d’objets sur disque (la file d’attente des blobs supprimés du gestionnaire de blobs), indexé par nom de disque. Les disques sans réplication de blobs signalent 0.

Le délai maximal (en secondes) de mise à jour du dictionnaire

Nombre d’erreurs depuis le dernier chargement réussi de l’ensemble des dictionnaires.

Nombre d’octets disponibles sur chaque disque (système de fichiers virtuel), indexés au nom du disque. Les systèmes de fichiers distants peuvent ne pas fournir cette information et afficher une valeur élevée, comme 16 EiB.

Nombre de requêtes GetObject pouvant actuellement être envoyées sans atteindre la limite de limitation de débit sur chaque disque (système de fichiers virtuel), indexées par nom de disque. Les systèmes de fichiers locaux peuvent ne pas fournir cette information.

Limite de limitation de débit des requêtes GetObject sur chaque disque, en requêtes par seconde (système de fichiers virtuel), indexé par le nom du disque. Les systèmes de fichiers locaux peuvent ne pas fournir cette information.

Nombre de requêtes PutObject pouvant actuellement être envoyées sans atteindre la limite de limitation de débit sur chaque disque (système de fichiers virtuel), indexées par nom de disque. Les systèmes de fichiers locaux peuvent ne pas fournir cette information.

Limite de limitation de débit des requêtes PutObject sur chaque disque, en requêtes par seconde (système de fichiers virtuel), indexé par nom de disque. Les systèmes de fichiers locaux peuvent ne pas fournir cette information.

La taille totale, en octets, de chaque disque (système de fichiers virtuel), indexée par le nom du disque. Les systèmes de fichiers distants peuvent ne pas fournir cette information et afficher une valeur élevée, par exemple 16 EiB.

Nombre d’octets disponibles sur chaque disque (système de fichiers virtuel), hors réservations pour les fusions, les récupérations et les déplacements, indexé par nom de disque. Les systèmes de fichiers distants peuvent ne pas fournir cette information et afficher une valeur élevée, comme 16 EiB.

Octets utilisés sur chaque disque (système de fichiers virtuel), indexés au nom du disque. Les systèmes de fichiers distants ne fournissent pas toujours cette information.

Le nombre d’erreurs mémoire ECC corrigeables, indexé par le numéro du contrôleur mémoire. Une valeur élevée indique une RAM défectueuse qui doit être remplacée immédiatement, car lorsqu’un grand nombre d’erreurs sont corrigées, des erreurs silencieuses peuvent également se produire, entraînant une corruption des données. Source : /sys/devices/system/edac/mc/

Le nombre d’erreurs mémoire ECC irrécupérables, indexé par le numéro du contrôleur mémoire. Une valeur non nulle indique une RAM défectueuse qui doit être remplacée immédiatement, car elle signale un risque potentiel de corruption des données. Source : /sys/devices/system/edac/mc/

Somme de la taille de l’ensemble résident (VmRSS) de tous les processus en cours d’exécution des fonctions définies par l’utilisateur de type executable et executable_pool, ainsi que de leurs processus descendants, en octets. Les workers executable_pool inactifs sont inclus. Les pages partagées sont comptées une fois par processus ; la somme constitue donc une borne supérieure qui peut dépasser l’empreinte mémoire physique réelle des processus UDF.

Nombre de processus en cours d’exécution lancés pour les fonctions définies par l’utilisateur executable et executable_pool, y compris leurs processus descendants.

Nombre total d’octets dans le système de fichiers virtuel cache. Ce cache est stocké sur disque.

Capacité totale du système de fichiers virtuel cache. Ce cache est stocké sur disque.

Nombre total de segments de fichier mis en cache dans le système de fichiers virtuel cache. Ce cache est stocké sur disque.

Octets disponibles sur le volume sur lequel le chemin des logs de ClickHouse est monté. Si cette valeur se rapproche de zéro, vous devez ajuster la rotation des logs dans le fichier de configuration.

Le nombre d’inodes disponibles sur le volume sur lequel est monté le chemin des logs de ClickHouse.

La taille, en octets, du volume sur lequel est monté le chemin des logs de ClickHouse. Il est recommandé de prévoir au moins 10 Go pour les logs.

Le nombre total d’inodes sur le volume où est monté le chemin des logs de ClickHouse.

Octets utilisés sur le volume sur lequel est monté le chemin des logs de ClickHouse.

Le nombre d’inodes utilisés sur le volume sur lequel le chemin des logs de ClickHouse est monté.

Octets disponibles sur le volume sur lequel est monté le chemin principal de ClickHouse.

Le nombre d’inodes disponibles sur le volume sur lequel le chemin principal de ClickHouse est monté. S’il est proche de zéro, cela indique une erreur de configuration et vous obtiendrez « no space left on device » même si le disque n’est pas plein.

La taille, en octets, du volume sur lequel le chemin principal de ClickHouse est monté.

Le nombre total d’inodes sur le volume où le chemin principal de ClickHouse est monté. S’il est inférieur à 25 millions, cela indique une mauvaise configuration.

Nombre d’octets utilisés sur le volume où est monté le chemin principal de ClickHouse.

Le nombre d’inodes utilisés sur le volume où est monté le chemin principal de ClickHouse. Cette valeur correspond généralement au nombre de fichiers.

Nombre de connexions rejetées pour le protocole GRPC.

Nombre de threads du serveur du protocole GRPC.

Le nombre d’entrées dans le cache des tailles de tables de hachage. Le cache des tailles de tables de hachage est utilisé pour l’optimisation prédictive de GROUP BY.

Le nombre de fois où la prédiction de la taille d’une table de hachage a été correcte.

Le nombre de fois où l’estimation de la taille d’une table de hachage s’est révélée incorrecte.

Mémoire totale du tampon de réception TCP du noyau (sk_rmem_alloc) sur l’ensemble des sockets du pool de connexions HTTP.

Mémoire totale du tampon d’émission TCP du noyau (sk_wmem_alloc) pour l’ensemble des sockets du pool de connexions HTTP.

Nombre de connexions rejetées sur l’interface HTTP (sans TLS).

Nombre de connexions rejetées sur l’interface HTTPS.

Nombre de threads dans le serveur de l’interface HTTPS.

Nombre de threads sur le serveur de l’interface HTTP (sans TLS).

Nombre de connexions rejetées pour le protocole de communication entre les répliques (sans TLS).

Nombre de connexions rejetées pour le protocole de communication des répliques (avec TLS).

Nombre de threads du serveur du protocole de communication entre répliques (avec TLS).

Nombre de threads sur le serveur du protocole de communication entre les répliques (sans TLS).

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Métrique interne de l’allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Il s'agit d'une métrique interne de l'allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Métrique interne de l’allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Métrique interne de l’allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Numéro d’incrémentation interne des statistiques de jemalloc (l’allocateur mémoire de Jason Evans), utilisé dans toutes les autres métriques jemalloc.

La différence entre jemalloc.active et jemalloc.allocated représente la fragmentation interne de l’allocateur de mémoire (pages actives qui ne sont pas entièrement utilisées par les allocations).

Octets actifs dans l’arène JIT jemalloc dédiée. Inclut à la fois (a) l’état du tas LLVM (TargetMachine et son Subtarget spécifique à la cible, les modules IR, les analyses des passes d’optimisation, les tables de relocalisation RuntimeDyld) et (b) les blocs réservés alignés sur les pages que JITModuleMemoryManager alloue via posix_memalign pour les sections exécutables et de données (intercepté par je_posix_memalign, il passe donc par jemalloc). CompiledExpressionCacheBytes (CurrentMetric) constitue un sous-ensemble de cette métrique : il ne suit que la capacité réservée des blocs de pages pour les sections exécutables et de données, et non les octets de code et de données réellement utilisés dans ces blocs.

Octets de l’arène JIT marqués comme « dirty », pouvant être purgés puis restitués au système d’exploitation.

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Octets actifs cumulés dans le pool d’arènes jemalloc MergeTree dédié (arènes jemalloc.mergetree_arena.count). Contient l’état du tas MergeTree à long terme : les métadonnées par part (SerializationInfoByName, l’arbre MergeTreeDataPartChecksums, les délégués Poco::LRUCache<String, ColumnSize> à l’intérieur de chaque IMergeTreeDataPart, les maps ColumnSize/IndexSize par part, MinMaxIndex, VersionMetadataOnDisk et l’objet MergeTreeDataPart{Compact,Wide} lui-même), les métadonnées partagées entre les parts d’une table (NamesAndTypesList, column_name_to_position, la map serializations et ColumnsSubstreams, voir SharedPartColumns.h) ainsi que les métadonnées par table (clones de StorageInMemoryMetadata / ColumnsDescription / VirtualColumnsDescription initialisés par setProperties, l’agrégation serialization_hints et le shared_part_columns_cache). Les parts actives et les parts obsolètes en attente de nettoyage y contribuent toutes deux. Séparée de l’arène de cache et de l’arène JIT. Les colonnes par part system.parts.primary_key_bytes_in_memory[_allocated] et system.parts.index_granularity_bytes_in_memory[_allocated] sont des sous-ensembles de cette métrique (lorsque leurs valeurs sont non nulles). L’index primaire est alloué ici même lorsqu’il appartient à PrimaryIndexCache (volontairement : le réallouer à la limite du cache pourrait échouer après qu’une part a déjà été validée), de sorte que PrimaryIndexCacheBytes chevauche cette métrique.

Nombre d’arènes jemalloc dédiées aux métadonnées MergeTree à longue durée de vie, contrôlé par le paramètre de serveur jemalloc_merge_tree_arenas. 0 signifie que le pool d’arènes dédiées est désactivé et que les métadonnées sont allouées dans les arènes par défaut par CPU ; 1 correspond à une arène unique partagée ; N > 1 correspond à un pool réparti par CPU. Consultez jemalloc.mergetree_arena.active_bytes.

Octets de l’arène MergeTree dédiée, additionnés sur l’ensemble du pool jemalloc, marqués comme « dirty », pouvant être purgés puis restitués au système d’exploitation.

Somme des pages actives dans le pool d’arènes MergeTree dédié de jemalloc.

Pages modifiées cumulées dans le pool Arena MergeTree dédié de jemalloc.

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

Une métrique interne de l’allocateur de mémoire de bas niveau (jemalloc). Voir https://jemalloc.net/jemalloc.3.html

La différence de temps entre l’instant où le thread chargé du calcul des métriques asynchrones était censé être réveillé et celui où il l’a effectivement été. Un indicateur indirect de la latence et de la réactivité globales du système.

La taille approximative des données de ClickHouse Keeper, en octets.

Latence moyenne des requêtes de ClickHouse Keeper.

Nombre d’entrées de log décodées actuellement mises en mémoire tampon avant le thread de commit par le lecteur de lecture anticipée du changelog

Taille totale des entrées de log décodées actuellement mises en mémoire tampon avant le thread de commit par le lecteur de lecture anticipée du changelog

Le nombre de nœuds éphémères de ClickHouse Keeper.

Le nombre de followers de ClickHouse Keeper.

1 si ClickHouse Keeper dépasse la limite mémoire souple, 0 sinon.

1 si ClickHouse Keeper est un follower, 0 sinon.

1 si ClickHouse Keeper est leader, 0 sinon.

1 si ClickHouse Keeper agit en tant qu’observateur, 0 sinon.

1 si ClickHouse Keeper est en mode autonome, 0 sinon.

Index du dernier log validé dans ClickHouse Keeper.

Durée, en millisecondes, de la dernière période sans leader observée localement, qui s'est achevée lorsque cette instance de ClickHouse Keeper est devenue leader. Les transferts de leadership qui ne présentent pas d'état sans leader échantillonné ne sont pas enregistrés. 0 si cette instance n'est pas le leader actif ou si aucune période terminée n'a été enregistrée.

Durée, en millisecondes, de la dernière période sans leader observée localement et achevée par ce leader ClickHouse Keeper. 0 si cette instance n’est pas le leader actif ou si aucune période sans leader achevée n’a été enregistrée.

Index du dernier log stocké dans ClickHouse Keeper.

Terme Raft du dernier log enregistré dans ClickHouse Keeper.

Index du dernier log présent dans le dernier snapshot créé.

Nombre d’entrées stockées dans le cache en mémoire des logs les plus récents

Taille totale du cache en mémoire des logs les plus récents

La taille non compressée, en octets, du dernier snapshot créé par ClickHouse Keeper.

Le nombre maximal de descripteurs de fichier ouverts dans ClickHouse Keeper. -1 si cette valeur ne peut pas être déterminée.

Latence maximale des requêtes de ClickHouse Keeper.

Latence minimale des requêtes de ClickHouse Keeper.

Le nombre de descripteurs de fichiers ouverts dans ClickHouse Keeper. -1 si la valeur ne peut pas être déterminée.

Nombre de paquets reçus par ClickHouse Keeper.

Nombre de paquets envoyés par ClickHouse Keeper.

Le nombre de paths différents surveillés par les clients de ClickHouse Keeper.

Le nombre de sessions clientes de ClickHouse Keeper ayant des watches.

Le nombre de followers de ClickHouse Keeper qui sont eux aussi synchronisés.

Indice jusqu’auquel les logs peuvent être validés dans ClickHouse Keeper.

Nombre de connexions rejetées du protocole TCP de Keeper (sans TLS).

Nombre de connexions rejetées pour le protocole TCP de Keeper avec TLS.

Nombre de threads du serveur du protocole TCP de Keeper (avec TLS).

Nombre de threads du serveur du protocole TCP de Keeper (sans TLS).

Le nombre de watches dans ClickHouse Keeper.

Le nombre de nœuds (entrées de données) de ClickHouse Keeper.

L’identifiant de transaction actuel (zxid) dans ClickHouse Keeper.

La charge de l’ensemble du système, calculée comme une moyenne avec lissage exponentiel sur 1 minute. La charge correspond au nombre de threads de l’ensemble des processus (les entités d’ordonnancement du noyau de l’OS) qui s’exécutent actuellement sur le CPU, sont en attente d’IO, ou sont prêts à s’exécuter sans être planifiés à cet instant. Ce nombre inclut tous les processus, et pas seulement clickhouse-server. Il peut être supérieur au nombre de cœurs CPU si le système est surchargé et que de nombreux processus sont prêts à s’exécuter, mais attendent du CPU ou des IO.

La charge globale du système, moyennée par lissage exponentiel sur 15 minutes. La charge correspond au nombre de threads de l’ensemble des processus (les entités d’ordonnancement du noyau du système d’exploitation) qui s’exécutent actuellement sur le CPU, sont en attente d’E/S, ou sont prêts à s’exécuter mais ne sont pas planifiés à cet instant. Cette valeur inclut tous les processus, pas seulement clickhouse-server. Elle peut être supérieure au nombre de cœurs de CPU si le système est surchargé et que de nombreux processus sont prêts à s’exécuter mais attendent le CPU ou les E/S.

La charge globale du système, calculée comme une moyenne avec lissage exponentiel sur 5 minutes. La charge représente le nombre de threads de l’ensemble des processus (les entités d’ordonnancement du noyau du système d’exploitation) qui s’exécutent actuellement sur le CPU, attendent des opérations d’IO, ou sont prêts à s’exécuter mais ne sont pas planifiés à cet instant. Ce nombre inclut tous les processus, et pas seulement clickhouse-server. Il peut être supérieur au nombre de cœurs CPU si le système est surchargé et que de nombreux processus sont prêts à s’exécuter, mais attendent du CPU ou des opérations d’IO.

Temps écoulé, en secondes, de l’opération de fusion en arrière-plan actuellement en cours depuis le plus longtemps.

Nombre maximal de parts par partition, toutes partitions confondues, pour toutes les tables de la famille MergeTree. Des valeurs supérieures à 300 indiquent une mauvaise configuration, une surcharge ou un chargement massif de données.

La quantité de mémoire virtuelle mappée pour les pages de code machine du processus du serveur, en octets.

Quantité de mémoire virtuelle mappée pour l’utilisation de la pile et de la mémoire allouée, en octets. Il n’est pas précisé si cela inclut les piles de chaque thread ni la majeure partie de la mémoire allouée au moyen de l’appel système mmap. Cette métrique n’existe que par souci d’exhaustivité. Je recommande d’utiliser la métrique MemoryResident pour la surveillance.

La quantité de mémoire physique utilisée par le processus du serveur, en octets.

Quantité maximale de mémoire physique utilisée par le processus du serveur, en octets.

Quantité de mémoire physique utilisée par le processus du serveur, hors cache de pages en espace utilisateur, en octets. Cette mesure donne une vision plus précise de l’utilisation réelle de la mémoire lorsque le cache de pages en espace utilisateur est utilisé. Lorsque le cache de pages en espace utilisateur est désactivé, cette valeur est égale à MemoryResident.

La quantité de mémoire utilisée par le processus serveur et également partagée avec d'autres processus, en octets. ClickHouse n'utilise pas de mémoire partagée, mais le système d'exploitation peut, pour ses propres raisons, marquer une partie de la mémoire comme partagée. Cette métrique n'est pas très pertinente à surveiller et n'existe que par souci d'exhaustivité.

Nombre de zones de mémoire virtuelle (VMA) de piles pthread marquées [anon:clickhouse_stack] dans /proc/self/smaps. Actualisé selon la fréquence de collecte des métriques lourdes. Nécessite Linux 5.17 ou une version ultérieure ; indisponible sur les kernels plus anciens (voir l’entrée MEMORY_THREAD_STACKS_METRIC_UNAVAILABLE dans system.warnings).

Nombre de régions de mémoire virtuelle de la tâche marquées VM_MEMORY_STACK (à l’exclusion des régions de garde inaccessibles). Actualisé selon la fréquence de collecte des métriques lourdes.

Taille approximative de l'ensemble résident des piles pthread, obtenue en additionnant les valeurs Rss: des VMA de /proc/self/smaps étiquetées [anon:clickhouse_stack] via prctl(PR_SET_VMA_ANON_NAME). Actualisée selon la fréquence de collecte des métriques lourdes. Nécessite Linux 5.17 ou une version ultérieure ; absente sur les kernels plus anciens (voir l'entrée MEMORY_THREAD_STACKS_METRIC_UNAVAILABLE dans system.warnings).

Taille approximative de l'ensemble résident des piles pthread, obtenue en additionnant les pages résidentes des régions de mémoire virtuelle de la tâche étiquetées VM_MEMORY_STACK (à l'exclusion des régions de garde inaccessibles). Actualisée selon la fréquence de collecte des métriques lourdes.

Taille virtuelle approximative des piles pthread, calculée en additionnant les valeurs Size: des VMA de /proc/self/smaps étiquetées [anon:clickhouse_stack]. Actualisée selon la fréquence de collecte des métriques lourdes. Nécessite Linux 5.17 ou une version ultérieure ; absente sur les kernels antérieurs (voir l’entrée MEMORY_THREAD_STACKS_METRIC_UNAVAILABLE dans system.warnings).

Taille virtuelle approximative des piles pthread, calculée en additionnant les tailles des régions de mémoire virtuelle de la tâche étiquetées VM_MEMORY_STACK (à l’exclusion des régions de garde inaccessibles). Actualisée selon la fréquence de collecte des métriques lourdes.

Taille de l’espace d’adressage virtuel alloué par le processus serveur, en octets. La taille de l’espace d’adressage virtuel est généralement bien supérieure à la consommation de mémoire physique et ne doit pas être utilisée pour estimer la consommation de mémoire. Des valeurs élevées pour cette métrique sont tout à fait normales et n’ont qu’une signification technique.

Nombre estimé de blobs en attente de réplication vers d'autres emplacements du disque (file d'attente des blobs manquants du gestionnaire de blobs), identifié par le nom du disque. Les disques sans réplication de blobs renvoient 0.

Nombre de connexions rejetées du protocole de compatibilité MySQL.

Nombre de threads sur le serveur du protocole de compatibilité MySQL.

Nombre d’octets reçus via chaque interface réseau. Les clés correspondent aux noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre d’octets de paquets supprimés lors de leur réception sur toutes les interfaces réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de fois où une erreur s’est produite lors de la réception via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de paquets réseau reçus via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre d’octets envoyés via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de fois qu’un paquet a été abandonné lors de l’envoi via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de fois où une erreur (par ex. une retransmission TCP) s’est produite lors de l’envoi via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de paquets réseau envoyés via chaque interface réseau. Les clés sont les noms des interfaces réseau. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Taille totale des files d’attente de réception des sockets réseau utilisés sur le serveur en TCPv4 et TCPv6.

Nombre total d’adresses distantes uniques des sockets réseau utilisés sur le serveur, en TCPv4 et TCPv6.

Nombre total de sockets réseau utilisés sur le serveur, en TCPv4 et TCPv6, tous états confondus.

Nombre total de sockets réseau dans un état donné sur le serveur, pour TCPv4 et TCPv6.

Taille totale des files d’attente d’émission des sockets réseau utilisés par le serveur, en TCPv4 et TCPv6.

Taille totale des retransmissions en cours (non récupérées à cet instant) des sockets réseau utilisées sur le serveur, en TCPv4 et TCPv6.

Nombre total de bases de données sur le serveur.

Le nombre total de parts détachées de tables MergeTree par des utilisateurs à l’aide de la requête ALTER TABLE DETACH (par opposition aux parts inattendues, endommagées ou ignorées). Le serveur ne tient pas compte des parts détachées et elles peuvent être supprimées.

Le nombre total de parts détachées des tables MergeTree. Une part peut être détachée par un utilisateur à l'aide de la requête ALTER TABLE DETACH, ou par le serveur lui-même si la part est corrompue, inattendue ou devenue inutile. Le serveur ignore les parts détachées, qui peuvent donc être supprimées.

Le nombre total de mutations restant à appliquer.

Le nombre total de mutations pour lesquelles il reste une part de données à muter au-delà de la valeur spécifiée du paramètre max_pending_mutations_execution_time_to_warn.

Nombre total de tables, toutes bases de données du serveur confondues, à l’exclusion des bases de données qui ne peuvent pas contenir de tables MergeTree. Les moteurs de base de données exclus sont ceux qui génèrent l’ensemble des tables à la volée, comme Lazy, MySQL, PostgreSQL, SQlite.

Nombre total de tables de la base de données system sur le serveur, stockées dans des tables de la famille MergeTree.

Nombre de changements de contexte subis par le système sur la machine hôte. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Déficit relatif de CPU, calculé comme suit : nombre de threads en attente de CPU par rapport au nombre de threads utilisant le CPU. S'il est supérieur à zéro, le serveur tirerait parti de ressources CPU supplémentaires. S'il est nettement supérieur à zéro, le serveur pourrait ne plus répondre. La métrique est accumulée entre les mises à jour des métriques asynchrones.

Le ratio du temps passé à exécuter un CPU virtuel pour des systèmes d’exploitation invités sous le contrôle du kernel Linux, lorsqu’un invité est défini avec une priorité plus élevée (voir man procfs). Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Cette métrique n’est pas pertinente pour ClickHouse, mais elle existe néanmoins par souci d’exhaustivité. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme de leurs valeurs [0..num cores].

Ratio du temps pendant lequel chaque cœur CPU a exécuté un CPU virtuel pour des systèmes d’exploitation invités avec une priorité plus élevée, identique à OSGuestNiceTime, mais non additionné sur l’ensemble des cœurs. Les clés correspondent aux numéros des cœurs CPU, et la valeur de chaque cœur est comprise dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSGuestNiceTime, mais divisée par le nombre de cœurs CPU afin d’être mesurée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela vous permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs varie, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est définie, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Le ratio du temps passé à exécuter un CPU virtuel pour des systèmes d’exploitation invités sous le contrôle du kernel Linux (voir man procfs). Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Cette métrique n’est pas pertinente pour ClickHouse, mais elle existe tout de même par souci d’exhaustivité. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme de leurs valeurs [0..num cores].

Ratio du temps pendant lequel chaque cœur CPU a exécuté un CPU virtuel pour les systèmes d’exploitation invités, identique à OSGuestTime, mais non additionné sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Cette valeur est similaire à OSGuestTime, mais divisée par le nombre de cœurs CPU afin d’être ramenée à l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de moyenner les valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en conservant une métrique moyenne d’utilisation des ressources. Si elle est définie, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Le ratio du temps pendant lequel le cœur CPU était inactif (sans même être prêt à exécuter un processus en attente d’IO), du point de vue du kernel du système d’exploitation. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, pas seulement clickhouse-server. Cela n’inclut pas le temps pendant lequel le CPU était sous-utilisé pour des raisons internes au CPU (accès mémoire, blocages du pipeline, erreurs de prédiction de branchement, exécution d’un autre cœur SMT). La valeur pour un seul cœur CPU est comprise dans l’intervalle [0..1]. La valeur pour tous les cœurs CPU est calculée comme la somme de l’ensemble des cœurs [0..num cores].

Ratio du temps pendant lequel chaque cœur CPU était inactif, identique à OSIdleTime, mais non additionné sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Cette valeur est similaire à OSIdleTime, mais divisée par le nombre de cœurs de CPU afin d’être ramenée à l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est spécifiée, la Cgroup CPU quota divisée par sa période peut être utilisée à la place du nombre réel de cœurs de CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Le nombre d’interruptions sur la machine hôte. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Ratio entre le temps pendant lequel le cœur CPU n’exécutait pas de code et le temps pendant lequel le kernel du système d’exploitation n’exécutait aucun autre processus sur ce CPU, les processus étant en attente d’opérations d’IO. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme de ces valeurs [0..num cores].

Le ratio du temps pendant lequel chaque cœur CPU attendait des E/S, identique à OSIOWaitTime mais non additionné sur l’ensemble des cœurs. Les clés correspondent aux numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

Cette valeur est similaire à OSIOWaitTime, mais divisée par le nombre de cœurs de processeur afin d’être exprimée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est définie, la Cgroup CPU quota divisée par sa période peut être utilisée à la place du nombre réel de cœurs de processeur ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Le ratio du temps consacré au traitement des requêtes d’interruption matérielle par le CPU. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Une valeur élevée de cette métrique peut indiquer une mauvaise configuration matérielle ou une charge réseau très importante. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme de chacun [0..num cores].

Ratio du temps consacré au traitement des requêtes d’interruptions matérielles sur chaque cœur CPU, identique à OSIrqTime mais non additionné entre les cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Cette valeur est similaire à OSIrqTime, mais divisée par le nombre de cœurs CPU afin d’être exprimée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de moyenner les valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs varie, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est définie, la quota CPU du cgroup divisée par sa période peut être utilisée à la place du nombre réel de cœurs CPU. Dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

La quantité de mémoire disponible, en octets, pouvant être utilisée par les programmes. Cette métrique est très proche de OSMemoryFreePlusCached. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

La quantité de mémoire utilisée par les tampons du noyau du système d’exploitation, en octets. Cette valeur devrait généralement être faible, et des valeurs élevées peuvent indiquer une mauvaise configuration du système d’exploitation. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Quantité de mémoire utilisée par le cache de pages du système d’exploitation, en octets. En général, la quasi-totalité de la mémoire disponible est utilisée par le cache de pages du système d’exploitation ; des valeurs élevées pour cette métrique sont normales et attendues. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

La quantité de mémoire libre, plus la mémoire du cache de pages du système d’exploitation sur l’hôte, en octets. Cette mémoire est disponible pour les programmes. La valeur doit être très proche de OSMemoryAvailable. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

La quantité de mémoire libre sur le système hôte, en octets. Cela n’inclut pas la mémoire utilisée par l’OS cache de pages, en octets. La mémoire du cache de pages est également utilisable par les programmes ; la valeur de cette métrique peut donc prêter à confusion. Préférez plutôt la métrique OSMemoryAvailable. Par commodité, nous fournissons également la métrique OSMemoryFreePlusCached, qui devrait être assez proche de OSMemoryAvailable. Voir aussi https://www.linuxatemyram.com/. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

La quantité de mémoire d’échange également chargée en RAM. Le swap doit être désactivé sur les systèmes de production. Si la valeur de cette métrique est élevée, cela indique une mauvaise configuration. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

Quantité totale de mémoire du système hôte, en octets.

Le rapport entre le temps pendant lequel le cœur CPU exécutait du code en espace utilisateur avec une priorité plus élevée. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme leur somme [0..num cores].

Proportion du temps pendant lequel chaque cœur CPU exécutait du code en espace utilisateur à priorité plus élevée, identique à OSNiceTime, mais non cumulée sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSNiceTime, mais divisée par le nombre de cœurs CPU afin d’être mesurée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est spécifiée, la Cgroup CPU quota divisée par sa période peut être utilisée à la place du nombre réel de cœurs CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Nombre total de fichiers ouverts sur la machine hôte. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Nombre de threads bloqués dans l’attente de la fin des E/S (man procfs). Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Le nombre de processus créés. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Le nombre de threads exécutables (en cours d’exécution ou prêts à être exécutés) par le système d’exploitation. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

Le rapport entre le temps passé à traiter les requêtes d’interruption logicielle sur le CPU. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. Une valeur élevée de cette métrique peut indiquer la présence d’un logiciel inefficace sur le système. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme de leurs valeurs [0..num cores].

Ratio du temps consacré au traitement des requêtes d’interruptions logicielles sur chaque cœur CPU, identique à OSSoftIrqTime mais non additionné sur l’ensemble des cœurs. Les clés correspondent aux numéros des cœurs CPU, et la valeur de chaque cœur est dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSSoftIrqTime, mais divisée par le nombre de cœurs du CPU afin d’être comprise dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est définie, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs du CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

La proportion du temps que le CPU passe à exécuter d'autres systèmes d'exploitation lorsqu'il fonctionne dans un environnement virtualisé. Il s'agit d'une métrique à l'échelle du système : elle inclut tous les processus de la machine hôte, pas seulement clickhouse-server. Tous les environnements virtualisés ne fournissent pas cette métrique, et la plupart ne la fournissent pas. La valeur pour un seul cœur CPU se situe dans l'intervalle [0..1]. La valeur pour l'ensemble des cœurs CPU est calculée comme leur somme [0..num cores].

Ratio du temps passé par chaque cœur CPU dans d’autres systèmes d’exploitation lors de l’exécution dans un environnement virtualisé, identique à OSStealTime mais non additionné sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSStealTime, mais divisée par le nombre de cœurs CPU afin d’être comprise dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est spécifiée, le quota CPU du cgroup divisé par sa période peut être utilisé à la place du nombre réel de cœurs CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

La proportion du temps pendant lequel le cœur CPU exécutait du code du noyau de l’OS (system). Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server. La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme la somme sur tous les cœurs [0..num cores].

Proportion du temps pendant lequel chaque cœur CPU exécutait du code du noyau de l’OS (système), identique à OSSystemTime, mais non cumulée sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSSystemTime, mais divisée par le nombre de cœurs CPU afin d’être exprimée dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, tout en obtenant une métrique moyenne d’utilisation des ressources. Si elle est définie, la Cgroup CPU quota divisée par sa période peut être utilisée à la place du nombre réel de cœurs CPU ; dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Le nombre total de threads « runnable », tel qu’il est vu par l’ordonnanceur du noyau du système d’exploitation.

Le nombre total de threads, vu par l’ordonnanceur du noyau du système d’exploitation.

La durée de fonctionnement du serveur hôte (la machine sur laquelle ClickHouse s’exécute), en secondes.

Le rapport du temps pendant lequel le cœur CPU exécutait du code en espace utilisateur. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus sur la machine hôte, et pas seulement clickhouse-server. Cela inclut également le temps pendant lequel le CPU était sous-utilisé pour des raisons internes au CPU (chargements mémoire, blocages du pipeline, erreurs de prédiction de branche, exécution d’un autre cœur SMT). La valeur pour un seul cœur CPU se situe dans l’intervalle [0..1]. La valeur pour l’ensemble des cœurs CPU est calculée comme leur somme [0..nombre de cœurs].

Ratio du temps pendant lequel chaque cœur CPU exécutait du code en espace utilisateur, identique à OSUserTime mais non additionné sur l’ensemble des cœurs. Les clés sont les numéros des cœurs CPU, et la valeur de chaque cœur se situe dans l’intervalle [0..1]. Il s’agit d’une métrique à l’échelle du système ; elle inclut tous les processus de la machine hôte, et pas seulement clickhouse-server.

La valeur est similaire à OSUserTime, mais divisée par le nombre de cœurs CPU afin d’être comprise dans l’intervalle [0..1], quel que soit le nombre de cœurs. Cela vous permet de calculer la moyenne des valeurs de cette métrique sur plusieurs serveurs d’un cluster, même si le nombre de cœurs n’est pas uniforme, et d’obtenir malgré tout une métrique moyenne d’utilisation des ressources. Si elle est définie, la Cgroup CPU quota divisée par sa période peut être utilisée à la place du nombre réel de cœurs CPU. Dans ce cas, la valeur de cette métrique peut dépasser 1 à certains moments.

Limite actuelle du cache de pages en espace utilisateur, en octets.

Nombre de connexions refusées pour le protocole de compatibilité PostgreSQL.

Nombre de threads dans le serveur du protocole de compatibilité PostgreSQL.

Limite totale de la file d’attente des signaux (une fois la valeur ProcessSignalQueueSize atteinte, des erreurs CANNOT_CREATE_TIMER peuvent se produire)

Taille de la file des signaux (signaux en attente, temporisateurs de profilage des requêtes)

Nombre de connexions rejetées pour l'endpoint Prometheus. Remarque : les endpoints Prometheus peuvent également être utilisés via les ports HTTP/HTTPS habituels.

Nombre de threads sur le serveur de l'endpoint Prometheus. Remarque : les endpoints Prometheus peuvent également être utilisés via les ports HTTP/HTTPS habituels.

Microsecondes de temps de blocage depuis la dernière mesure. La documentation upstream sur les métriques et leur interprétation est disponible à l'adresse https://docs.kernel.org/accounting/psi.html

Mémoire totale actuellement utilisée par toutes les requêtes en cours d’exécution sur le serveur, en octets. Utile pour attribuer la pression mémoire à la charge concurrente des requêtes.

Somme des pics de mémoire des requêtes par utilisateur pour tous les utilisateurs suivis dans ProcessList, en octets. Le pic de chaque utilisateur correspond au niveau maximal atteint par le memory tracker de cet utilisateur, qui est réinitialisé lorsque l'utilisateur n'a plus de requêtes en cours d'exécution. Il s'agit donc d'une agrégation des pics par utilisateur actuellement suivis, et non d'un pic unique à l'échelle du serveur pour l'ensemble des requêtes depuis le démarrage.

Efficacité expérimentale du chemin de lecture de ReaderExecutor : coût modélisé (ms) par MiB d’octets demandés au cours du dernier intervalle de mise à jour, à l’échelle de l’instance – rapport entre les deltas de ProfileEvents ReaderExecutorModeledCostMicroseconds et ReaderExecutorDeliveredBytes. Plus faible est préférable : le plancher de débit est d’environ 20 (lecture directe depuis une source), les accès au cache tendent vers 0, tandis que la surlecture et les connexions incomplètes l’augmentent. 0 signifie qu’aucune lecture par l’exécuteur n’a eu lieu pendant l’intervalle.

Écart maximal, en secondes, entre la part répliquée la plus récente et la part de données la plus récente restant à répliquer, dans l’ensemble des tables Replicated. Une valeur très élevée indique une réplique sans données.

Nombre maximal d’opérations INSERT en file d’attente (encore à répliquer) sur l’ensemble des tables Replicated.

Nombre maximal d’opérations de merge dans la file d’attente (encore à appliquer) sur l’ensemble des tables Replicated.

Taille maximale de la file d’attente (en nombre d’opérations telles que get, merge) sur l’ensemble des tables Replicated.

Différence maximale entre le retard d’une réplique et celui de la réplique la plus à jour de la même table, parmi les tables répliquées.

Somme des opérations INSERT dans la file d’attente (encore à répliquer) sur l’ensemble des tables Replicated.

Somme des opérations de fusion en file d’attente (encore à appliquer) pour l’ensemble des tables Replicated.

Taille cumulée des files d’attente (en nombre d’opérations comme get, merge) pour les tables Replicated.

Valeur du compteur de bas niveau éponyme du runtime de fibres Silk, cumulée depuis l’initialisation de l’ordonnanceur de fibres. Les compteurs dont le nom contient Time sont exprimés en nanosecondes.

Nombre de connexions TCP rejetées (sans TLS).

Nombre de connexions refusées pour le protocole TCP (avec TLS).

Nombre de threads sur le serveur pour le protocole TCP (avec TLS).

Nombre de threads sur le serveur du protocole TCP (sans TLS).

La température indiquée par chaque capteur, en ℃. Un capteur peut renvoyer une valeur peu réaliste. Les clés correspondent aux numéros des zones thermiques (source : /sys/class/thermal) ou aux noms des moniteurs matériels et de leurs capteurs (source : /sys/class/hwmon).

Volume total en octets (compressés, y compris les données et les index) stocké dans toutes les tables de la famille MergeTree.

Quantité totale d’octets (compressés, y compris les données et les indices) stockés dans les tables de la famille MergeTree de la base de données system.

La quantité totale de mémoire (en octets) utilisée par les granules d’index (seules les parts actives sont prises en compte).

La quantité totale de mémoire (en octets) allouée aux granules d’index (ne tient compte que des parts actives).

Nombre total de parts de données dans toutes les tables de la famille MergeTree. Des valeurs supérieures à 10 000 nuiront au temps de démarrage du serveur et peuvent indiquer un choix peu judicieux de la clé de partitionnement.

Nombre total de parts de données dans les tables de la famille MergeTree de la base de données system.

La quantité totale de mémoire (en octets) utilisée par les valeurs de la clé primaire (en ne tenant compte que des parts actives).

La quantité totale de mémoire (en octets) réservée aux valeurs de clé primaire (ne tient compte que des parts actives).

La quantité totale de mémoire (en octets) utilisée par la granularité d’index des projections (ne prend en compte que les parts actives).

La quantité totale de mémoire (en octets) réservée à la granularité de l’index de projection (ne prend en compte que les parts actives).

Quantité totale de mémoire (en octets) utilisée par les valeurs de clé primaire de la projection (ne tient compte que des parts actives).

Quantité totale de mémoire (en octets) réservée aux valeurs de la clé primaire de la projection (ne prend en compte que les parts actives).

Nombre total de lignes (enregistrements) stockées dans toutes les tables de la famille MergeTree.

Nombre total de lignes (enregistrements) stockées dans les tables de la famille MergeTree de la base de données system.

Quantité totale d’octets non compressés, telle qu’elle est indiquée par les checksums des parts, stockés dans toutes les tables de la famille MergeTree. Il s’agit de la même source que la colonne total_bytes_uncompressed de system.tables, et elle n’inclut pas les fichiers stockés sans compression, tels que les marks et les index de clé primaire.

Quantité totale d’octets non compressés, telle qu’indiquée par les sommes de contrôle des parts, stockés dans les tables de la famille MergeTree de la base de données system. Elle provient de la même source que la colonne total_bytes_uncompressed de system.tables et n’inclut pas les fichiers stockés sans compression, tels que les marks et les index de clé primaire.

Mémoire suivie par ClickHouse (elle devrait être égale à la métrique MemoryTracking), en octets.

Somme des tampons par thread contenant les allocations et désallocations récentes qui n’ont pas encore été propagées à TrackedMemory.

Le temps de fonctionnement du serveur, en secondes. Il comprend le temps passé à initialiser le serveur avant qu’il n’accepte les connexions.

Le nombre maximal de mappages mémoire dont un processus peut disposer (/proc/sys/vm/max_map_count).

Le nombre actuel de mappages mémoire du processus (/proc/self/maps). S’il est proche du maximum (VMMaxMapCount), vous devez augmenter la valeur de vm.max_map_count dans /etc/sysctl.conf

Le dernier ZXID observé par la session client ZooKeeper en cours. Cette valeur augmente de façon monotone à mesure que le client observe les transactions de ZooKeeper.

Voir aussi

• Monitoring — Concepts de base de la supervision de ClickHouse.
• system.metrics — Contient des métriques calculées instantanément.
• system.events — Contient les événements qui se sont produits.
• system.metric_log — Contient l'historique des valeurs de métriques des tables system.metrics et system.events.