SQL Server Événements prolongés : Surveillance et dépannage [2026]

SQL Server Extended Events est un système de surveillance des performances léger qui permet aux administrateurs et aux développeurs de collecter et d'analyser des données détaillées sur l'activité du serveur. Ce système est intégré à… SQL Server Le moteur de base de données fournit des informations complètes sur le fonctionnement normal et les scénarios de dépannage.

1.2 Pourquoi utiliser des événements étendus pour la surveillance ?

SQL Server Extended Events offre plusieurs avantages convaincants pour la surveillance et le dépannage des bases de données :

Impact minimal sur les performances grâce à une architecture légère
Contrôle précis de la collecte de données et du filtrage des événements
Collecte de données personnalisable et adaptée aux besoins spécifiques de surveillance
Capacité à capturer simultanément des événements provenant de plusieurs packages
Des capacités de filtrage flexibles pour se concentrer sur les opérations pertinentes
Prise en charge de la surveillance des systèmes de production sans dégradation de l'expérience utilisateur
Suivi complet des indicateurs de performance
Diagnostic avancéostcapacités de dépannage des circuits intégrés
Tenue d'une piste d'audit pour la conformité aux exigences
Options d'analyse des données en temps réel et historiques

1.3 Événements prolongés vs SQL Server Profiler

Si SQL Server Profiler MS SQL Extended Events, outil de surveillance traditionnel, offre une alternative plus efficace. Extended Events consomme moins de ressources système et offre une meilleure évolutivité pour les environnements de production.

SQL Server Profiler est désormais obsolète et Microsoft recommande de migrer vers les événements étendus pour toutes les activités de surveillance.

2. Comprendre l'architecture des événements étendus

2.1 Composants du moteur d'événements étendus

Le moteur Extended Events se compose de plusieurs composants essentiels qui fonctionnent de concert pour capturer, traiter et stocker les données d'événements. La compréhension de ces composants vous aide à concevoir des solutions de surveillance efficaces.

Répartiteur : Le composant de répartition coordonne le flux d'événements provenant des sources d'événements vers le moteur d'événements étendus. Lorsqu'un événement se déclenche, le répartiteur reçoit la notification et la transmet aux sessions actives abonnées à ce type d'événement spécifique.
Tampon: Tempo des tamponsrarstockez les données d'événements en mémoire avant de les écrire dans tarCe mécanisme de mise en mémoire tampon améliore les performances en réduisant les opérations d'E/S. La taille et la gestion de la mémoire tampon peuvent être configurées pour optimiser l'utilisation de la mémoire et les besoins de capture des données.
Session: Une session définit le périmètre de la surveillance des événements. Elle spécifie les événements à capturer, les actions à exécuter, les prédicats à appliquer et l'emplacement de stockage des résultats. Les sessions peuvent être créées, modifiées et supprimées.tarted, et s'est arrêté indépendamment.
Tarobtenir l'instance : TarLes instances GET représentent les destinations de stockage des données d'événements capturées. Chaque session peut écrire dans une ou plusieurs destinations. tardes données telles que des fichiers, des tampons circulaires ou des compteurs. TarRécupère, traite et conserve les informations relatives à l'événement pour une analyse ultérieure.

2.2 Forfaits événementiels

SQL Server Extended Events organise les fonctionnalités en packages. Chaque package contient des événements, des actions, des types, des prédicats et des éléments connexes. tarLes packages courants incluent sqlserver, sqlos et package0.

Le package sqlserver fournit des événements spécifiques à la base de données tels que les requêtes et les transactions.
Le package sqlos contient des événements du système d'exploitation.
Le package0 offre des fonctionnalités à usage général utilisées dans tous les packages.

2.3 Types d'événements et champs

Les événements représentent des occurrences au sein de SQL Server que vous souhaitez surveiller. Chaque type d'événement possède des champs prédéfinis qui enregistrent les informations pertinentes. Par exemple, l'événement `sql_statement_completed` inclut des champs pour la durée, le temps CPU, les lectures et les écritures.

Les événements peuvent être synchrones ou asynchrones. Les événements synchrones se déclenchent pendant l'opération elle-même, tandis que les événements asynchrones se déclenchent après son achèvement. Comprendre les caractéristiques des événements vous aide à sélectionner ceux qui répondent le mieux à vos besoins de surveillance.

2.4 actions

Les actions ajoutent des supplémentstary informations aux événements capturés. Lorsqu'un événement se déclenche, des actions associées s'exécutent pour recueillir des informations contextuelles supplémentaires telles que le texte SQL, l'ID de session ou les informations de la pile d'appels.

Les actions courantes incluent sql_text pour capturer les instructions de requête, database_name pour identifier la base de données et client_hostNom permettant de suivre le serveur d'origine. Les actions fournissent un contexte essentiel pour le dépannage et l'analyse.

2.5 Tarobtient

Tardétermine comment et où les données d'événements sont stockées. SQL Server Extended Events prend en charge plusieurs tarobtenir des types, notamment :

Fichier d'événements pour le stockage sur disque, assurant un stockage persistant pour une analyse détaillée
ring_buffer pour la rétention en mémoire, offrant un accès rapide aux événements récents avec une surcharge minimale
compteur d'événements pour un comptage simple
histogramme pour le regroupement
appariement pour la corrélation d'événements liés

2.6 Prédicats (Filtres)

Les prédicats permettent de filtrer les événements selon des conditions spécifiées, réduisant ainsi le volume de données collectées. Vous pouvez filtrer par nom de base de données, nom d'application, ID de session, seuils de durée ou toute valeur de champ d'événement.

L'utilisation efficace des prédicats minimise l'impact sur les performances en ne capturant que les événements pertinents. Les prédicats complexes combinent plusieurs conditions à l'aide d'opérateurs logiques afin de créer des critères de filtrage précis.

3. États et cycle de vie des sessions d'événements étendus

3.1 États de session : CRÉER, MODIFIER et SUPPRIMER

Les sessions Extended Event progressent à travers des états distincts :

L'instruction CREATE EVENT SESSION définit une nouvelle session, mais ne la ferme pas.tarLa session reste à l'état arrêté jusqu'à ce qu'elle soit explicitement activée.
L'instruction ALTER EVENT SESSION modifie la configuration de la session ou change son état entre arrêtée et en cours.tarTed.
L'instruction DROP EVENT SESSION supprime entièrement la définition de session du serveur.

3.2 Contenu et caractéristiques de la session

Chaque session contient un ensemble d'événements, d'actions, tarLes sessions possèdent des limites implicites qui définissent leur portée et leur comportement. Les options de configuration contrôlent l'allocation de mémoire, la conservation des événements et la latence de distribution.

Les caractéristiques de session incluent leur persistance entre les ressources du serveur.tarLe délai d'expiration (ts), l'allocation de mémoire maximale et la gestion de la pression sur la mémoire ont un impact significatif sur le comportement de la session et la consommation de ressources.

3.3 Limites de session et paquets

Les limites de session définissent les relations entre les événements. tarLes données sont collectées via des paquets. Les événements d'un paquet peuvent déclencher des actions d'un autre paquet, offrant ainsi une grande flexibilité dans les stratégies de collecte de données.

Les relations entre les packages permettent de combiner des événements provenant de plusieurs sources au sein d'une même session. Cette fonctionnalité permet de mettre en place des scénarios de surveillance complets couvrant différentes zones géographiques. SQL Server sous-systèmes.

4. Création de sessions d'événements étendus à l'aide de SSMS

4.1 Prérequis et configuration

Avant de créer SQL Server Pour les sessions Extended Events, assurez-vous de disposer des autorisations appropriées. L'autorisation ALTER ANY EVENT SESSION est requise pour les sessions au niveau du serveur, et l'autorisation CONTROL sur la base de données pour les sessions au niveau de la base de données.

