> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Table système contenant des métriques calculées périodiquement en arrière-plan, par exemple la quantité de RAM utilisée.

# system.asynchronous_metrics

<Info>
  **Interroger dans ClickHouse Cloud**

  Les données de cette table système sont stockées localement sur chaque nœud de ClickHouse Cloud. Pour obtenir une vue complète de l’ensemble des données, il faut donc utiliser la fonction `clusterAllReplicas`. Consultez [cette page](/fr/reference/system-tables/overview#system-tables-in-clickhouse-cloud) pour plus de détails.
</Info>

<div id="description">
  ## Description
</div>

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

<div id="columns">
  ## Colonnes
</div>

* `metric` ([String](/fr/reference/data-types/string)) — Nom de la métrique.
* `value` ([Float64](/fr/reference/data-types/float)) — Valeur de la métrique.
* `description` ([String](/fr/reference/data-types/string) - Description de la métrique)

<div id="example">
  ## Exemple
</div>

```sql theme={null}
SELECT * FROM system.asynchronous_metrics LIMIT 10
```

```text theme={null}
┌─metric──────────────────────────────────┬──────value─┬─description────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ AsynchronousMetricsCalculationTimeSpent │ 0.00179053 │ Time in seconds spent for calculation of asynchronous metrics (this is the overhead of asynchronous metrics).                                                                                                                                              │
│ NumberOfDetachedByUserParts             │          0 │ The total number of parts detached from MergeTree tables by users with the `ALTER TABLE DETACH` query (as opposed to unexpected, broken or ignored parts). The server does not care about detached parts and they can be removed.                          │
│ NumberOfDetachedParts                   │          0 │ The total number of parts detached from MergeTree tables. A part can be detached by a user with the `ALTER TABLE DETACH` query or by the server itself it the part is broken, unexpected or unneeded. The server does not care about detached parts and they can be removed. │
│ TotalRowsOfMergeTreeTables              │    2781309 │ Total amount of rows (records) stored in all tables of MergeTree family.                                                                                                                                                                                   │
│ TotalBytesOfMergeTreeTables             │    7741926 │ Total amount of bytes (compressed, including data and indices) stored in all tables of MergeTree family.                                                                                                                                                   │
│ NumberOfTables                          │         93 │ Total number of tables summed across the databases on the server, excluding the databases that cannot contain MergeTree tables. The excluded database engines are those who generate the set of tables on the fly, like `Lazy`, `MySQL`, `PostgreSQL`, `SQlite`. │
│ NumberOfDatabases                       │          6 │ Total number of databases on the server.                                                                                                                                                                                                                   │
│ MaxPartCountForPartition                │          6 │ Maximum number of parts per partition across all partitions of all tables of MergeTree family. Values larger than 300 indicates misconfiguration, overload, or massive data loading.                                                                       │
│ ReplicasSumMergesInQueue                │          0 │ Sum of merge operations in the queue (still to be applied) across Replicated tables.                                                                                                                                                                       │
│ ReplicasSumInsertsInQueue               │          0 │ Sum of INSERT operations in the queue (still to be replicated) across Replicated tables.                                                                                                                                                                   │
└─────────────────────────────────────────┴────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```

<div id="metric-descriptions">
  ## Descriptions des métriques
</div>

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étriques qui incluent un suffixe variable (par disque, par CPU, par interface, ...) sont représentés par l’espace réservé `*name*` ; le serveur en cours d’exécution les expose avec le suffixe concret substitué.

<div id="asynchronousheavymetricscalculationtimespent">
  ### AsynchronousHeavyMetricsCalculationTimeSpent
</div>

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).

<div id="asynchronousheavymetricsupdateinterval">
  ### AsynchronousHeavyMetricsUpdateInterval
</div>

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

<div id="asynchronousmetricscalculationtimespent">
  ### AsynchronousMetricsCalculationTimeSpent
</div>

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

<div id="asynchronousmetricsupdateinterval">
  ### AsynchronousMetricsUpdateInterval
</div>

Intervalle de mise à jour des métriques

<div id="asyncloggingmetric_firstqueuesize">
  ### AsyncLogging*metric\_first*QueueSize
</div>

Nombre de messages asynchrones en file d’attente pour la journalisation sur ce canal

<div id="blockactivetime_name">
  ### BlockActiveTime\_*name*
</div>

Temps, en secondes, pendant lequel le périphérique de blocs a eu des requêtes d’E/S en file d’attente. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockactivetimeperop_name">
  ### BlockActiveTimePerOp\_*name*
</div>

Semblable aux métriques `BlockActiveTime`, mais la valeur est divisée par le nombre d’opérations d’E/S afin de calculer le temps par opération.

<div id="blockdiscardbytes_name">
  ### BlockDiscardBytes\_*name*
