# Always On : supervision des groupes de disponibilité

> Compteurs et indicateurs clés à surveiller pour les Groupes de Disponibilité Always On de SQL Server.
>
> Source : https://www.pachadata.com/docs/howtos/administration/monitoring/alwayson-ag/
> Auteur : Rudi Bruchez · mis à jour le 2026-10-14
> Version Markdown de la page, pour les outils et les LLM. La page HTML fait référence.


Supervision proactive des Groupes de Disponibilité Always On (AG).

## Compteurs de Performance

Compteurs importants à suivre et alerter :

- [Cluster Resources (WSFC) / Resource Failure](#cluster-resources-wsfc--resource-failure)
- [Cluster Resources (WSFC) / Resources Online](#cluster-resources-wsfc--resources-online)
- [SQLServer:Database Replica / Transaction Delay](#sqlserverdatabase-replica--transaction-delay)

### Cluster Resources (WSFC) / Resource Failure

Mesure : nombre total (cumulatif) d’échecs de ressources WSFC (une ressource passe en état Failed / nécessite redémarrage).

Doit rester stable (ou monter très rarement).

Élevé / augmente : indique des incidents réels (timeout health check, service SQL redémarré, perte réseau, etc.).

Pistes : événements WSFC + SQL ERRORLOG + System/Application (service crash, perte heartbeat, etc.)

### Cluster Resources (WSFC) / Resources Online

Mesure : nombre de ressources WSFC en ligne 

Doit être égal au nombre total de ressources configurées dans le cluster.

Baisse : ressource Offline/Failed → à corréler immédiatement aux événements cluster.

### SQLServer:Availability Replica / Flow Control Time (ms/sec)

Mesure : temps (en millisecondes par seconde) pendant lequel l’envoi a été throttlé par le mécanisme de flow control.

Interprétation :

- 0 : pas de throttling.
- \> 0 : SQL ralentit volontairement l’envoi, typiquement parce que le secondaire ne suit pas (redo lent, ressources saturées, backlog).

**Important** : c’est un indicateur direct de pression côté secondaire/transport.

### SQLServer:Availability Replica / Flow Control/sec

Mesure : nombre d’événements de flow control par seconde.

Interprétation : plus c’est élevé, plus souvent SQL applique de la régulation.

Souvent corrélé : Flow Control/sec > 0 et Flow Control Time > 0 → secondaire en difficulté (CPU, I/O redo, réseau).

### SQLServer:Database Replica / Database Flow Control Delay

> Par base de données

Mesure : délai (ms) imposé par _flow control_ au niveau base (throttling spécifique à cette DB).

Interprétation : 

- 0 est la valeur normale
- \> 0 indique que cette base est limitée (secondaire en retard, pression redo/I/O).

### SQLServer:Database Replica / Database Flow Controls/sec

> Par base de données

Mesure : événements de flow control par seconde pour cette base.

Interprétation : si >0 de manière persistante, c’est un signe de contrainte côté secondaire (ou transport).

### SQLServer:Database Replica / Log Apply Pending Queue

> Par base de données

Mesure : quantité de log reçue, mais pas encore prête à être appliquée (en attente de traitement interne).

Interprétation : reflète un backlog “avant redo”.

Hausse continue : secondaire n’ingère pas assez vite (CPU, I/O, contention, réseau, compression, etc.).

### SQLServer:Database Replica / Log Apply Ready Queue

> Par base de données

Mesure : quantité de log prête à être appliquée (redo) mais pas encore appliquée.

Interprétation : backlog “redo”.

Hausse : redo thread(s) ne suivent pas → souvent I/O data secondaire, CPU secondaire, contention, ou requêtes lisant sur secondaire.

### SQLServer:Database Replica / Log Send Queue

> Par base de données

Mesure : quantité de log en attente d’envoi depuis le primaire vers le secondaire.

Interprétation : indicateur majeur de backlog côté primaire.

Hausse continue : primaire génère plus de log que ce qui est envoyé

- réseau saturé, compression lente, ou
- secondaire ne suit pas (flow control), ou
- CPU primaire/threads transport saturés.

Pistes : comparer à Bytes Sent/sec, Flow Control, Resent Messages, latence.

### SQLServer:Database Replica / Recovery Queue

> Par base de données

Mesure : quantité de travail en attente pour le recovery (redo/undo/recovery interne) sur la base répliquée.

Interprétation : 0 en régime stable ; augmente lors de rattrapage, failover, resynchronisation.

### SQLServer:Database Replica / Redo blocked/sec

> Par base de données

Mesure : nombre d’événements par seconde où le redo est bloqué (ne peut pas appliquer).

Interprétation : très important ; un redo bloqué signifie que le secondaire ne peut pas avancer.

Causes fréquentes : I/O data saturées, verrous internes, contraintes ressources, opérations DDL, contention, manque CPU, requêtes lourdes sur secondaire lisible.

### SQLServer:Database Replica / Transaction Delay

> Par base de données

Mesure : délai (ms) subi par les transactions à cause de la réplication/commit (typiquement en synchrone).

Interprétation : 0 en asynchrone (souvent), ou faible en synchrone sain.

Monte si le commit attend le secondaire (latence réseau, secondaire lent).

Pistes : `HADR_SYNC_COMMIT`, latence réseau, performance log primaire, redo secondaire.

### synthèse

- Throttling : Flow Control Time, Flow Control/sec, Database Flow Control*.
- Backlog primaire : Log Send Queue.
- Backlog secondaire : Log Apply Pending/Ready Queue, Redo Bytes Remaining.
- Capacité du secondaire à suivre : Redone Bytes/sec, Redo blocked/sec.
- Impact sur les commits (synchrone) : Group Commit Time, Transaction Delay.

## Requêtes directes T-SQL


Replica States (https://github.com/rudi-bruchez/tsql-scripts/blob/main/hadr/availability-replicas-states.sql) :

```sql
-----------------------------------------------------------------
-- availability replicas states
--
-- rudi@babaluga.com, go ahead license
-----------------------------------------------------------------

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

SELECT
	g.name as AG,
	ar.replica_server_name as [Replica],
	rs.is_local,
	rs.role_desc as role,
	rs.operational_state_desc as operational_state,
	rs.connected_state_desc as connected_state,
	rs.recovery_health_desc as recovery_health,
	rs.synchronization_health_desc as synchronization_health
FROM sys.dm_hadr_availability_replica_states rs
JOIN sys.availability_replicas ar ON rs.replica_id = ar.replica_id
JOIN sys.availability_groups g ON ar.group_id = g.group_id
ORDER BY g.name, ar.replica_server_name, rs.role
OPTION (RECOMPILE, MAXDOP 1);
```


Alertez sur les colonnes :

- **operational_state** -- Si <> `ONLINE` ou si `NULL`, il y a un problème.
- **connected_state** -- Si <> `CONNECTED`, il y a un problème.
- **recovery_health** -- Si <> `HEALTHY`, il y a un problème.
- **synchronization_health** -- Si <> `HEALTHY`, il y a un problème.


Database Replica States (https://github.com/rudi-bruchez/tsql-scripts/blob/main/hadr/database-replica-states.sql) :

```sql
-----------------------------------------------------------------
-- AlwaysOn database replica states
-- Rudi Bruchez - rudi@babaluga.com 
-----------------------------------------------------------------

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

SELECT 
	g.name as AG
   ,ar.replica_server_name as [Replica]
   ,dbcs.database_name AS [db]
   ,IIF(rs.is_local = 1, 'Y', 'N') as [local]   
   ,IIF(dbcs.is_failover_ready = 1, 'Y', 'N') AS [FailoverReady]
   ,IIF(dbcs.is_database_joined = 1, 'Y', 'N') AS [Joined]
   ,IIF(rs.is_primary_replica = 1, 'Y', 'N') as [primary]
   ,CONCAT(rs.synchronization_state_desc, ' (', rs.synchronization_state, ')') AS synchronization_state
   ,CONCAT(rs.synchronization_health_desc, ' (', rs.synchronization_health, ')') AS synchronization_health
   ,CONCAT(rs.database_state_desc, ' (', rs.database_state, ')') AS database_state
   ,CONCAT(IIF(rs.is_suspended = 1, 'Y', 'N'), IIF(rs.is_suspended = 0, '', CONCAT(rs.suspend_reason_desc, ' (', rs.suspend_reason, ')'))) AS suspended
   ,DATEDIFF(minute, rs.last_sent_time, CURRENT_TIMESTAMP) AS last_sent_min
   ,DATEDIFF(minute, rs.last_received_time, CURRENT_TIMESTAMP) AS last_received_min
   ,DATEDIFF(minute, rs.last_hardened_time, CURRENT_TIMESTAMP) AS last_hardened_min
   ,DATEDIFF(minute, rs.last_redone_time, CURRENT_TIMESTAMP) AS last_redone_min
   ,DATEDIFF(minute, rs.last_commit_time, CURRENT_TIMESTAMP) AS last_commit_min
   ,DATEDIFF(minute, rs.last_redone_time, rs.last_hardened_time) as redo_latency_min
   ,ISNULL(CAST(rs.log_send_queue_size / 1024.0 as decimal(38, 2)), 0) AS [LogSendQueueSize_Mb]
   ,ISNULL(CAST(rs.log_send_rate / 1024.0 as decimal(38, 2)), -1) AS [LogSendRate_Mb]
   ,ISNULL(CAST(rs.redo_queue_size / 1024.0 as decimal(38, 2)), -1) AS [RedoQueueSize_Mb]
   ,ISNULL(CAST(rs.redo_rate / 1024.0 as decimal(38, 2)), -1) AS [RedoRate_Mb]
   ,rs.secondary_lag_seconds
   ,ISNULL(CASE 
    WHEN rs.is_primary_replica = 1 
        OR rs.redo_queue_size is null  
        OR rs.redo_queue_size = 0
        OR rs.redo_rate is null or rs.redo_rate = 0 THEN 0 
    ELSE CAST(CAST(rs.redo_queue_size AS DECIMAL(38, 2)) / rs.redo_rate / 60 AS DECIMAL(38, 2)) END, 0) AS [EstimatedRecoveryTime_Min]
FROM sys.dm_hadr_database_replica_states rs
JOIN sys.availability_groups g ON rs.group_id = g.group_id
JOIN sys.availability_replicas ar ON rs.replica_id = ar.replica_id
JOIN sys.dm_hadr_database_replica_cluster_states dbcs ON dbcs.replica_id = ar.replica_id
OPTION (RECOMPILE, MAXDOP 1);
```


Alertez sur les colonnes :

- **synchronization_state** -- Si <> `SYNCHRONIZED` (synchrone) ou `NOT SYNCHRONIZED` (asynchrone), il y a un problème.
- **synchronization_health** -- Si <> `HEALTHY`, il y a un problème.
- **is_suspended** -- Si <> `0`, il y a un problème.

---

## L'auteur

Rudi Bruchez, consultant SQL Server indépendant depuis 2006 : audit de performance, optimisation, migrations, haute disponibilité et formation. Pour un audit ou une intervention sur votre serveur : https://www.pachadata.com/contact/ (audit à distance : https://www.pachadata.com/services/audit-sql-server-a-distance/).