Vérifier que SQL Server Management Studio est installé et connecté à votre tarPrenez un exemple. Familiarisez-vous avec les exigences de surveillance et identifiez les événements et tartrouvera la solution la mieux adaptée à vos besoins.

4.2 Accès aux événements étendus dans l'explorateur d'objets

Pour accéder à l'interface des événements étendus dans SSMS, suivez ces étapes :

Ouvrez SQL Server Management Studio et connectez-vous à votre SQL Server exemple.
Dans l'explorateur d'objets, développez Direction -> Événements étendus.
Le nœud Événements étendus contient Sessions et Packs Dossiers pour gérer vos configurations de surveillance.

4.3 Créer une nouvelle session

Pour créer une nouvelle session :

1. Faites un clic droit sur le Sessions dossier sous Événements étendus.
2. Choisir Nouvelle session pour ouvrir la boîte de dialogue de configuration. Le contenu suivant utilisera cette méthode pour créer une nouvelle session.

Noter la Assistant de nouvelle session Une expérience plus guidée est également disponible.

4.3.1 Configuration générale de la page

Sur le Généralités page, configurer les propriétés de session de base :

Saisissez un nom de session dans le Nom de la session champ. Utilisez des noms descriptifs indiquant l'objectif de la surveillance.
Sélectionner (facultatif) Start la session d'événement sur le serveur startube pour permettre l'activation automatique de la session.
Le modèle de session par défaut est BlancVous pouvez utiliser d'autres modèles si vous utilisez une configuration prédéfinie.

4.3.2 Configuration de la page Événements

Le Événements Cette page vous permet de sélectionner les événements à surveiller :

Sélectionnez le Événements page de gauche Sélectionnez une page panneau.
Dans l' Bibliothèque d'événementsrary, parcourez les événements disponibles ou utilisez la fonction de recherche.
Filtrez les événements en saisissant des mots clés tels que « sql_statement_completed » pour trouver les événements pertinents.
Sélectionnez l'événement souhaité, par exemple sql_statement_completed.
Cliquez sur la flèche droite pour déplacer l'événement vers le Événements sélectionnés liste.

4.3.3 Configuration du stockage des données

Le Stockage de données Cette page définit l'emplacement de stockage des données d'événements :

Sélectionnez le Stockage de données page de gauche Sélectionnez une page panneau.
Dans l' Tarobtient zone, choisissez un tarRécupérez le type dans la liste déroulante.

(1) fichier d'événement Tarobtenez

Le fichier d'événements tarLa fonction get enregistre les données dans des fichiers disque avec l'extension .xel :

Choisir fichier d'événement du tarRécupérer le menu déroulant du type.
Spécifiez le chemin d'accès au fichier, par exemple C:\temp\VotreSession_Tarobtenir.xel.
Configurez les options de rotation pour gérer l'espace disque en définissant la taille maximale des fichiers et le nombre de fichiers.
Le tarLes événements d'écriture sont récupérés en continu jusqu'à l'arrêt de la session ou jusqu'à ce que les limites de stockage soient atteintes.

(2) tampon annulaire Tarobtenez

Le tampon annulaire tarRécupérer les événements stockés en mémoire pour un accès rapide sans E/S disque :

Choisir tampon annulaire car tarobtenir le type.
Configurez la taille maximale de la mémoire allouée au tampon.
Il faut savoir que les événements plus anciens sont supprimés lorsque la mémoire tampon est pleine, ce qui rend cette méthode adaptée à la surveillance des activités récentes.

(3) compteur d'événements Tarobtenez

Le compteur d'événements tarCette fonction compte simplement les occurrences d'événements sans stocker de données détaillées. Cela minimise la surcharge lorsque seules les informations de fréquence sont nécessaires.

(4) histogramme Tarobtenez

L'histogramme tarObtenez des groupes d'événements selon une valeur de champ spécifique, générant des statistiques de distribution. Ceci est utile pour identifier les tendances communes ou les valeurs fréquentes.

(5) appariement Tarobtenez

La correspondance des paires tarObtenir des corrélations entre événements liés, tels que l'acquisition et la libération d'un verrou. Ceci permet d'analyser les opérations appariées et leurs relations temporelles.

4.3.4 Paramètres avancés

Le Avancé Cette page propose des options de configuration au niveau de la session :

Sélectionnez le Avancé page de gauche Sélectionnez une page panneau.
Configurez Mode de rétention des événements pour contrôler la manière dont les événements sont gérés en cas de forte pression sur la mémoire.
complet » Latence d'envoi maximale pour équilibrer le traitement en temps réel et les performances du système.
Configurez Taille maximale de la mémoire et Taille maximale de l'événement en fonction de vos besoins en matière de surveillance.
Choisir Mode de partitionnement de la mémoire optimiser pour les environnements mono ou multiprocesseurs.

4.4 Configuration des filtres d'événements (prédicats)

Les prédicats permettent de réduire le volume de données en filtrant les événements selon des critères spécifiques. Pour configurer les filtres :

Sur le Événements Sur la page, sélectionnez l'événement que vous souhaitez filtrer, tel que « sql_statement_completed ».
Cliquez à nouveau sur Configurez pour ouvrir la boîte de dialogue de configuration de l'événement.
Sélectionnez le Filtre (Prédicat) languette.
Dans l' Champ Dans le menu déroulant, choisissez le champ sur lequel filtrer, par exemple la durée.
Sélectionnez un Opérateur, comme « > ».
Saisissez le filtre Valeur, par exemple 1000000 (1 seconde).
Ajoutez d'autres conditions si nécessaire.

4.5 Sélection des actions et des champs d'événement

Pour chaque événement, vous pouvez sélectionner les données à collecter :

Sur le Événements Sur la page, sélectionnez l'événement pour lequel vous souhaitez sélectionner les données, par exemple « sql_statement_completed ».
Cliquez à nouveau sur Configurez pour ouvrir la boîte de dialogue de configuration de l'événement.
Sélectionnez le Champs globaux (Actions) languette.
Sélectionnez les actions à ajouter.tary informations, telles que database_name ou client_app_name.
Revoir le Champs d'événements section permettant de voir quels champs sont automatiquement capturés.
Supprimez les champs inutiles afin de réduire le volume de données.

4.6 StarGestion et intégration des sessions

Après avoir configuré votre session, vous pouvez start'y mettre et surveiller son fonctionnement :

Cliquez à nouveau sur OK pour créer la session.
Dans l'explorateur d'objets, développez le Sessions dossier pour voir votre nouvelle session.
Cliquez avec le bouton droit sur le nom de la session et sélectionnez Start Session pour commencer à enregistrer les événements.
Pour afficher les données en direct, cliquez avec le bouton droit sur la session et sélectionnez Suivi des données en direct.
Arrêtez la session en cliquant avec le bouton droit et en sélectionnant Arrêter la session.

5. Création de sessions d'événements étendus à l'aide de T-SQL

5.1 Syntaxe de création de session d'événement

La création de sessions d'événements étendus avec T-SQL offre un contrôle précis et permet la création de scripts pour un déploiement automatisé. L'instruction CREATE EVENT SESSION suit une structure syntaxique spécifique.

La syntaxe de base comprend le nom de la session, les clauses ADD EVENT pour chaque événement, ADD TARClauses GET pour les destinations de stockage et clauses WITH facultatives pour la configuration de session.

5.2 Création d'une session d'événement de base

Une session de base surveille des événements spécifiques et écrit les résultats dans un tarVoici comment construire les composants essentiels.

5.2.1 Définition du nom et des options de la session

Staren créant la session avec un nom descriptif :

CREATE EVENT SESSION [SampleSession] ON SERVER

La clause ON SERVER crée une session au niveau du serveur qui persiste malgré les modifications apportées à la base de données. Pour Azure SQL Database, utilisez ON DATABASE pour les sessions au niveau de la base de données.

