Wait statistics sur Azure SQL Database : les lire par base et par pool
sys.dm_db_wait_stats ou sys.dm_os_wait_stats, les waits qui comptent dans le cloud (log rate governor, resource governor, PAGEIOLATCH, CXPACKET) et une requête KQL par pool.
Quand un pool est « lent », le pourcentage de CPU dit que quelque chose travaille, mais pas ce que les requêtes attendent. Les wait statistics donnent cette seconde moitié. Sur Azure SQL Database, le tableau diffère de SQL Server on-premises sur deux points : les vues n'ont pas la même portée, et toute une famille de waits vient de la gouvernance des ressources de la plateforme plutôt que de vos requêtes. Voici comment je les lis, par base et par pool.
Deux vues, deux portées
| Vue | Portée | Usage |
|---|---|---|
sys.dm_db_wait_stats |
la base courante uniquement | attribuer les waits à une base ; exige VIEW DATABASE STATE |
sys.dm_os_wait_stats |
la vue du moteur, non limitée à votre base | voir les waits qui n'appartiennent pas à une base utilisateur, et les waits de plateforme |
Les deux sont cumulatives depuis la dernière remise à zéro (redémarrage, failover ou déplacement de la base), et aucune ne montre les waits en cours. Ne lisez donc jamais les valeurs absolues : prenez deux instantanés et soustrayez, ou utilisez un collecteur qui stocke des deltas. La documentation de sys.dm_db_wait_stats précise que les compteurs sont remis à zéro quand la base est déplacée ou mise hors ligne, et que les statistiques ne sont pas conservées après un failover.
-- instantané, attendre 5 minutes, second instantané, soustraire
SELECT wait_type, waiting_tasks_count, wait_time_ms, signal_wait_time_ms
INTO #w1
FROM sys.dm_db_wait_stats;
WAITFOR DELAY '00:05:00';
SELECT TOP (10)
b.wait_type,
b.wait_time_ms - a.wait_time_ms AS delta_wait_ms,
b.signal_wait_time_ms - a.signal_wait_time_ms AS delta_signal_ms
FROM sys.dm_db_wait_stats AS b
JOIN #w1 AS a ON a.wait_type = b.wait_type
WHERE b.wait_type NOT LIKE 'SLEEP%' AND b.wait_type NOT LIKE '%QUEUE%'
ORDER BY delta_wait_ms DESC;
Filtrez toujours d'abord les waits d'inactivité et de fond (sleep, queue, wait-for), sinon ils dominent la liste.
Les waits qui comptent dans le cloud
Gouvernance du débit de journal. Azure SQL Database limite la vitesse à laquelle une charge peut générer du journal de transactions, pour protéger les sauvegardes et les réplicas. Elle apparaît via des types de wait documentés sur Microsoft Learn : LOG_RATE_GOVERNOR (limite de la base), POOL_LOG_RATE_GOVERNOR (limite du pool), INSTANCE_LOG_RATE_GOVERNOR, et la famille HADR_THROTTLE_LOG_RATE_* (régulation : réplica lent, espace de journal, géo-réplication). Les chargements en masse, SELECT INTO et les reconstructions d'index la touchent en premier. Si vous voyez POOL_LOG_RATE_GOVERNOR, le gros travail d'écriture d'une base ralentit les autres : replanifiez-le, découpez-le en lots, ou augmentez le niveau de service.
Resource governor et mémoire. RESOURCE_SEMAPHORE : des requêtes attendent un octroi de mémoire ; RESOURCE_SEMAPHORE_QUERY_COMPILE : limitation des compilations (beaucoup de requêtes ad hoc) ; IO_QUEUE_LIMIT est décrit comme la file d'IO asynchrones de la base trop remplie, avec un seuil lié à l'objectif de service.
Lectures de stockage. PAGEIOLATCH_* : une tâche attend qu'une page soit lue du stockage vers la mémoire. Un peu, c'est normal. Beaucoup, ce sont des index manquants, des scans qui lisent trop, ou une mémoire trop petite pour le jeu de travail. Vérifiez la latence avec sys.dm_io_virtual_file_stats avant de conclure.
Parallélisme. CXPACKET : les threads d'une requête parallèle s'attendent ; CXCONSUMER est son pendant plus bénin. Ce sont des symptômes, pas des causes : regardez le plan le plus coûteux, les statistiques et le degré de parallélisme. Baisser MAXDOP au niveau de la base est possible, mais corrigez d'abord le plan.
À connaître aussi. WRITELOG (vidages de journal au commit, beaucoup de petites transactions), LCK_M_* (blocages), SE_REPL_* (attente des acquittements des secondaires).
Les lire par pool
La DMV par base ne donne pas de vue du pool. Deux approches. D'abord, exporter vers Log Analytics la catégorie de diagnostic des wait statistics de la plateforme, puis agréger par pool en KQL (la table et les colonnes ci-dessous sont celles que j'utilise ; les noms sont génériques) :
AzureDiagnostics
| where TimeGenerated > ago(24h)
| where ResourceProvider == "MICROSOFT.SQL" and Category == "DatabaseWaitStatistics"
| extend Pool = tostring(column_ifexists("ElasticPoolName_s", "")),
Db = tostring(column_ifexists("DatabaseName_s", "")),
Wait = tostring(column_ifexists("wait_type_s", "")),
DeltaMs = todouble(column_ifexists("delta_wait_time_ms_d", 0.0))
| summarize TotalMs = sum(DeltaMs) by Pool, Wait
| top 20 by TotalMs desc
Ensuite, exécuter la requête de delta ci-dessus sur chaque base et stocker le résultat de façon centrale. Je lis alors dans cet ordre :
flowchart TD
A["Métrique du pool élevée : CPU, workers ou écriture journal"] --> B["Waits par pool (KQL)"]
B --> C{"Wait dominant ?"}
C -- "log rate governor" --> D["Trouver la base qui écrit, replanifier"]
C -- "PAGEIOLATCH" --> E["Index, scans, mémoire, latence fichiers"]
C -- "CXPACKET" --> F["Plans, statistiques, MAXDOP"]
C -- "verrous" --> G["Blocages : transactions, index"]
D --> H["Query Store de cette base"]
E --> H
F --> H
Retour d'expérience
- Le temps d'attente total n'est pas un temps de réponse : les threads attendent en parallèle. Servez-vous des waits pour classer, pas pour additionner.
- Comparez avec une référence de la même heure un jour normal ; un wait toujours présent n'est pas votre problème du jour.
- Le wait du governor au niveau du pool nomme le symptôme mais pas le coupable : croisez avec l'écriture de journal par base ou Query Store pour trouver qui écrit.
- Vérifiez que le paramètre de diagnostic est actif avant un incident ; on ne peut pas exporter un historique qu'on n'a pas collecté.