</div>

Nombre d’octets rejetés sur le périphérique de blocs. Ces opérations concernent les SSD. Les opérations de rejet ne sont pas utilisées par ClickHouse, mais peuvent l’être par d’autres processus du système. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockdiscardmerges_name">
  ### BlockDiscardMerges\_*name*
</div>

Nombre d’opérations de discard demandées au 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. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockdiscardops_name">
  ### BlockDiscardOps\_*name*
</div>

Nombre d’opérations de discard demandées au périphérique de blocs. Ces opérations concernent surtout 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. 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. Source : `/sys/block`. Voir [https://www.kernel.org/doc/Documentation/block/stat.txt](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockdiscardtime_name">
  ### BlockDiscardTime\_*name*
</div>

Temps, en secondes, passé dans les opérations de discard demandées au périphérique de blocs, cumulé sur l’ensemble des opérations. Ces opérations concernent 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. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockinflightops_name">
  ### BlockInFlightOps\_*name*
</div>

Cette valeur indique le nombre de requêtes d’E/S qui ont été envoyées au pilote du périphérique, mais ne sont pas encore terminées. Elle n’inclut pas les requêtes d’E/S qui se trouvent dans la file d’attente, mais n’ont pas encore été envoyées au pilote du périphérique. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockqueuetime_name">
  ### BlockQueueTime\_*name*
</div>

Cette valeur comptabilise le nombre de millisecondes durant lesquelles les requêtes d’E/S ont été en attente sur ce périphérique de blocs. S’il y a plusieurs requêtes d’E/S en attente, cette valeur augmente du produit du nombre de millisecondes par le nombre de requêtes en attente. Il s’agit d’une métrique à l’échelle du système : elle inclut tous les processus de la machine hôte, et pas uniquement clickhouse-server. Source : `/sys/block`. Voir [https://www.kernel.org/doc/Documentation/block/stat.txt](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockqueuetimeperop_name">
  ### BlockQueueTimePerOp\_*name*
</div>

Similaire aux métriques `BlockQueueTime`, mais la valeur est divisée par le nombre d’opérations d’E/S afin de calculer le temps par opération.

<div id="blockreadbytes_name">
  ### BlockReadBytes\_*name*
</div>

Nombre d’octets lus depuis le 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 du système d’exploitation, qui réduit les E/S. Il s’agit d’une métrique à l’échelle de tout le 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockreadmerges_name">
  ### BlockReadMerges\_*name*
</div>

Nombre d'opérations de lecture demandées au périphérique de blocs et fusionnées par le planificateur d'E/S 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. Source : `/sys/block`. Voir [https://www.kernel.org/doc/Documentation/block/stat.txt](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockreadops_name">
  ### BlockReadOps\_*name*
</div>

Nombre d’opérations de lecture demandées au périphérique de blocs. Il s’agit d’une métrique système à l’échelle de l’hôte : 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockreadtime_name">
  ### BlockReadTime\_*name*
</div>

Temps en secondes passé dans les opérations de lecture demandées au périphérique de blocs, cumulé sur l’ensemble des opérations. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockwritebytes_name">
  ### BlockWriteBytes\_*name*
</div>

Nombre d’octets écrits sur le 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. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockwritemerges_name">
  ### BlockWriteMerges\_*name*
</div>

Nombre d’opérations d’écriture demandées au périphérique de blocs et fusionnées par l’ordonnanceur d’E/S 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. Source : `/sys/block`. Voir [https://www.kernel.org/doc/Documentation/block/stat.txt](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockwriteops_name">
  ### BlockWriteOps\_*name*
</div>

Nombre d’opérations d’écriture demandées au périphérique 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="blockwritetime_name">
  ### BlockWriteTime\_*name*
</div>

Temps passé, en secondes, dans les opérations d’écriture demandées au périphérique de blocs, cumulé sur l’ensemble des opérations. 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](https://www.kernel.org/doc/Documentation/block/stat.txt)

<div id="cgroupmaxcpu">
  ### CGroupMaxCPU
</div>

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

<div id="cgroupmemorytotal">
  ### Mémoire totale du CGroup
</div>

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.

<div id="cgroupmemoryused">
  ### CGroupMemoryUsed
</div>

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.

<div id="cgroupmemoryusedwithoutpagecache">
  ### CGroupMemoryUsedWithoutPageCache
</div>

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.

<div id="cgroupsystemtime">
  ### CGroupSystemTime
</div>

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

<div id="cgroupsystemtimenormalized">
  ### CGroupSystemTimeNormalized
</div>

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.

<div id="cgroupusertime">
  ### CGroupUserTime
</div>

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).

<div id="cgroupusertimenormalized">
  ### CGroupUserTimeNormalized
</div>

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.

<div id="cpufrequencymhz_core_id">
  ### CPUFrequencyMHz\_*core\_id*
</div>

La fréquence actuelle du CPU, en MHz. La plupart des CPU modernes ajustent dynamiquement leur fréquence pour économiser de l'énergie et profiter du mode Turbo Boost.

<div id="dictionarymaxupdatedelay">
  ### DictionaryMaxUpdateDelay
</div>

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

<div id="dictionarytotalfailedupdates">
  ### DictionaryTotalFailedUpdates
</div>

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

<div id="diskavailable_name">
  ### DiskAvailable\_*name*
</div>

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

<div id="diskgetobjectthrottleravailable_name">
  ### DiskGetObjectThrottlerAvailable\_*name*
</div>

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

<div id="diskgetobjectthrottlerrps_name">
  ### DiskGetObjectThrottlerRPS\_*name*
</div>

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

<div id="diskputobjectthrottleravailable_name">
  ### DiskPutObjectThrottlerAvailable\_*name*
</div>

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

<div id="diskputobjectthrottlerrps_name">
  ### DiskPutObjectThrottlerRPS\_*name*
</div>

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

<div id="disktotal_name">
  ### DiskTotal\_*name*
</div>

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

<div id="diskunreserved_name">
  ### DiskUnreserved\_*name*
</div>

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

<div id="diskused_name">
  ### DiskUsed\_*name*
</div>

Octets utilisés sur le disque (système de fichiers virtuel). Les systèmes de fichiers distants ne fournissent pas toujours cette information.

<div id="edaci_correctable">
  ### EDAC*i*\_Correctable
</div>

Le nombre d’erreurs mémoire ECC corrigeables. 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/`

<div id="edaci_uncorrectable">
  ### EDAC*i*\_Uncorrectable
</div>

Le nombre d’erreurs mémoire ECC irrécupérables. 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/`

<div id="filesystemcachebytes">
  ### Octets du cache du système de fichiers
</div>

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

<div id="filesystemcachecapacity">
  ### FilesystemCacheCapacity
</div>

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

<div id="filesystemcachefiles">
  ### FilesystemCacheFiles
</div>

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

<div id="filesystemlogspathavailablebytes">
  ### FilesystemLogsPathAvailableBytes
</div>

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.

<div id="filesystemlogspathavailableinodes">
  ### FilesystemLogsPathAvailableINodes
</div>

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

<div id="filesystemlogspathtotalbytes">
  ### FilesystemLogsPathTotalBytes
</div>

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.

<div id="filesystemlogspathtotalinodes">
  ### FilesystemLogsPathTotalINodes
</div>

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

<div id="filesystemlogspathusedbytes">
  ### FilesystemLogsPathUsedBytes
</div>

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

<div id="filesystemlogspathusedinodes">
  ### FilesystemLogsPathUsedINodes
</div>

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

<div id="filesystemmainpathavailablebytes">
  ### FilesystemMainPathAvailableBytes
</div>

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

<div id="filesystemmainpathavailableinodes">
  ### FilesystemMainPathAvailableINodes
</div>

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.

<div id="filesystemmainpathtotalbytes">
  ### FilesystemMainPathTotalBytes
</div>

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

<div id="filesystemmainpathtotalinodes">
  ### FilesystemMainPathTotalINodes
</div>

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.

<div id="filesystemmainpathusedbytes">
  ### FilesystemMainPathUsedBytes
</div>

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

<div id="filesystemmainpathusedinodes">
  ### Inodes utilisés du chemin principal du système de fichiers
</div>

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.

<div id="grpcrejectedconnections">
  ### GRPCRejectedConnections
</div>

Nombre de connexions rejetées pour le protocole GRPC.

<div id="grpcthreads">
  ### GRPCThreads
</div>

Nombre de threads du serveur du protocole GRPC.

<div id="hashtablestatscacheentries">
  ### HashTableStatsCacheEntries
</div>

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.

<div id="hashtablestatscachehits">
  ### HashTableStatsCacheHits
</div>

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

<div id="hashtablestatscachemisses">
  ### HashTableStatsCacheMisses
</div>

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

<div id="httpconnectionpoolgroup_nametcprcvbuftotalbytes">
  ### HTTPConnectionPool*group\_name*TCPRcvBufTotalBytes
</div>

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

<div id="httpconnectionpoolgroup_nametcpsndbuftotalbytes">
  ### HTTPConnectionPool*group\_name*TCPSndBufTotalBytes
</div>

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

<div id="httprejectedconnections">
  ### HTTPRejectedConnections
</div>

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

<div id="httpsecurerejectedconnections">
  ### HTTPSecureRejectedConnections
</div>

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

<div id="httpsecurethreads">
  ### HTTPSecureThreads
</div>

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

<div id="httpthreads">
  ### HTTPThreads
</div>

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

<div id="interserverrejectedconnections">
  ### InterserverRejectedConnections
</div>

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

<div id="interserversecurerejectedconnections">
  ### InterserverSecureRejectedConnections
</div>

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

<div id="interserversecurethreads">
  ### InterserverSecureThreads
</div>

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

<div id="interserverthreads">
  ### InterserverThreads
</div>

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

<div id="jemallocactive">
  ### jemalloc.active
</div>

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

<div id="jemallocallocated">
  ### jemalloc.allocated
</div>

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

<div id="jemallocarenasalldirty_purged">
  ### jemalloc.arenas.all.dirty\_purged
</div>

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

<div id="jemallocarenasallmuzzy_purged">
  ### jemalloc.arenas.all.muzzy\_purged
</div>

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

<div id="jemallocarenasallpactive">
  ### jemalloc.arenas.all.pactive
</div>

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

<div id="jemallocarenasallpdirty">
  ### jemalloc.arenas.all.pdirty
</div>

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

<div id="jemallocarenasallpmuzzy">
  ### jemalloc.arenas.all.pmuzzy
</div>

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

<div id="jemallocarenasdirty_decay_ms">
  ### jemalloc.arenas.dirty\_decay\_ms
</div>

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

<div id="jemallocbackground_threadnum_runs">
  ### jemalloc.background\_thread.num\_runs
</div>

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

<div id="jemallocbackground_threadnum_threads">
  ### jemalloc.background\_thread.num\_threads
</div>

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

<div id="jemallocbackground_threadrun_intervals">
  ### jemalloc.background\_thread.run\_intervals
</div>

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

<div id="jemalloccache_arenapactive">
  ### jemalloc.cache\_arena.pactive
</div>

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

<div id="jemalloccache_arenapdirty">
  ### jemalloc.cache\_arena.pdirty
</div>

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

<div id="jemallocepoch">
  ### jemalloc.epoch
</div>

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`.

<div id="jemallocmapped">
  ### jemalloc.mapped
</div>

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

<div id="jemallocmergetree_arenaactive_bytes">
  ### jemalloc.mergetree\_arena.active\_bytes
</div>

Octets actifs dans l’arène jemalloc MergeTree dédiée. Contient l’état du tas MergeTree à long terme : les métadonnées par part (`NamesAndTypesList`, `SerializationInfoByName`, la map `serializations`, `column_name_to_position`, 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) ainsi que les métadonnées par table (clones de `StorageInMemoryMetadata` / `ColumnsDescription` / `VirtualColumnsDescription` initialisés par `setProperties`, l’agrégation `serialization_hints` et le `columns_descriptions_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 — elles peuvent aussi se trouver à la place dans `PrimaryIndexCacheBytes`, qui appartient à l’arène de cache et n’est pas compté ici).

<div id="jemallocmergetree_arenadirty_bytes">
  ### jemalloc.mergetree\_arena.dirty\_bytes
</div>

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

<div id="jemallocmergetree_arenapactive">
  ### jemalloc.mergetree\_arena.pactive
</div>

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

<div id="jemallocmergetree_arenapdirty">
  ### jemalloc.mergetree\_arena.pdirty
</div>

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

<div id="jemallocmetadata">
  ### jemalloc.metadata
</div>

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

<div id="jemallocmetadata_thp">
  ### jemalloc.metadata\_thp
</div>

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

<div id="jemallocprofactive">
  ### jemalloc.prof.active
</div>

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

<div id="jemallocproflg_sample">
  ### jemalloc.prof.lg\_sample
</div>

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

<div id="jemallocprofthread_active_init">
  ### jemalloc.prof.thread\_active\_init
</div>

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

<div id="jemallocresident">
  ### jemalloc.resident
</div>

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

<div id="jemallocretained">
  ### jemalloc.retained
</div>

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

<div id="jitter">
  ### Jitter
</div>

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.

<div id="keeperapproximatedatasize">
  ### KeeperApproximateDataSize
</div>

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

<div id="keeperavglatency">
  ### KeeperAvgLatency
</div>

Latence moyenne des requêtes de ClickHouse Keeper.

<div id="keepercommitlogscacheentries">
  ### KeeperCommitLogsCacheEntries
</div>

Nombre d’entrées stockées dans le cache en mémoire pour les prochains logs à valider

<div id="keepercommitlogscachesize">
  ### KeeperCommitLogsCacheSize
</div>

Taille totale du cache en mémoire des prochains logs à valider

<div id="keeperephemeralscount">
  ### KeeperEphemeralsCount
</div>

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

<div id="keeperfollowers">
  ### KeeperFollowers
</div>

Le nombre de followers de ClickHouse Keeper.

<div id="keeperisexceedingmemorysoftlimithit">
  ### KeeperIsExceedingMemorySoftLimitHit
</div>

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

<div id="keeperisfollower">
  ### KeeperIsFollower
</div>

1 si ClickHouse Keeper est un follower, 0 sinon.

<div id="keeperisleader">
  ### KeeperIsLeader
</div>

1 si ClickHouse Keeper est leader, 0 sinon.

<div id="keeperisobserver">
  ### KeeperIsObserver
</div>

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

<div id="keeperisstandalone">
  ### KeeperIsStandalone
</div>

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

<div id="keeperkeyarenasize">
  ### KeeperKeyArenaSize
</div>

La taille, en octets, de l’arène mémoire réservée aux clés dans ClickHouse Keeper.

<div id="keeperlastcommittedlogidx">
  ### KeeperLastCommittedLogIdx
</div>

Index du dernier log validé dans ClickHouse Keeper.

<div id="keeperlastlogidx">
  ### KeeperLastLogIdx
</div>

Index du dernier log stocké dans ClickHouse Keeper.

<div id="keeperlastlogterm">
  ### KeeperLastLogTerm
</div>

Terme Raft du dernier log enregistré dans ClickHouse Keeper.

<div id="keeperlastsnapshotidx">
  ### KeeperLastSnapshotIdx
</div>

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

<div id="keeperlatestlogscacheentries">
  ### KeeperLatestLogsCacheEntries
</div>

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

<div id="keeperlatestlogscachesize">
  ### KeeperLatestLogsCacheSize
</div>

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

<div id="keeperlatestsnapshotsize">
  ### KeeperLatestSnapshotSize
</div>

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

<div id="keepermaxfiledescriptorcount">
  ### KeeperMaxFileDescriptorCount
</div>

Le nombre maximal de descripteurs de fichier ouverts dans ClickHouse Keeper.

<div id="keepermaxlatency">
  ### KeeperMaxLatency
</div>

Latence maximale des requêtes de ClickHouse Keeper.

<div id="keeperminlatency">
  ### KeeperMinLatency
</div>

Latence minimale des requêtes de ClickHouse Keeper.

<div id="keeperopenfiledescriptorcount">
  ### KeeperOpenFileDescriptorCount
</div>

Le nombre de descripteurs de fichiers ouverts dans ClickHouse Keeper.

<div id="keeperpacketsreceived">
  ### KeeperPacketsReceived
</div>

Nombre de paquets reçus par ClickHouse Keeper.

<div id="keeperpacketssent">
  ### KeeperPacketsSent
</div>

Nombre de paquets envoyés par ClickHouse Keeper.

<div id="keeperpathswatched">
  ### KeeperPathsWatched
</div>

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

<div id="keepersessionwithwatches">
  ### KeeperSessionWithWatches
</div>

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

<div id="keepersyncedfollowers">
  ### KeeperSyncedFollowers
</div>

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

<div id="keepertargetcommitlogidx">
  ### KeeperTargetCommitLogIdx
</div>

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

<div id="keepertcprejectedconnections">
  ### KeeperTCPRejectedConnections
</div>

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

<div id="keepertcpsecurerejectedconnections">
  ### KeeperTCPSecureRejectedConnections
</div>

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

<div id="keepertcpsecurethreads">
  ### KeeperTCPSecureThreads
</div>

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

<div id="keepertcpthreads">
  ### KeeperTCPThreads
</div>

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

<div id="keeperwatchcount">
  ### KeeperWatchCount
</div>

Le nombre de watches dans ClickHouse Keeper.

<div id="keeperznodecount">
  ### KeeperZnodeCount
</div>

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

<div id="keeperzxid">
  ### KeeperZxid
</div>

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

<div id="loadaverage1">
  ### LoadAverage1
</div>

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.

<div id="loadaverage15">
  ### LoadAverage15
</div>

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.

<div id="loadaverage5">
  ### LoadAverage5
</div>

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.

<div id="longestrunningmerge">
  ### LongestRunningMerge
</div>

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

<div id="maxpartcountforpartition">
  ### MaxPartCountForPartition
</div>

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.

<div id="memorycode">
  ### MemoryCode
</div>

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

<div id="memorydataandstack">
  ### MemoryDataAndStack
</div>

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.

<div id="memoryresident">
  ### MemoryResident
</div>

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

<div id="memoryresidentmax">
  ### MemoryResidentMax
</div>

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

<div id="memoryresidentwithoutpagecache">
  ### MemoryResidentWithoutPageCache
</div>

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.

<div id="memoryshared">
  ### MemoryShared
</div>

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é.

<div id="memoryvirtual">
  ### MemoryVirtual
</div>

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.

<div id="mysqlrejectedconnections">
  ### MySQLRejectedConnections
</div>

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

<div id="mysqlthreads">
  ### MySQLThreads
</div>

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

<div id="networkreceivebytes_interface_name">
  ### NetworkReceiveBytes\_*interface\_name*
</div>

Nombre d’octets reçus via l’interface 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.

<div id="networkreceivedrop_interface_name">
  ### NetworkReceiveDrop\_*interface\_name*
</div>

Nombre d’octets de paquets rejetés lors de leur réception via l’interface 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.

<div id="networkreceiveerrors_interface_name">
  ### NetworkReceiveErrors\_*interface\_name*
</div>

Nombre de fois qu'une error s'est produite lors de la réception via l'interface 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.

<div id="networkreceivepackets_interface_name">
  ### NetworkReceivePackets\_*interface\_name*
</div>

Nombre de paquets réseau reçus via l’interface 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.

<div id="networksendbytes_interface_name">
  ### NetworkSendBytes\_*interface\_name*
</div>

Nombre d’octets envoyés par l’interface 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.

<div id="networksenddrop_interface_name">
  ### NetworkSendDrop\_*interface\_name*
</div>

Nombre de fois où un paquet a été abandonné lors de l’envoi via l’interface 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.

<div id="networksenderrors_interface_name">
  ### NetworkSendErrors\_*interface\_name*
</div>

Nombre de fois qu’une error (par ex. une retransmission TCP) s’est produite lors de l’envoi via l’interface réseau. Il s’agit d’une Metric à l’échelle du système ; elle inclut tous les processus sur la machine hôte, pas seulement clickhouse-server.

<div id="networksendpackets_interface_name">
  ### NetworkSendPackets\_*interface\_name*
</div>

Nombre de paquets réseau envoyés via l’interface 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.

<div id="networktcpreceivequeue">
  ### NetworkTCPReceiveQueue
</div>

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

<div id="networktcpsocketremoteaddresses">
  ### NetworkTCPSocketRemoteAddresses
</div>

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

<div id="networktcpsockets">
  ### NetworkTCPSockets
</div>

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

<div id="networktcpsockets_description">
  ### NetworkTCPSockets\_*description*
</div>

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

<div id="networktcptransmitqueue">
  ### NetworkTCPTransmitQueue
</div>

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

<div id="networktcpunrecoveredretransmits">
  ### NetworkTCPUnrecoveredRetransmits
</div>

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.

<div id="numberofdatabases">
  ### NumberOfDatabases
</div>

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

<div id="numberofdetachedbyuserparts">
  ### NumberOfDetachedByUserParts
</div>

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.

<div id="numberofdetachedparts">
  ### NumberOfDetachedParts
</div>

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.

<div id="numberofpendingmutations">
  ### NumberOfPendingMutations
</div>

Le nombre total de mutations restant à appliquer.

<div id="numberofpendingmutationsoverexecutiontime">
  ### NombreDeMutationsEnAttenteAu-delàDeLaDuréeDExécution
</div>

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.

<div id="numberoftables">
  ### NumberOfTables
</div>

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`.

<div id="numberoftablessystem">
  ### NumberOfTablesSystem
</div>

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

<div id="oscontextswitches">
  ### OSContextSwitches
</div>

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.

<div id="oscpuoverload">
  ### OSCPUOverload
</div>

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.

<div id="osguestnicetimecpu_suffix">
  ### OSGuestNiceTime*cpu\_suffix*
</div>

Le rapport du temps passé à exécuter un CPU virtuel pour des systèmes d’exploitation invités sous le contrôle du noyau 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].

<div id="osguestnicetimenormalized">
  ### OSGuestNiceTimeNormalized
</div>

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.

<div id="osguesttimecpu_suffix">
  ### OSGuestTime*cpu\_suffix*
</div>

Le ratio du temps passé à exécuter un CPU virtuel pour des systèmes d’exploitation invités sous le contrôle du noyau Linux (voir `man procfs`). Il s’agit d’une métrique système globale : 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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme la somme de leurs valeurs \[0..num cores].

<div id="osguesttimenormalized">
  ### OSGuestTimeNormalized
</div>

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.

<div id="osidletimecpu_suffix">
  ### OSIdleTime*cpu\_suffix*
</div>

Le ratio du temps pendant lequel le cœur du CPU était inactif (sans même être prêt à exécuter un processus en attente d’IO), du point de vue du noyau 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 de CPU est comprise dans l’intervalle \[0..1]. La valeur pour tous les cœurs de CPU est calculée comme la somme de l’ensemble des cœurs \[0..num cores].

<div id="osidletimenormalized">
  ### OSIdleTimeNormalized
</div>

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.

<div id="osinterrupts">
  ### OSInterrupts
</div>

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.

<div id="osiowaittimecpu_suffix">
  ### OSIOWaitTime*cpu\_suffix*
</div>

Rapport entre le temps pendant lequel le cœur CPU n’exécutait pas de code et le temps pendant lequel le noyau 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].

<div id="osiowaittimenormalized">
  ### OSIOWaitTimeNormalized
</div>

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.

<div id="osirqtimecpu_suffix">
  ### OSIrqTime*cpu\_suffix*
</div>

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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme la somme de chacun \[0..num cores].

<div id="osirqtimenormalized">
  ### OSIrqTimeNormalized
</div>

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.

<div id="osmemoryavailable">
  ### Mémoire OS disponible
</div>

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.

<div id="osmemorybuffers">
  ### OSMemoryBuffers
</div>

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.

<div id="osmemorycached">
  ### OSMemoryCached
</div>

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.

<div id="osmemoryfreepluscached">
  ### OSMemoryFreePlusCached
</div>

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.

<div id="osmemoryfreewithoutcached">
  ### OSMemoryFreeWithoutCached
</div>

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/](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.

<div id="osmemoryswapcached">
  ### OSMemorySwapCached
</div>

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.

<div id="osmemorytotal">
  ### OSMemoryTotal
</div>

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

<div id="osnicetimecpu_suffix">
  ### OSNiceTime*cpu\_suffix*
</div>

Le rapport entre le temps pendant lequel le cœur de 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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme leur somme \[0..num cores].

<div id="osnicetimenormalized">
  ### OSNiceTimeNormalized
</div>

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.

<div id="osopenfiles">
  ### OSOpenFiles
</div>

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.

<div id="osprocessesblocked">
  ### OSProcessesBlocked
</div>

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.

<div id="osprocessescreated">
  ### OSProcessesCreated
</div>

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`.

<div id="osprocessesrunning">
  ### ProcessusOSEnCours
</div>

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.

<div id="ossoftirqtimecpu_suffix">
  ### OSSoftIrqTime*cpu\_suffix*
</div>

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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme la somme de leurs valeurs \[0..num cores].

<div id="ossoftirqtimenormalized">
  ### OSSoftIrqTimeNormalized
</div>

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.

<div id="osstealtimecpu_suffix">
  ### OSStealTime*cpu\_suffix*
</div>

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 de processeur se situe dans l'intervalle \[0..1]. La valeur pour l'ensemble des cœurs de processeur est calculée comme leur somme \[0..num cores].

<div id="osstealtimenormalized">
  ### OSStealTimeNormalized
</div>

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.

<div id="ossystemtimecpu_suffix">
  ### OSSystemTime*cpu\_suffix*
</div>

La proportion du temps pendant lequel le cœur de CPU exécutait du code du noyau du système d’exploitation (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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme la somme sur tous les cœurs \[0..num cores].

<div id="ossystemtimenormalized">
  ### OSSystemTimeNormalized
</div>

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.

<div id="osthreadsrunnable">
  ### OSThreadsRunnable
</div>

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

<div id="osthreadstotal">
  ### OSThreadsTotal
</div>

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

<div id="osuptime">
  ### OSUptime
</div>

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

<div id="osusertimecpu_suffix">
  ### OSUserTime*cpu\_suffix*
</div>

Le rapport du temps pendant lequel le cœur de 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 de CPU se situe dans l’intervalle \[0..1]. La valeur pour l’ensemble des cœurs de CPU est calculée comme leur somme \[0..nombre de cœurs].

<div id="osusertimenormalized">
  ### OSUserTimeNormalized
</div>

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.

<div id="pagecachemaxbytes">
  ### PageCacheMaxBytes
</div>

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

<div id="postgresqlrejectedconnections">
  ### PostgreSQLRejectedConnections
</div>

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

<div id="postgresqlthreads">
  ### PostgreSQLThreads
</div>

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

<div id="processsignalqueuelimit">
  ### Limite de la file d’attente des signaux
</div>

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

<div id="processsignalqueuesize">
  ### ProcessSignalQueueSize
</div>

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

<div id="prometheusrejectedconnections">
  ### PrometheusRejectedConnections
</div>

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

<div id="prometheusthreads">
  ### PrometheusThreads
</div>

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.

<div id="psi_type_stall_type">
  ### PSI\_*type*\_*stall\_type*
</div>

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](https://docs.kernel.org/accounting/psi.html)

<div id="queriesmemoryusage">
  ### QueriesMemoryUsage
</div>

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.

<div id="queriespeakmemoryusage">
  ### Utilisation mémoire maximale des requêtes
</div>

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.

<div id="replicasmaxabsolutedelay">
  ### ReplicasMaxAbsoluteDelay
</div>

É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.

<div id="replicasmaxinsertsinqueue">
  ### ReplicasMaxInsertsInQueue
</div>

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

<div id="replicasmaxmergesinqueue">
  ### ReplicasMaxMergesInQueue
</div>

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

<div id="replicasmaxqueuesize">
  ### ReplicasMaxQueueSize
</div>

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

<div id="replicasmaxrelativedelay">
  ### ReplicasMaxRelativeDelay
</div>

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.

<div id="replicassuminsertsinqueue">
  ### ReplicasSumInsertsInQueue
</div>

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

<div id="replicassummergesinqueue">
  ### ReplicasSumMergesInQueue
</div>

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

<div id="replicassumqueuesize">
  ### ReplicasSumQueueSize
</div>

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

<div id="tcprejectedconnections">
  ### TCPRejectedConnections
</div>

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

<div id="tcpsecurerejectedconnections">
  ### TCPSecureRejectedConnections
</div>

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

<div id="tcpsecurethreads">
  ### TCPSecureThreads
</div>

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

<div id="tcpthreads">
  ### TCPThreads
</div>

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

<div id="temperaturei">
  ### Température*i*
</div>

La température du périphérique correspondant en ℃. Un capteur peut renvoyer une valeur irréaliste. Source : `/sys/class/thermal`

<div id="temperature_hwmon_name">
  ### Temperature\_*hwmon\_name*
</div>

La température mesurée par le capteur matériel correspondant, en ℃. Un capteur peut renvoyer une valeur aberrante. Source : `/sys/class/hwmon`

<div id="temperature_hwmon_name_sensor_name">
  ### Temperature\_*hwmon\_name*\_*sensor\_name*
</div>

Température relevée par le moniteur matériel et le capteur correspondants, en ℃. Un capteur peut renvoyer une valeur irréaliste. Source : `/sys/class/hwmon`

<div id="totalbytesofmergetreetables">
  ### TotalBytesOfMergeTreeTables
</div>

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

<div id="totalbytesofmergetreetablessystem">
  ### TotalBytesOfMergeTreeTablesSystem
</div>

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.

<div id="totalindexgranularitybytesinmemory">
  ### TotalIndexGranularityBytesInMemory
</div>

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

<div id="totalindexgranularitybytesinmemoryallocated">
  ### TotalIndexGranularityBytesInMemoryAllocated
</div>

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

<div id="totalpartsofmergetreetables">
  ### Nombre total de parts de données des tables MergeTree
</div>

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.

<div id="totalpartsofmergetreetablessystem">
  ### TotalPartsOfMergeTreeTablesSystem
</div>

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

<div id="totalprimarykeybytesinmemory">
  ### TotalPrimaryKeyBytesInMemory
</div>

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).

<div id="totalprimarykeybytesinmemoryallocated">
  ### TotalPrimaryKeyBytesInMemoryAllocated
</div>

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

<div id="totalprojectionindexgranularitybytesinmemory">
  ### TotalProjectionIndexGranularityBytesInMemory
</div>

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).

<div id="totalprojectionindexgranularitybytesinmemoryallocated">
  ### TotalProjectionIndexGranularityBytesInMemoryAllocated
</div>

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).