5.2.2 Ajout d'événements avec ADD EVENT

Ajoutez des événements à capturer à l'aide de la clause ADD EVENT :

CREATE EVENT SESSION [SampleSession] ON SERVER
ADD EVENT sqlserver.sql_statement_completed

Ceci enregistre toutes les instructions SQL exécutées. Vous pouvez ajouter plusieurs événements en incluant des clauses ADD EVENT supplémentaires.

5.2.3 Configuration des actions d'événement

Les actions permettent de recueillir des informations supplémentaires pour chaque événement. Ajoutez les actions entre parenthèses après le nom de l'événement :

CREATE EVENT SESSION [SampleSession] ON SERVER
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(sqlserver.sql_text, sqlserver.database_name, sqlserver.username)
)

Cet exemple capture le texte SQL, le nom de la base de données et le nom d'utilisateur pour chaque instruction exécutée.

5.2.4 Définition des prédicats d'événement (clause WHERE)

Les prédicats permettent de filtrer les événements afin de réduire le volume de données. Utilisez la clause WHERE dans la définition de l'événement :

CREATE EVENT SESSION [SampleSession] ON SERVER
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(sqlserver.sql_text)
    WHERE ([package0].[greater_than_uint64]([duration],(5000000)))
)

Ce filtre permet de sélectionner les instructions d'une durée supérieure à 5 secondes (5 000 000 microsecondes).

5.3 Ajout d'un événement Tarobtient

TarPermet de définir où les données d'événements sont stockées et comment elles sont traitées.

5.3.1 AJOUTER TARSyntaxe GET

Ajouter tarobtient l'utilisation du ADD TARClause GET après la définition de tous les événements :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\SampleSession.xel'
)

Le préfixe package0 indique le tarL'obtention provient du package de base.

5.3.2 Configuration Tarobtenir les paramètres

Chaque projet récompensé par un tarLa fonction get type accepte des paramètres spécifiques. Pour event_file, configurez filename, max_file_size et max_rollover_files :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\SampleSession.xel',
        max_file_size=(50),
        max_rollover_files=(5)
)

Cette configuration crée des fichiers jusqu'à 50 Mo chacun, et conserve jusqu'à 5 fichiers lors de leur rotation.

5.4 Options et paramètres de session

La clause WITH configure les options au niveau de la session qui contrôlent le comportement et l'utilisation des ressources.

5.4.1 MAX_MEMORY et EVENT_RETENTION_MODE

Contrôler l'allocation de mémoire et la gestion des événements sous pression :

WITH (
    MAX_MEMORY=4096 KB,
    EVENT_RETENTION_MODE=ALLOW_SINGLE_EVENT_LOSS
)

Les options EVENT_RETENTION_MODE incluent ALLOW_SINGLE_EVENT_LOSS pour une utilisation minimale de la mémoire, ALLOW_MULTIPLE_EVENT_LOSS pour une surcharge modérée et NO_EVENT_LOSS pour une conservation complète des données.ost de l'impact potentiel sur les performances.

5.4.2 MAX_DISPATCH_LATENCY

Définissez la durée maximale pendant laquelle les événements peuvent rester dans les tampons avant d'être écrits. tarobtient :

WITH (
    MAX_DISPATCH_LATENCY=30 SECONDS
)

Des valeurs plus faibles fournissent davantage de données en temps réel au niveau du cost d'opérations d'E/S accrues.

5.4.3 MODE DE PARTITION MÉMOIRE

Optimisez le partitionnement de la mémoire en fonction de votre configuration matérielle :

WITH (
    MEMORY_PARTITION_MODE=PER_CPU
)

Les options incluent AUCUNE pour une seule partition, PAR_NŒUD pour les systèmes NUMA et PAR_CPU pour une concurrence maximale sur les systèmes multiprocesseurs.

5.5 StarSéances de traitement, d'arrêt et de modification

Gérez l'état et la configuration de la session via les instructions ALTER EVENT SESSION.

5.5.1 MODIFIER LA SESSION D'ÉVÉNEMENT pour Start/Stop

Starsession ta après la création :

ALTER EVENT SESSION [SampleSession] ON SERVER STATE = START;

Arrêter une session en cours :

ALTER EVENT SESSION [SampleSession] ON SERVER STATE = STOP;

5.5.2 Modification des sessions existantes

Modifier la configuration de la session lorsqu'elle est arrêtée. Ajouter des événements :

ALTER EVENT SESSION [SampleSession] ON SERVER
ADD EVENT sqlserver.sql_batch_completed;

Supprimer les événements :

ALTER EVENT SESSION [SampleSession] ON SERVER
DROP EVENT sqlserver.sql_statement_completed;

5.5.3 Suppression des sessions d'événements

Supprimer complètement une session avec DROP EVENT SESSION :

DROP EVENT SESSION [SampleSession] ON SERVER;

La session doit être interrompue avant d'être abandonnée.

6. Travailler avec l'événement Tarentre dans les détails

6.1 fichier d'événement Tarobtenir la configuration

Le fichier d'événements tarLa fonction get permet un stockage persistant des données d'événements avec des options de configuration flexibles.

6.1.1 Chemin d'accès aux fichiers et conventions d'appellation

Spécifiez le chemin d'accès complet et le nom du fichier d'événement :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\MySession.xel'
)

Utilisez l'extension .xel pour les fichiers journaux d'événements étendus. Assurez-vous que SQL Server Le compte de service dispose des autorisations d'écriture sur le répertoire spécifié.

6.1.2 Gestion du renouvellement et de la taille des fichiers

Configurez la rotation automatique des fichiers pour gérer l'espace disque :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\MySession.xel',
        max_file_size=(50),
        max_rollover_files=(10)
)

Lorsqu'un fichier atteint 50 Mo, SQL Server L'option « Événements étendus » crée un nouveau fichier avec un suffixe incrémenté. Après avoir atteint 10 fichiers, le plus ancien est écrasé.

6.1.3 Lecture des données du fichier d'événements

Interroger les données du fichier d'événements à l'aide de sys.fn_xe_file_tarfonction get_read_file :

SELECT
    event_data,
    file_name,
    file_offset
FROM sys.fn_xe_file_target_read_file(
    'C:\XEvents\MySession*.xel',
    NULL, NULL, NULL
);

Le modèle générique lit tous les fichiers associés à la session.

6.2 tampon circulaire Tarobtenir l'utilisation

Le tampon annulaire tarRécupérer les événements stockés en mémoire pour un accès rapide à l'activité récente.

6.2.1 Stockage d'événements en mémoire

Configurer ring_buffer pour le stockage en mémoire :

ADD TARGET package0.ring_buffer

Les événements restent accessibles uniquement pendant la durée active de la session et SQL Server est en cours d'exécution. Les données sont lost lorsque la session s'arrête ou que le serveur se déconnectetarts.

6.2.2 Taille et configuration du tampon

Contrôler l'allocation de mémoire pour le tampon circulaire :

ADD TARGET package0.ring_buffer(
    SET max_memory=(4096)
)

Spécifiez la mémoire en Ko. Lorsque la mémoire tampon est pleine, les événements les plus anciens sont supprimés selon le principe du premier entré, premier sorti (FIFO).

6.2.3 Interrogation des données du tampon circulaire

Accédez aux données du tampon circulaire via les DMV :

SELECT
    CAST(target_data AS XML) AS TargetData
FROM sys.dm_xe_session_targets AS t
JOIN sys.dm_xe_sessions AS s
    ON s.address = t.event_session_address
WHERE s.name = 'YourSessionName'
    AND t.target_name = 'ring_buffer';

Le target_data contient des informations sur les événements au format XML.

6.3 compteur d'événements Tarobtenez

Le compteur d'événements tarLa fonction get permet un comptage simple sans stockage détaillé des données :

ADD TARGET package0.event_counter

Ce tarObtenez la fréquence des événements de suivi avec une surcharge minimale, utile pour la surveillance à haut volume où seuls les comptages comptent.

6.4 histogramme Tarobtenez

L'histogramme tarRécupérer les événements de groupe par valeurs de champ :

ADD TARGET package0.histogram(
    SET filtering_event_name=N'sqlserver.sql_statement_completed',
        source_type=0,
        source=N'database_name'
)

Cette configuration crée un histogramme montrant la répartition des événements dans les différentes bases de données.

6.5 appariement Tarobtenez

La correspondance des paires tarobtenir des corrélations entre les événements liés tels que les acquisitions de verrous et leurs libérations :

ADD TARGET package0.pair_matching(
    SET begin_event=N'sqlserver.lock_acquired',
        end_event=N'sqlserver.lock_released',
        begin_matching_columns=N'resource_type',
        end_matching_columns=N'resource_type'
)

Cela permet d'analyser les opérations appariées et leurs durées.

7. Visualisation et analyse des données d'événements étendus

7.1 Utilisation de SSMS pour visualiser les données en direct

SQL Server Management Studio fournit une interface graphique permettant de visualiser les données des événements étendus en temps réel :

Dans l'explorateur d'objets, développez Direction -> Événements étendus -> Sessions.
Faites un clic droit sur votre session active.
Choisir Suivi des données en direct pour ouvrir la visionneuse de données en direct.
Les événements apparaissent dans la grille au fur et à mesure qu'ils se produisent.
Cliquez sur chaque événement pour afficher les valeurs détaillées des champs dans le volet de détails.
Utilisez les filtres de la barre d'outils pour vous concentrer sur des types d'événements ou des valeurs de champs spécifiques.

7.2 Interrogation des données des fichiers d'événements avec T-SQL

Les requêtes T-SQL permettent une analyse flexible des données d'événements capturées.

7.2.1 sys.fn_xe_file_tarFonction get_read_file

Lire les données du fichier d'événements à l'aide de cette fonction système :

SELECT
    object_name AS EventName,
    CAST(event_data AS XML) AS EventData,
    file_name,
    file_offset,
    timestamp_utc
FROM sys.fn_xe_file_target_read_file(
    'C:\XEvents\MySession*.xel',
    NULL, NULL, NULL
);

La fonction renvoie une ligne par événement avec des détails au format XML.

7.2.2 Analyse des données d'événements XML

Extraire des valeurs spécifiques des données d'événement XML :

SELECT
    event_data.value('(event/@name)[1]', 'VARCHAR(50)') AS EventName,
    event_data.value('(event/@timestamp)[1]', 'DATETIME2') AS Timestamp,
    event_data.value('(event/data[@name="duration"]/value)[1]', 'BIGINT') AS Duration,
    event_data.value('(event/data[@name="statement"]/value)[1]', 'VARCHAR(MAX)') AS Statement
FROM (
    SELECT CAST(event_data AS XML) AS event_data
    FROM sys.fn_xe_file_target_read_file(
        'C:\XEvents\MySession*.xel',
        NULL, NULL, NULL
    )
) AS EventData;

Les expressions XQuery extraient les valeurs individuelles des champs de la structure XML.

7.2.3 Conversion des données d'événements en tableaux

Créer des ensembles de résultats structurés à partir des données d'événements :

WITH EventData AS (
    SELECT CAST(event_data AS XML) AS EventXML
    FROM sys.fn_xe_file_target_read_file(
        'C:\XEvents\MySession*.xel',
        NULL, NULL, NULL
    )
)
SELECT
    EventXML.value('(event/@name)[1]', 'VARCHAR(100)') AS EventName,
    EventXML.value('(event/data[@name="cpu_time"]/value)[1]', 'BIGINT') AS CPUTime,
    EventXML.value('(event/data[@name="physical_reads"]/value)[1]', 'BIGINT') AS PhysicalReads,
    EventXML.value('(event/action[@name="sql_text"]/value)[1]', 'VARCHAR(MAX)') AS SQLText,
    EventXML.value('(event/action[@name="database_name"]/value)[1]', 'VARCHAR(128)') AS DatabaseName
FROM EventData;

7.3 Interrogation des données du tampon circulaire

Extraire les données du ring_buffer tarobtient :

SELECT
    n.value('(@name)[1]', 'VARCHAR(50)') AS EventName,
    n.value('(@timestamp)[1]', 'DATETIME2') AS Timestamp,
    n.value('(data[@name="duration"]/value)[1]', 'BIGINT') AS Duration,
    n.value('(action[@name="sql_text"]/value)[1]', 'VARCHAR(MAX)') AS SQLText
FROM (
    SELECT CAST(target_data AS XML) AS TargetData
    FROM sys.dm_xe_session_targets AS t
    JOIN sys.dm_xe_sessions AS s
        ON s.address = t.event_session_address
    WHERE s.name = 'YourSessionName'
        AND t.target_name = 'ring_buffer'
) AS Data
CROSS APPLY TargetData.nodes('//event') AS q(n);

7.4 Vues système pour les événements étendus

SQL Server fournit plusieurs vues de gestion dynamique (DMV) et vues de catalogue pour la gestion et la surveillance des sessions d'événements étendus.

7.4.1 sys.server_event_sessions

Afficher les définitions de session stockées sur le serveur :

SELECT
    name,
    event_retention_mode_desc,
    max_dispatch_latency,
    max_memory,
    max_event_size,
    memory_partition_mode_desc
FROM sys.server_event_sessions;

Cette vue catalogue affiche les détails de configuration de toutes les sessions définies.

7.4.2 sys.dm_xe_sessions

Afficher les sessions actuellement actives :

SELECT
    name,
    create_time,
    total_regular_buffers,
    regular_buffer_size,
    total_large_buffers,
    large_buffer_size
FROM sys.dm_xe_sessions;

Ce DMV fournit des informations d'exécution sur les sessions d'événements étendus actives.

7.4.3 sys.dm_xe_session_tarobtient

Consultation tars'associe aux sessions actives :

SELECT
    s.name AS SessionName,
    t.target_name,
    t.execution_count,
    t.execution_duration_ms
FROM sys.dm_xe_session_targets AS t
JOIN sys.dm_xe_sessions AS s
    ON s.address = t.event_session_address;

7.4.4 Autres services d'immatriculation des véhicules utiles

Des vues supplémentaires fournissent des informations complètes sur la session :

sys.dm_xe_session_events : Liste les événements des sessions actives
sys.dm_xe_session_event_actions : Affiche les actions configurées pour les événements de session
sys.dm_xe_objects : Catalogue tous les événements, actions et tarobtient
sys.dm_xe_object_columns : Champs de détails disponibles pour chaque type d'événement
sys.dm_xe_packages : Liste tous les packages d'événements étendus

8. Cas d'utilisation pratiques et exemples

8.1 Surveillance de l'exécution des instructions SQL

Le suivi de l'exécution des instructions SQL permet de mieux comprendre les modèles de requêtes et leurs caractéristiques de performance.

8.1.1 Suivi des événements sql_statement_completed

Créez une session pour surveiller les instructions SQL exécutées :

CREATE EVENT SESSION [QueryMonitoring] ON SERVER
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(
        sqlserver.sql_text,
        sqlserver.database_name,
        sqlserver.client_hostname,
        sqlserver.username
    )
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\QueryMonitoring.xel',
        max_file_size=(100),
        max_rollover_files=(5)
)
WITH (
    MAX_MEMORY=4096 KB,
    EVENT_RETENTION_MODE=ALLOW_SINGLE_EVENT_LOSS,
    MAX_DISPATCH_LATENCY=30 SECONDS,
    STARTUP_STATE=OFF
);