<div id="totalprojectionprimarykeybytesinmemory">
  ### TotalProjectionPrimaryKeyBytesInMemory
</div>

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).

<div id="totalprojectionprimarykeybytesinmemoryallocated">
  ### TotalProjectionPrimaryKeyBytesInMemoryAllocated
</div>

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).

<div id="totalrowsofmergetreetables">
  ### Nombre total de lignes des tables MergeTree
</div>

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

<div id="totalrowsofmergetreetablessystem">
  ### TotalRowsOfMergeTreeTablesSystem
</div>

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

<div id="totaluncompressedbytesofmergetreetables">
  ### TotalUncompressedBytesOfMergeTreeTables
</div>

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.

<div id="totaluncompressedbytesofmergetreetablessystem">
  ### TotalUncompressedBytesOfMergeTreeTablesSystem
</div>

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.

<div id="trackedmemory">
  ### TrackedMemory
</div>

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

<div id="uptime">
  ### Temps de fonctionnement
</div>

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

<div id="vmmaxmapcount">
  ### VMMaxMapCount
</div>

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

<div id="vmnummaps">
  ### VMNumMaps
</div>

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

<div id="zookeeperclientlastzxidseen">
  ### ZooKeeperClientLastZXIDSeen
</div>

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](/fr/guides/oss/deployment-and-scaling/monitoring/monitoring) — Concepts de base de la supervision de ClickHouse.
* [system.metrics](/fr/reference/system-tables/metrics) — Contient des métriques calculées instantanément.
* [system.events](/fr/reference/system-tables/events) — Contient les événements qui se sont produits.
* [system.metric\_log](/fr/reference/system-tables/metric_log) — Contient l'historique des valeurs de métriques des tables `system.metrics` et `system.events`.