ALTER EVENT SESSION [QueryMonitoring] ON SERVER STATE = START;

8.1.2 Filtrage par base de données ou application

Concentrez-vous sur des bases de données ou des applications spécifiques en utilisant des prédicats :

CREATE EVENT SESSION [AppSpecificMonitoring] ON SERVER
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(sqlserver.sql_text, sqlserver.client_app_name)
    WHERE (
        [sqlserver].[database_name] = N'YourDatabase'
        AND [sqlserver].[client_app_name] LIKE N'YourApplication%'
    )
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\AppMonitoring.xel'
);

8.2 Collecte des informations sur les interblocages

L'analyse des interblocages nécessite la collecte d'informations détaillées sur les transactions conflictuelles.

8.2.1 Événement xml_deadlock_report

Créez une session pour capturer les graphiques d'interblocage complets :

CREATE EVENT SESSION [DeadlockMonitoring] ON SERVER
ADD EVENT sqlserver.xml_deadlock_report(
    ACTION(
        sqlserver.database_name,
        sqlserver.sql_text
    )
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\Deadlocks.xel'
)
WITH (STARTUP_STATE=ON);

ALTER EVENT SESSION [DeadlockMonitoring] ON SERVER STATE = START;

8.2.2 Analyse des graphes d'interblocage

Extraire et analyser les informations relatives aux interblocages :

SELECT
    EventXML.value('(event/@timestamp)[1]', 'DATETIME2') AS DeadlockTime,
    EventXML.query('.') AS DeadlockGraph
FROM (
    SELECT CAST(event_data AS XML) AS EventXML
    FROM sys.fn_xe_file_target_read_file(
        'C:\XEvents\Deadlocks*.xel',
        NULL, NULL, NULL
    )
) AS EventData
WHERE EventXML.value('(event/@name)[1]', 'VARCHAR(50)') = 'xml_deadlock_report';

Le graphique d'interblocage contient des informations détaillées sur les processus, les ressources et la sélection des victimes.

8.3 Suivi des problèmes de performance des requêtes

Identifiez les requêtes peu performantes à l'aide des indicateurs de durée et de consommation de ressources.

8.3.1 Détection des requêtes de longue durée

Capture des requêtes dépassant des seuils de durée spécifiques :

CREATE EVENT SESSION [LongRunningQueries] ON SERVER
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(
        sqlserver.sql_text,
        sqlserver.database_name,
        sqlserver.plan_handle
    )
    WHERE ([duration] > 5000000)  -- 5 seconds in microseconds
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\LongQueries.xel'
);

8.3.2 Analyse du plan d'exécution

Capture des plans de requêtes pour l'analyse des performances :

CREATE EVENT SESSION [QueryPlans] ON SERVER
ADD EVENT sqlserver.query_post_execution_showplan(
    ACTION(
        sqlserver.sql_text,
        sqlserver.database_name
    )
    WHERE ([duration] > 10000000)  -- 10 seconds
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\QueryPlans.xel',
    max_file_size=(200)
);

8.4 Surveillance des événements de connexion et de sécurité

Suivre les activités d'authentification et d'autorisation à des fins d'audit de sécurité.

8.4.1 Suivi des succès et des échecs de connexion

Surveiller les tentatives de connexion réussies et échouées :

CREATE EVENT SESSION [LoginMonitoring] ON SERVER
ADD EVENT sqlserver.login(
    ACTION(
        sqlserver.client_hostname,
        sqlserver.client_app_name
    )
),
ADD EVENT sqlserver.login_failed(
    ACTION(
        sqlserver.client_hostname
    )
)
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\Logins.xel'
)
WITH (STARTUP_STATE=ON);

8.4.2 Modifications des autorisations

Suivi des modifications des autorisations de sécurité :

CREATE EVENT SESSION [SecurityChanges] ON SERVER
ADD EVENT sqlserver.server_principal_management_event,
ADD EVENT sqlserver.database_principal_management_event,
ADD EVENT sqlserver.database_permission_change_event
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\SecurityAudit.xel'
);

8.5 Surveillance au niveau de la base de données

Surveiller les opérations spécifiques à la base de données et les changements d'état.

8.5.1 Événements de sauvegarde et de restauration

Suivi des opérations de sauvegarde et de restauration :

CREATE EVENT SESSION [BackupMonitoring] ON SERVER
ADD EVENT sqlserver.backup_restore_progress_trace,
ADD EVENT sqlserver.databases_backup_restore_event
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\BackupRestore.xel'
);

8.5.2 Modifications de l'état de la base de données

Surveiller les transitions d'état de la base de données :

CREATE EVENT SESSION [DatabaseStateChanges] ON SERVER
ADD EVENT sqlserver.database_started,
ADD EVENT sqlserver.database_stopped
ADD TARGET package0.ring_buffer;

8.6 Détection de la corruption des bases de données et des problèmes d'intégrité

SQL Server Extended Events offre des capacités d'alerte précoce pour détecter les corruptions potentielles de bases de données, permettant une intervention proactive avant que les problèmes ne s'aggravent.

8.6.1 Événements clés pour la détection de la corruption

Plusieurs événements signalent une corruption potentielle ou des problèmes d'E/S.

8.6.1.1 Événement error_reported pour les erreurs critiques

L'événement error_reported capture tout SQL Server erreurs, y compris les numéros d'erreur liés à la corruption :

ADD EVENT sqlserver.error_reported(
    WHERE (
        [severity] >= (20)
        OR [error_number] IN (823, 824, 825, 832, 855, 856)
    )
)

L'erreur 823 indique des erreurs d'E/S, l'erreur 824 signale des erreurs de cohérence logique et l'erreur 825 signale des succès de nouvelle tentative de lecture qui peuvent indiquer des problèmes matériels.

Événement 8.6.1.2 database_suspect_data_page

Cet événement se déclenche lorsque SQL Server rencontre une page suspecte :

ADD EVENT sqlserver.database_suspect_data_page

Les pages suspectes indiquent une corruption potentielle et sont enregistrées dans la table msdb.dbo.suspect_pages.

8.6.1.3 Événement errorlog_write

Capturez les entrées écrites dans le SQL Server Journal des erreurs :

ADD EVENT sqlserver.errorlog_written(
    WHERE ([severity] >= (16))
)

8.6.2 Création d'une session de surveillance de la corruption

Mettre en place une session exhaustive consacrée à la détection et au suivi de la corruption.

8.6.2.1 Filtrage des numéros d'erreur de corruption (823, 824, 825)

Créer un tarsession organisée par Geted et axée sur les indicateurs de corruption :

CREATE EVENT SESSION [CorruptionDetection] ON SERVER
ADD EVENT sqlserver.error_reported(
    ACTION(
        sqlserver.database_name,
        sqlserver.sql_text
    )
    WHERE (
        [error_number] IN (823, 824, 825, 832, 855, 856)
        OR [severity] >= (20)
    )
),
ADD EVENT sqlserver.database_suspect_data_page(
    ACTION(
        sqlserver.database_name
    )
)

8.6.2.2 Définition des niveaux de gravité appropriés

Inclure les erreurs graves pouvant indiquer une corruption :

WHERE (
    [severity] >= (20)
    OR [error_number] IN (823, 824, 825)
)

Un niveau de gravité de 20 et plus indique des problèmes au niveau du système, souvent liés à la corruption.

8.6.2.3 Configuration du fichier d'événements TarRecevez des alertes

Stocker les événements de corruption à des fins d'analyse et d'alerte :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\CorruptionMonitoring.xel',
        max_file_size=(50),
        max_rollover_files=(10)
)
WITH (
    STARTUP_STATE=ON,
    MAX_DISPATCH_LATENCY=5 SECONDS
);

ALTER EVENT SESSION [CorruptionDetection] ON SERVER STATE = START;

8.6.3 Analyse des données relatives aux événements de corruption

Extraire et interpréter les événements liés à la corruption à partir des données capturées.

8.6.3.1 Identification des pages suspectes

Requête pour les événements database_suspect_data_page :

SELECT
    EventXML.value('(event/@timestamp)[1]', 'DATETIME2') AS EventTime,
    EventXML.value('(event/data[@name="database_id"]/value)[1]', 'INT') AS DatabaseID,
    EventXML.value('(event/data[@name="file_id"]/value)[1]', 'INT') AS FileID,
    EventXML.value('(event/data[@name="page_id"]/value)[1]', 'BIGINT') AS PageID,
    EventXML.value('(event/action[@name="database_name"]/value)[1]', 'VARCHAR(128)') AS DatabaseName
FROM (
    SELECT CAST(event_data AS XML) AS EventXML
    FROM sys.fn_xe_file_target_read_file(
        'C:\XEvents\CorruptionMonitoring*.xel',
        NULL, NULL, NULL
    )
) AS EventData
WHERE EventXML.value('(event/@name)[1]', 'VARCHAR(50)') = 'database_suspect_data_page';

8.6.3.2 Extraction des détails et du contexte de l'erreur

Analyser les événements error_reported pour détecter les schémas de corruption :

SELECT
    EventXML.value('(event/@timestamp)[1]', 'DATETIME2') AS ErrorTime,
    EventXML.value('(event/data[@name="error_number"]/value)[1]', 'INT') AS ErrorNumber,
    EventXML.value('(event/data[@name="severity"]/value)[1]', 'INT') AS Severity,
    EventXML.value('(event/data[@name="message"]/value)[1]', 'VARCHAR(MAX)') AS ErrorMessage,
    EventXML.value('(event/action[@name="database_name"]/value)[1]', 'VARCHAR(128)') AS DatabaseName,
    EventXML.value('(event/action[@name="sql_text"]/value)[1]', 'VARCHAR(MAX)') AS SQLText
FROM (
    SELECT CAST(event_data AS XML) AS EventXML
    FROM sys.fn_xe_file_target_read_file(
        'C:\XEvents\CorruptionMonitoring*.xel',
        NULL, NULL, NULL
    )
) AS EventData
WHERE EventXML.value('(event/@name)[1]', 'VARCHAR(50)') = 'error_reported'
    AND EventXML.value('(event/data[@name="error_number"]/value)[1]', 'INT') IN (823, 824, 825);

8.6.4 Intégration avec DBCC CHECKDB

Utilisez les données des événements étendus comme guide DBCC CHECKDB exécution.

8.6.4.1 Déclenchement de DBCC CHECKDB en fonction d'événements

En cas de détection d'événements de corruption, exécutez DBCC CHECKDB pour une validation complète :

-- After detecting corruption events, run DBCC CHECKDB
DBCC CHECKDB ('YourDatabaseName') WITH NO_INFOMSGS, ALL_ERRORMSGS;

Extended Events fournit une alerte précoce, tandis que DBCC CHECKDB effectue une validation approfondie.

8.6.4.2 Flux de travail automatisés de réponse à la corruption

Mettre en œuvre des réponses automatisées en surveillant le fichier d'événements :

Configurez SQL Server Tâche de l'agent : interroger périodiquement le fichier d'événements de surveillance de la corruption.
En cas de détection d'événements de corruption, exécutez DBCC CHECKDB sur la base de données concernée.
Envoyer des alertes par e-mail aux administrateurs de bases de données contenant les détails de l'événement et les résultats de DBCC CHECKDB.
Consignez les résultats dans un tableau de suivi centralisé pour l'analyse des tendances.

8.6.4.3 Équilibrer la surveillance proactive et les performances

Extended Events offre une détection de corruption à faible surcharge par rapport à l'exécution fréquente de DBCC CHECKDB :

Exécutez les événements étendus en continu pour une détection de corruption en temps réel.
N’exécutez DBCC CHECKDB que lorsque des indicateurs de corruption apparaissent.
Planifiez des contrôles DBCC CHECKDB réguliers pendant les fenêtres de maintenance.
Utilisez les événements étendus pour identifier les bases de données qui nécessitent une attention immédiate.

Cette approche permet une surveillance proactive sans la consommation importante de ressources qu'impliquent des contrôles d'intégrité constants.

8.6.4.4 Réparation de la base de données corrompue

Si des corruptions sont détectées dans la base de données, vous pouvez utiliser DBCC CHECKDB pour corriger les corruptions mineures. En cas d'échec, vous pouvez essayer un outil tiers. outil de récupération de base de données SQL, qui offre généralement un taux de récupération plus élevé sur les bases de données gravement corrompues.

9. Événements étendus au niveau du serveur vs au niveau de la base de données

9.1 Sessions d'événements à portée du serveur

Les sessions au niveau du serveur surveillent l'activité sur l'ensemble du système. SQL Server Ces sessions sont créées avec la clause ON SERVER et sont conservées dans la base de données principale.

CREATE EVENT SESSION [ServerWideMonitoring] ON SERVER
ADD EVENT sqlserver.sql_statement_completed
ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\ServerWide.xel'
);

Les sessions au niveau du serveur capturent les événements de toutes les bases de données et conviennent à la surveillance au niveau de l'instance.

9.2 Sessions d'événements à portée de base de données (Azure SQL Database)

Les sessions à portée de base de données sont limitées à une seule base de données et sont principalement utilisées dans Azure SQL Database où l'accès au niveau du serveur est restreint :

CREATE EVENT SESSION [DatabaseSpecificMonitoring] ON DATABASE
ADD EVENT sqlserver.sql_statement_completed
ADD TARGET package0.event_file(
    SET filename=N'DatabaseMonitoring.xel'
);

Dans Azure SQL Database, les fichiers d'événements sont stockés dans Azure Blob Storage plutôt que sur les systèmes de fichiers locaux.

9.3 Différences et cas d'utilisation

Les sessions au niveau du serveur offrent une surveillance complète de toutes les bases de données, mais nécessitent des privilèges élevés. Les sessions au niveau de la base de données offrent une isolation et sont appropriées pour la surveillance d'applications ou de locataires spécifiques.

Utilisez les sessions au niveau du serveur pour la surveillance centralisée, le dépannage des performances des bases de données et l'audit de sécurité. Utilisez les sessions au niveau de la base de données dans Azure SQL Database, les environnements mutualisés ou lorsque vous déléguez les responsabilités de surveillance aux équipes applicatives.

10. Événements étendus dans Azure SQL Database

10.1 Considérations spécifiques à Azure

Azure SQL Database implémente les événements étendus avec quelques différences par rapport aux solutions sur site. SQL ServerLes sessions sont par défaut limitées à la base de données, et le stockage des fichiers d'événements utilise Azure Blob Storage plutôt que les systèmes de fichiers locaux.

L'authentification auprès d'Azure Blob Storage nécessite un jeton SAS configuré dans le fichier d'événements. tarLa méthode `get` utilise des chaînes de connexion faisant référence au compte de stockage et au conteneur où sont stockés les fichiers d'événements.

10.2 Disponible Tarse connecte à Azure

Azure SQL Database prend en charge ces événements étendus tarobtient :

event_file : Écritures dans le stockage Blob Azure
ring_buffer : Stockage en mémoire avec le même comportement que sur site
event_counter : Compte les occurrences d'événements

Le fichier d'événements tarL'obtention nécessite une configuration avec les informations d'identification Azure Blob Storage :

ADD TARGET package0.event_file(
    SET filename=N'https://yourstorageaccount.blob.core.windows.net/container/EventFile.xel'
)

10.3 Création de sessions à portée de base de données

Créer une session dans Azure SQL Database :

CREATE EVENT SESSION [AzureMonitoring] ON DATABASE
ADD EVENT sqlserver.sql_statement_completed(
    ACTION(sqlserver.sql_text, sqlserver.database_name)
)
ADD TARGET package0.ring_buffer
WITH (MAX_MEMORY=4096 KB);

ALTER EVENT SESSION [AzureMonitoring] ON DATABASE STATE = START;

Les sessions à portée de base de données dans Azure se comportent de manière similaire aux sessions à portée de serveur sur site, mais leur portée est limitée à la base de données actuelle.

11. Meilleures pratiques et optimisation des performances

11.1 Minimiser l'impact sur les performances

Les événements étendus sont conçus pour une surcharge minimale, mais une configuration incorrecte peut impacter leurs performances. Suivez ces instructions :

Utilisez des prédicats spécifiques pour filtrer les événements plutôt que de tout enregistrer.
Évitez de collecter les actions inutiles qui augmentent la charge de traitement.
Choisissez approprié tarobtient en fonction des besoins de conservation des données
Définissez des tailles de tampon et des latences d'envoi raisonnables.
Surveiller la consommation des ressources de session à l'aide des DMV

11.2 Choisir les événements et les filtres appropriés

Sélectionnez les événements qui correspondent directement à vos objectifs de surveillance. Évitez les événements à haute fréquence, sauf nécessité, et appliquez systématiquement des prédicats pour réduire le volume de données.

Par exemple, au lieu de capturer tous les événements sql_statement_completed, filtrez par bases de données spécifiques ou par seuils de durée :

WHERE (
    [sqlserver].[database_name] = N'ProductionDB'
    AND [duration] > 1000000
)

11.3 Tarobtenir les directives de sélection

Choisissez tarobtient en fonction de vos besoins d'analyse :

Utilisez event_file pour une analyse historique détaillée et une conservation à long terme
Utilisez ring_buffer pour la surveillance en temps réel avec un impact minimal sur les E/S
Utilisez event_counter lorsque seule la fréquence compte.
Utiliser l'histogramme pour l'analyse de distribution
Utilisez la méthode pair_matching pour l'analyse d'événements corrélés

11.4 Recommandations de configuration de session

Configurez les sessions avec des limites de ressources appropriées :

Définissez MAX_MEMORY en fonction du volume d'événements prévu et des ressources du serveur.
Utilisez ALLOW_SINGLE_EVENT_LOSS pour une surcharge minimale en most scénarios
Définissez MAX_DISPATCH_LATENCY pour équilibrer les besoins en temps réel et les performances.
Utilisez le partitionnement de mémoire PER_CPU sur les systèmes multiprocesseurs
Évitez STARTUP_STATE=ON sauf si une surveillance continue est requise

11.5 Gestion de la taille et de la conservation des fichiers d'événements

Configurez la rotation des fichiers pour éviter une utilisation illimitée du disque :

ADD TARGET package0.event_file(
    SET filename=N'C:\XEvents\Session.xel',
        max_file_size=(100),
        max_rollover_files=(10)
)

Cette configuration conserve environ 1 Go de données d'événements (10 fichiers × 100 Mo). Ajustez cette valeur en fonction de vos besoins de conservation et de l'espace de stockage disponible.

12. Dépannage des événements prolongés

12.1 Problèmes courants et solutions

Les problèmes courants liés aux événements étendus incluent les sessions ne capturant pas de données, la dégradation des performances et les fichiers tarDes problèmes peuvent survenir, ainsi qu'un comportement inattendu de la session.

12.2 Session ne capturant pas de données

Si une session ne capture pas les événements attendus :

Vérifiez que la session est started utilisant sys.dm_xe_sessions.
Vérifiez les prédicats pour vous assurer qu'ils n'excluent pas tous les événements.
Confirmer que les événements se déclenchent par temporarj'enlève les filtres.
Vérifiez les autorisations pour vous assurer que vous avez accès aux données de session.
Vérifier que tarLa configuration est correcte et accessible en écriture.

SELECT name, create_time
FROM sys.dm_xe_sessions
WHERE name = 'YourSessionName';

12.3 Dégradation des performances

Si les événements étendus entraînent des problèmes de performances :

Ajoutez des prédicats pour réduire le volume d'événements.
Supprimez les actions inutiles qui collectent des supplémentstaret données.
Augmentez la valeur de MAX_DISPATCH_LATENCY pour réduire la fréquence d'écriture.
Modifiez EVENT_RETENTION_MODE en ALLOW_SINGLE_EVENT_LOSS.
Envisagez d'utiliser ring_buffer au lieu d'event_file pour les événements à haute fréquence.

Fichier 12.4 TarObtenir des problèmes

Fichier tarLes problèmes rencontrés sont souvent liés aux autorisations ou à l'espace disque :

Vérifiez le SQL Server Le compte de service dispose des autorisations d'écriture sur le tarobtenir le répertoire.
Assurez-vous de disposer d'un espace disque suffisant.
Vérifiez que le chemin spécifié existe et est accessible.
Vérifiez la configuration de rotation des fichiers si la rotation ne se fait pas comme prévu.

12.5 Débogage avec les vues système

Utilisez les DMV pour diagnostiquer les problèmes liés aux événements étendus :

-- Check session status
SELECT s.name, s.create_time, s.total_regular_buffers, s.total_large_buffers
FROM sys.dm_xe_sessions AS s;

-- View session targets and their status
SELECT
    s.name AS SessionName,
    t.target_name,
    t.execution_count,
    CAST(t.target_data AS XML) AS TargetData
FROM sys.dm_xe_session_targets AS t
JOIN sys.dm_xe_sessions AS s
    ON s.address = t.event_session_address;

-- Check for dropped events
SELECT s.name, s.dropped_event_count, s.dropped_buffer_count
FROM sys.dm_xe_sessions AS s;

13. Sujets avancés

13.1 Création de forfaits événementiels personnalisés

Les utilisateurs avancés peuvent créer des packages d'événements personnalisés pour étendre SQL Server Fonctionnalités d'événements étendus. Cela nécessite un développement C++ et une intégration avec le SQL Server cadre d'extensibilité.

Les packages personnalisés permettent de surveiller les événements spécifiques à une application ou d'intégrer des systèmes de surveillance tiers à l'infrastructure Extended Events.

13.2 Modèles de session d'événement

SSMS propose des modèles intégrés pour les scénarios de surveillance courants. Accédez à ces modèles lors de la création de nouvelles sessions via l'assistant :

Dans la boîte de dialogue Nouvelle session, cliquez sur Modèle menu déroulant.
Sélectionnez un modèle parmi ceux disponibles, tels que Suivi des détails des requêtes ou État du système.
Modifiez le modèle pour l'adapter à vos besoins spécifiques.

13.3 Intégration avec les solutions de surveillance

Les données des événements étendus peuvent alimenter les solutions de surveillance d'entreprise :

Exporter les données d'événements vers des systèmes de journalisation centralisés
Analyser les fichiers d'événements et charger les données dans les bases de données de surveillance.
Créez des tableaux de bord personnalisés à l'aide d'outils de BI.
Déclencher des alertes en fonction de modèles d'événements spécifiques
Corrélatif SQL Server événements avec des métriques d'application et d'infrastructure

13.4 Automatisation et planification

Automatisez la gestion des événements étendus à l'aide de SQL Server Agent:

Créer des emplois pour starinterrompre/arrêter les sessions pendant des plages horaires spécifiques
Planifiez l'analyse et le reporting des fichiers d'événements.
Mettez en œuvre des politiques de conservation des données en archivant ou en supprimant les anciens fichiers d'événements.
Automatiser la réponse aux conditions détectées telles que les problèmes de performance ou les événements de sécurité

14. Migration depuis SQL Server Profiler

14.1 SQL Server Correspondance entre les événements du profileur et les événements étendus

Microsoft fournit une cartographie entre SQL Server Profiler Événements et événements étendus. Les correspondances courantes incluent :

SQL:BatchTerminé -> sql_batch_completed
SQL:BatchStarting -> sql_batch_starting
SQL:StmtCompleted -> sql_statement_completed
SQL:StateStarting -> requête_sqltarting
Graphique d'interblocage -> rapport d'interblocage XML
Connexion audit -> connexion
Déconnexion de l'audit -> déconnexion

14.2 Conversion des définitions de traces

Convertir l'existant SQL Server Profiler établit des liens avec les sessions d'événements étendus en identifiant les événements équivalents et en configurant les prédicats appropriés. SSMS facilite les conversions courantes.

Examinez les filtres de trace et convertissez-les en prédicats d'événements étendus. Les actions dans les événements étendus remplacent les colonnes de trace provenant de SQL Server Profileur.

14.3 Comparaison des performances

Les événements étendus offrent des performances nettement supérieures à SQL Server Profiler. Des études comparatives montrent que les événements étendus consomment moins de cycles CPU et ont un impact moindre sur le débit des transactions.

Les événements étendus utilisent un traitement asynchrone et une gestion optimisée de la mémoire, tandis que SQL Server Profiler s'appuie sur une capture d'événements synchrone qui bloque jusqu'à la fin du traitement des traces.

15. Conclusion

15.1 Résumé des concepts clés

SQL Server Extended Events offre un cadre puissant et léger pour la surveillance et le dépannage. SQL ServerL'architecture se compose d'événements, d'actions, de prédicats, taret des sessions qui fonctionnent ensemble pour capturer l'activité pertinente du serveur.

Les sessions peuvent être créées à l'aide de SSMS ou de T-SQL, offrant une flexibilité pour le dépannage ponctuel et la surveillance automatisée. tarLes types get prennent en charge différentes approches d'analyse, de la surveillance en temps réel avec ring_buffer à l'analyse historique avec event_file.

Extended Events offre des performances supérieures à celles de SQL Server Profiler offre des fonctionnalités de surveillance plus complètes. Le système permet aux administrateurs et développeurs de bases de données de diagnostiquer les problèmes, d'optimiser les performances, de renforcer la sécurité et de garantir la conformité.

15.2 Prochaines étapes et ressources supplémentaires

Pour continuer à développer votre SQL Server Expertise XEvents :

Mettez en œuvre les événements étendus dans des environnements de test pour acquérir une expérience pratique.
Consultez la documentation Microsoft pour obtenir les catalogues d'événements complets et une référence de syntaxe détaillée.
Joignez-vous au SQL Server Forums communautaires pour apprendre des expériences des autres
Explorez des scénarios avancés tels que les packages personnalisés et l'intégration avec les plateformes de surveillance
Développer une bibliothèquerary de modèles de session pour les scénarios de surveillance courants

Section FAQ 16

Q: Quels sont SQL Server Événements prolongés ?

A: SQL Server Extended Events est un système de surveillance des performances léger intégré à l'infrastructure. SQL Server Moteur de base de données qui capture des informations détaillées sur les opérations du serveur avec une surcharge minimale.

Q : En quoi les événements étendus diffèrent-ils des SQL Server Profileur ?

A : Les événements étendus offrent de meilleures performances, une surcharge réduite et une configuration plus flexible que SQL Server Profileur. SQL Server Profiler est obsolète et Microsoft recommande d'utiliser les événements étendus pour toutes les tâches de surveillance.

Q : Les événements prolongés peuvent-ils avoir un impact ? SQL Server performance?

A : Correctement configurés avec des prédicats et des limites de ressources appropriés, les événements étendus ont un impact minimal sur les performances. Une mauvaise configuration, sans filtrage, peut en revanche les affecter.

Q : Quelles autorisations sont requises pour créer des sessions d'événements étendus ?

R : Vous avez besoin de l'autorisation ALTER ANY EVENT SESSION pour les sessions au niveau du serveur ou de l'autorisation CONTROL sur la base de données pour les sessions au niveau de la base de données.

Q : Comment puis-je consulter les données des événements étendus ?

R : Utiliser SQL Server Visualiseur de données en direct de Management Studio, interrogez les fichiers d'événements avec sys.fn_xe_file_target_read_file, ou interroger les données du tampon circulaire via les DMV.

Q : Les événements étendus peuvent-ils détecter une corruption de la base de données ?

A: Oui, les événements étendus peuvent capturer les erreurs liées à la corruption (823, 824, 825) et les événements de page suspects, fournissant un avertissement précoce pour les problèmes de corruption potentiels.

Q : Quelle est la différence entre les événements, les actions et les prédicats ?

A : Les événements sont des occurrences que vous souhaitez surveiller. Les actions ajoutent des informations complémentaires.tarLes informations sont associées aux événements capturés. Des prédicats filtrent les événements en fonction de conditions afin de réduire le volume de données.

Q : Comment puis-je surveiller les requêtes provenant d'applications ou de bases de données spécifiques ?

A : Utilisez des prédicats dans la configuration de votre événement pour filtrer par database_name, client_app_name ou d'autres champs pertinents.

Q: quoi tarQue dois-je utiliser pour les événements étendus ?

A: Utilisez event_file pour le stockage persistant et l'analyse historique, ring_buffer pour la surveillance en temps réel avec une faible surcharge, event_counter pour un suivi de fréquence simple et histogram pour l'analyse de distribution.

Q : Les événements étendus sont-ils disponibles dans Azure SQL Database ?

R : Oui, Azure SQL Database prend en charge les événements étendus à l'échelle de la base de données avec des fichiers d'événements stockés dans Azure Blob Storage.

Q : Comment puis-je dépanner une session d'événements étendus qui ne capture pas de données ?

A : Vérifiez que la session est starTed, vérifie que les prédicats ne filtrent pas tous les événements, confirme. tarRécupérez la configuration et examinez les autorisations à l'aide des DMV système.

Q : Puis-je automatiser la gestion des événements étendus ?

A : Oui, utilisez SQL Server Emplois d'agent à starArrêter/retirer les sessions, analyser les fichiers d'événements, mettre en œuvre des politiques de rétention et réagir aux conditions détectées.

Références

À propos de l’auteur

Yuan Sheng est un administrateur de base de données senior (DBA) avec plus de 10 ans d'expérience dans SQL Server Environnements et gestion de bases de données d'entreprise. Il a résolu avec succès des centaines de scénarios de récupération de bases de données dans des organisations du secteur financier, de la santé et de l'industrie manufacturière.

Yuan se spécialise dans SQL Server récupération de base de données, solutions à haute disponibilitéet l'optimisation des performances. Son expérience pratique approfondie comprend la gestion de bases de données multi-téraoctets et la mise en œuvre Groupes de disponibilité toujours activéset en développant des stratégies automatisées de sauvegarde et de restauration pour les systèmes d'information critiques de l'entreprise.

Grâce à son expertise technique et à son approche pratique, Yuan se concentre sur la création de guides complets qui aident les administrateurs de bases de données et les professionnels de l'informatique à résoudre des problèmes complexes. SQL Server défis efficacement. Il se tient au courant des dernières SQL Server les versions et les technologies de base de données en constante évolution de Microsoft, testant régulièrement des scénarios de récupération pour garantir que ses recommandations reflètent les meilleures pratiques du monde réel.

Vous avez des questions sur SQL Server Besoin d'aide pour la récupération de votre base de données ? Yuan vous accueille. commentaires et suggestions pour améliorer ces ressources techniques.

SQL Server Événements prolongés : surveillance, diagnostic et dépannage SQL Server [Guide 2026]

1. Introduction

1.1 Que sont SQL Server Événements prolongés ?