Cibles pour les événements étendus

S’applique à :SQL ServerAzure SQL DatabaseAzure SQL Managed Instance

Cet article explique quand et comment utiliser des cibles d’événements étendus. Pour chaque cible, cet article vous explique :

• Ses capacités de collecte et de création de rapports sur les données envoyées par les événements
• Ses paramètres, sauf si le paramètre est explicite

Le tableau suivant décrit la disponibilité de chaque type cible dans différents moteurs de base de données.

Type cible	SQL Server	Azure SQL Database	Azure SQL Managed Instance
etw_classic_sync_target	Oui	No	Non
event_counter	Oui	Oui	Oui
event_file	Oui	Oui	Oui
event_stream	Oui	Oui	Oui
Histogramme	Oui	Oui	Oui
pair_matching	Oui	No	Non
ring_buffer	Oui	Oui	Oui

Prérequis

Pour tirer le meilleur parti de cet article, vous devez :

• Familiarisez-vous avec les principes de base des événements étendus, comme décrit dans le guide de démarrage rapide : Événements étendus.

• Vous avez installé une version récente de SQL Server Management Studio (SSMS). Pour plus d’informations, consultez la page Télécharger SQL Server Management Studio (SSMS).

• Dans SSMS, savez comment utiliser l’Explorateur d’objets pour cliquer avec le bouton droit sur le nœud cible sous votre session d’événements, pour faciliter l’affichage des données de sortie.

Paramètres, actions et champs

L’instruction CREATE EVENT SESSION est essentielle aux événements étendus. Pour écrire l’instruction, vous avez besoin des éléments suivants :

• Événements que vous souhaitez ajouter à la session
• Champs associés à chaque événement choisi
• Paramètres associés à chaque cible que vous souhaitez ajouter aux sessions

Les instructions SELECT, qui retournent ces listes à partir des vues système sont disponibles pour les copier à partir de l’article suivant, dans sa section C :

• Utilisation de SELECT et JOIN dans les vues système pour les événements étendus dans SQL Server
  • C.4 Champs SELECT pour un événement.
  • C.6 Paramètres SELECT pour une cible.
  • C.3 Actions SELECT.

Vous pouvez voir les paramètres, les champs et les actions utilisés dans le contexte d’une instruction réelle CREATE EVENT SESSION , de la section B2 (perspective T-SQL).

Cible etw_classic_sync_target

Dans SQL Server, les événements étendus peuvent interagir avec le suivi des événements pour Windows (ETW) pour surveiller l’activité système. Pour plus d’informations, consultez l’article suivant :

• Suivi d’événements pour cible Windows
• Superviser l’activité système à l’aide d’événements étendus

Cette cible ETW traite les données qu’elle reçoit de manière synchrone, tandis que la plupart des cibles traitent de manière asynchrone.

Cible event_counter

La event_counter cible compte le nombre de fois où chaque événement spécifié se produit.

Contrairement à la plupart des autres cibles :

• La event_counter cible n’a aucun paramètre.
• La event_counter cible traite les données qu’elle reçoit de manière synchrone.

Exemple de sortie capturée par la cible event_counter

package_name   event_name         count
------------   ----------         -----
sqlserver      checkpoint_begin   4

Ensuite, l’instruction CREATE EVENT SESSION qui a retourné les résultats précédents. Pour cet exemple, le package0.counter champ a été utilisé dans le WHERE prédicat de clause pour arrêter le comptage une fois le nombre atteint 4.

CREATE EVENT SESSION [event_counter_1]
    ON SERVER
    ADD EVENT sqlserver.checkpoint_begin   -- Test by issuing CHECKPOINT; statements.
    (
        WHERE [package0].[counter] <= 4   -- A predicate filter.
    )
    ADD TARGET package0.event_counter
    WITH
    (
        MAX_MEMORY = 4096 KB,
        MAX_DISPATCH_LATENCY = 3 SECONDS
    );

event_file target

La event_file cible écrit la sortie de session d’événements de la mémoire tampon dans un fichier disque ou dans un objet blob dans Stockage Azure :

• Vous spécifiez le filename paramètre dans la ADD TARGET clause. L’extension de fichier doit être xel.
• Le nom de fichier que vous choisissez est utilisé par le système comme préfixe auquel un entier long basé sur la date est ajouté, suivi de l’extension xel .

CREATE EVENT SESSION avec cible event_file

Voici un exemple de clause CREATE EVENT SESSIONADD TARGET qui ajoute une event_file cible.

CREATE EVENT SESSION [locks_acq_rel_eventfile_22]
    ON SERVER
    ADD EVENT sqlserver.lock_acquired
    (
        SET
            collect_database_name=(1),
            collect_resource_description=(1)
        ACTION (sqlserver.sql_text,sqlserver.transaction_id)
        WHERE
        (
            [database_name]=N'InMemTest2'
            AND
            [object_id]=370100359
        )
    ),
    ADD EVENT sqlserver.lock_released
    (
        SET
            collect_database_name=1,
            collect_resource_description=1
        ACTION(sqlserver.sql_text,sqlserver.transaction_id)
        WHERE
        (
            [database_name]=N'InMemTest2'
            AND
            [object_id]=370100359
        )
    )
    ADD TARGET package0.event_counter,
    ADD TARGET package0.event_file
    (
        SET filename=N'C:\temp\locks_acq_rel_eventfile_22-.xel'
    )
    WITH
    (
        MAX_MEMORY=4096 KB,
        MAX_DISPATCH_LATENCY=10 SECONDS
    );

fonction sys.fn_xe_file_target_read_file()

La event_file cible stocke les données qu’elle reçoit dans un format binaire qui n’est pas lisible par l’homme. La fonction sys.fn_xe_file_target_read_file vous permet de représenter le contenu d’un xel fichier en tant qu’ensemble de lignes relationnelles.

Pour SQL Server 2016 et versions ultérieures, utilisez une SELECT instruction similaire à l’exemple suivant.

SELECT f.*
--,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
FROM sys.fn_xe_file_target_read_file(
    'C:\temp\locks_acq_rel_eventfile_22-*.xel', NULL, NULL, NULL)  AS f;

Pour SQL Server 2014, utilisez une SELECT instruction similaire à l’exemple suivant. Après SQL Server 2014, les xem fichiers ne sont plus utilisés.

SELECT f.*
--,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
FROM sys.fn_xe_file_target_read_file(
    'C:\temp\locks_acq_rel_eventfile_22-*.xel', 'C:\temp\metafile.xem', NULL, NULL) AS f;

Dans ces deux exemples, le * caractère générique carte est utilisé pour lire tous les xel fichiers qui commencent par le préfixe spécifié.

Dans Azure SQL Database, vous pouvez appeler la sys.fn_xe_file_target_read_file() fonction après avoir créé des informations d’identification délimitées à la base de données contenant un jeton SAP avec les autorisations et List les Read autorisations sur le conteneur avec les xel objets blob :

/*
Create a master key to protect the secret of the credential
*/
IF NOT EXISTS (
    SELECT 1
    FROM sys.symmetric_keys
    WHERE name = '##MS_DatabaseMasterKey##'
)
CREATE MASTER KEY;

/*
(Re-)create a database scoped credential.
The name of the credential must match the URI of the blob container.
*/
IF EXISTS (
    SELECT *
    FROM sys.database_credentials
    WHERE name = 'https://exampleaccount4xe.blob.core.windows.net/extended-events-container'
)
DROP DATABASE SCOPED CREDENTIAL [https://exampleaccount4xe.blob.core.windows.net/extended-events-container];

/*
The secret is the SAS token for the container. The Read and List permissions are set.
*/
CREATE DATABASE SCOPED CREDENTIAL [https://exampleaccount4xe.blob.core.windows.net/extended-events-container]
    WITH IDENTITY = 'SHARED ACCESS SIGNATURE',
        SECRET = 'sp=rl&st=2023-10-09T22:12:54Z&se=2023-10-10T06:12:54Z&spr=https&sv=2022-11-02&sr=c&sig=REDACTED';

/*
Return event session data
*/
SELECT f.*
--,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
FROM sys.fn_xe_file_target_read_file('https://exampleaccount4xe.blob.core.windows.net/extended-events-container/event-session-1', DEFAULT, DEFAULT, DEFAULT) AS f;

Dans Azure SQL Managed Instance, vous pouvez appeler la sys.fn_xe_file_target_read_file() fonction après avoir créé des informations d’identification de serveur contenant un jeton SAP avec les autorisations et List les Read autorisations sur le conteneur avec les xel objets blob :

IF NOT EXISTS (
    SELECT 1
    FROM sys.symmetric_keys
    WHERE name = '##MS_DatabaseMasterKey##'
)
CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'REDACTED';

/*
(Re-)create a database scoped credential.
The name of the credential must match the URI of the blob container.
*/
IF EXISTS (
    SELECT *
    FROM sys.credentials
    WHERE name = 'https://exampleaccount4xe.blob.core.windows.net/extended-events-container'
)
DROP CREDENTIAL [https://exampleaccount4xe.blob.core.windows.net/extended-events-container];

/*
The secret is the SAS token for the container. The Read and List permissions are set.
*/
CREATE CREDENTIAL [https://exampleaccount4xe.blob.core.windows.net/extended-events-container]
    WITH IDENTITY = 'SHARED ACCESS SIGNATURE',
        SECRET = 'sp=rl&st=2023-10-09T22:12:54Z&se=2023-10-10T06:12:54Z&spr=https&sv=2022-11-02&sr=c&sig=REDACTED';

/*
Return event session data
*/
SELECT f.*
--,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
FROM sys.fn_xe_file_target_read_file('https://exampleaccount4xe.blob.core.windows.net/extended-events-container/event-session-1', DEFAULT, DEFAULT, DEFAULT) AS f;

Données stockées dans la cible event_file

Il s’agit d’un exemple de données retournées sys.fn_xe_file_target_read_file dans SQL Server 2016 (13.x) et versions ultérieures.

module_guid                            package_guid                           object_name     event_data                                                                                                                                                                                                                                                                                          file_name                                                      file_offset
-----------                            ------------                           -----------     ----------                                                                                                                                                                                                                                                                                          ---------                                                      -----------
D5149520-6282-11DE-8A39-0800200C9A66   03FDA7D0-91BA-45F8-9875-8B6DD0B8E9F2   lock_acquired   <event name="lock_acquired" package="sqlserver" timestamp="2016-08-07T20:13:35.827Z"><action name="transaction_id" package="sqlserver"><value>39194</value></action><action name="sql_text" package="sqlserver"><value><![CDATA[  select top 1 * from dbo.T_Target;  ]]></value></action></event>   C:\temp\locks_acq_rel_eventfile_22-_0_131150744126230000.xel   11776
D5149520-6282-11DE-8A39-0800200C9A66   03FDA7D0-91BA-45F8-9875-8B6DD0B8E9F2   lock_released   <event name="lock_released" package="sqlserver" timestamp="2016-08-07T20:13:35.832Z"><action name="transaction_id" package="sqlserver"><value>39194</value></action><action name="sql_text" package="sqlserver"><value><![CDATA[  select top 1 * from dbo.T_Target;  ]]></value></action></event>   C:\temp\locks_acq_rel_eventfile_22-_0_131150744126230000.xel   11776

Cible d’histogramme

La histogram cible peut :

• Compter les occurrences pour plusieurs éléments séparément
• Compter les occurrences de différents types d’éléments :
  • Champs de l’événement
  • Actions

La histogram cible traite les données qu’elle reçoit de manière synchrone.

Le source_type paramètre est la clé du contrôle de la cible d’histogramme :

• source_type=0: collecter des données pour un champ d’événement.
• source_type=1: collecter des données pour une action. Il s’agit de la valeur par défaut.

La valeur par défaut du slots paramètre est 256. Si vous attribuez une autre valeur, la valeur est arrondie à la puissance de 2 la plus proche. Par exemple, les emplacements =59 sont arrondis à 64. Le nombre maximal d’emplacements d’histogramme pour une histogram cible est de 16384.

Lorsque vous utilisez histogram comme cible, vous pouvez parfois voir des résultats inattendus. Certains événements peuvent ne pas apparaître dans les emplacements attendus, tandis que d’autres emplacements peuvent afficher un nombre plus élevé d’événements que prévu.

Cela peut se produire si une collision de hachage se produit lors de l’affectation d’événements à des emplacements. Bien que cela soit rare, si une collision de hachage se produit, un événement qui doit être compté dans un emplacement est compté dans un autre. Pour cette raison, vous devez prendre soin de supposer qu’un événement n’a pas eu lieu simplement parce que le nombre dans un emplacement particulier indique zéro.

Par exemple, considérez le scénario suivant :

• Vous configurez une session Événements étendus, à l’aide histogram de la cible et du regroupement par object_id, pour collecter l’exécution de procédure stockée.
• Vous exécutez la procédure stockée A. Ensuite, vous exécutez la procédure stockée B.

Si la fonction de hachage retourne la même valeur pour les object_id deux procédures stockées, l’histogramme montre la procédure stockée A exécutée deux fois et la procédure stockée B n’apparaît pas.

Pour atténuer ce problème lorsque le nombre de valeurs distinctes est relativement petit, définissez le nombre d’emplacements d’histogrammes supérieurs au carré des valeurs distinctes attendues. Par exemple, si la histogram cible a sa source valeur définie sur le table_name champ d’événement et qu’il existe 20 tables dans la base de données, alors 20*20 = 400. La puissance suivante de 2 supérieure à 400 est 512, qui est le nombre recommandé d’emplacements dans cet exemple.

Cible d’histogramme avec une action

Dans sa ADD TARGET ... (SET ...) clause, l’instruction suivante CREATE EVENT SESSION spécifie l’attribution source_type=1de paramètre cible . Cela signifie que la cible d’histogramme suit une action.

Dans l’exemple présent, la ADD EVENT ... (ACTION ...) clause se produit pour offrir une seule action à choisir, à savoir sqlos.system_thread_id. Dans la ADD TARGET ... (SET ...) clause, nous voyons l’affectation source=N'sqlos.system_thread_id'.

CREATE EVENT SESSION [histogram_lockacquired]
    ON SERVER
    ADD EVENT sqlserver.lock_acquired
        (
        ACTION
            (
            sqlos.system_thread_id
            )
        )
    ADD TARGET package0.histogram
        (
        SET
            filtering_event_name=N'sqlserver.lock_acquired',
            slots=16,
            source=N'sqlos.system_thread_id',
            source_type=1
        );

Les données suivantes ont été capturées. Les valeurs de la value colonne sont des system_thread_id valeurs. Par exemple, un total de 236 verrous ont été effectués sous le thread 6540.

value   count
-----   -----
 6540     236
 9308      91
 9668      74
10144      49
 5244      44
 2396      28

Utilisez l’instruction SELECT pour découvrir les actions disponibles

L’instruction C.3SELECT peut trouver les actions que le système a disponibles pour vous permettre de spécifier dans l’instructionCREATE EVENT SESSION. Dans la WHERE clause, vous devez d’abord modifier le o.name LIKE filtre pour qu’il corresponde aux actions qui vous intéressent.

Ensuite, un exemple d’ensemble de lignes retourné par la C.3 SELECT. L’action system_thread_id est visible dans la deuxième ligne.

Package-Name   Action-Name                 Action-Description
------------   -----------                 ------------------
package0       collect_current_thread_id   Collect the current Windows thread ID
sqlos          system_thread_id            Collect current system thread ID
sqlserver      create_dump_all_threads     Create mini dump including all threads
sqlserver      create_dump_single_thread   Create mini dump for the current thread

Cible d’histogramme avec un champ d’événement

L’exemple suivant définit source_type=0. La valeur affectée est source un champ d’événement.

CREATE EVENT SESSION [histogram_checkpoint_dbid]
    ON SERVER
    ADD EVENT  sqlserver.checkpoint_begin
    ADD TARGET package0.histogram
    (
    SET
        filtering_event_name = N'sqlserver.checkpoint_begin',
        source               = N'database_id',
        source_type          = 0
    );

Les données suivantes ont été capturées par la histogram cible. Les données indiquent que la base de données avec l’ID 5 a connu 7 checkpoint_begin événements.

value   count
-----   -----
5       7
7       4
6       3

Utilisez l’instruction SELECT pour découvrir les champs disponibles sur l’événement choisi

L’instruction C.4SELECT affiche les champs d’événement parmi lesquels vous pouvez choisir. Vous devez d’abord modifier le o.name LIKE filtre pour qu’il soit votre nom d’événement choisi.

L’ensemble de lignes suivant a été retourné par la C.4 SELECT. L’ensemble de lignes indique qu’il database_id s’agit du seul champ de l’événement checkpoint_begin qui peut fournir des valeurs pour la histogram cible.

Package-Name   Event-Name         Field-Name   Field-Description
------------   ----------         ----------   -----------------
sqlserver      checkpoint_begin   database_id  NULL
sqlserver      checkpoint_end     database_id  NULL

Cible pair_matching

La pair_matching cible vous permet de détecter les événements de démarrage qui se produisent sans événement de fin correspondant. Par exemple, il peut s’agir d’un problème lorsqu’un lock_acquired événement se produit, mais qu’aucun événement correspondant lock_released ne suit en temps voulu.

Le système ne correspond pas automatiquement aux événements de début et de fin. Au lieu de cela, vous expliquez la correspondance avec le système dans votre CREATE EVENT SESSION instruction. Lorsqu’un événement de début et de fin est mis en correspondance, la paire est dis carte ed pour se concentrer sur les événements de début sans correspondance.

Rechercher des champs matchables pour la paire d’événements de début et de fin

À l’aide de C.4 SELECT, nous voyons dans l’ensemble de lignes suivant environ 16 champs pour l’événement lock_acquired . L’ensemble de lignes affiché ici a été fractionné manuellement pour indiquer les champs mis en correspondance de notre exemple. Pour certains champs tels que durationla tentative de correspondance est sans signification.

Package-Name   Event-Name   Field-Name               Field-Description
------------   ----------   ----------               -----------------
sqlserver   lock_acquired   database_name            NULL
sqlserver   lock_acquired   mode                     NULL
sqlserver   lock_acquired   resource_0               The ID of the locked object, when lock_resource_type is OBJECT.
sqlserver   lock_acquired   resource_1               NULL
sqlserver   lock_acquired   resource_2               The ID of the lock partition, when lock_resource_type is OBJECT, and resource_1 is 0.
sqlserver   lock_acquired   transaction_id           NULL

sqlserver   lock_acquired   associated_object_id     The ID of the object that requested the lock that was acquired.
sqlserver   lock_acquired   database_id              NULL
sqlserver   lock_acquired   duration                 The time (in microseconds) between when the lock was requested and when it was canceled.
sqlserver   lock_acquired   lockspace_nest_id        NULL
sqlserver   lock_acquired   lockspace_sub_id         NULL
sqlserver   lock_acquired   lockspace_workspace_id   NULL
sqlserver   lock_acquired   object_id                The ID of the locked object, when lock_resource_type is OBJECT. For other lock resource types it will be 0
sqlserver   lock_acquired   owner_type               NULL
sqlserver   lock_acquired   resource_description     The description of the lock resource. The description depends on the type of lock. This is the same value as the resource_description column in the sys.dm_tran_locks view.
sqlserver   lock_acquired   resource_type            NULL

Exemple de la cible pair_matching

L’instruction suivante CREATE EVENT SESSION spécifie deux événements et deux cibles. La pair_matching cible spécifie deux ensembles de champs pour qu’ils correspondent aux événements en paires. La séquence de champs délimités par des virgules affectées begin_matching_columns et end_matching_columns doit être identique. Aucun onglet ou nouvelle ligne n’est autorisé entre les champs mentionnés dans la valeur délimitée par des virgules, bien que les espaces soient autorisés.

Pour affiner les résultats, nous avons d’abord sélectionné sys.objects pour trouver le object_id tableau de test. Nous avons ajouté un filtre pour cet ID d’objet dans la ADD EVENT ... (WHERE ...) clause.

CREATE EVENT SESSION [pair_matching_lock_a_r_33]
    ON SERVER
    ADD EVENT sqlserver.lock_acquired
    (
        SET
            collect_database_name = 1,
            collect_resource_description = 1
        ACTION (sqlserver.transaction_id)
        WHERE
        (
            [database_name] = 'InMemTest2'
            AND
            [object_id] = 370100359
        )
    ),
    ADD EVENT sqlserver.lock_released
    (
        SET
            collect_database_name = 1,
            collect_resource_description = 1
        ACTION (sqlserver.transaction_id)
        WHERE
        (
            [database_name] = 'InMemTest2'
            AND
            [object_id] = 370100359
        )
    )
    ADD TARGET package0.event_counter,
    ADD TARGET package0.pair_matching
    (
        SET
            begin_event = N'sqlserver.lock_acquired',
            begin_matching_columns =
                N'resource_0, resource_1, resource_2, transaction_id, database_id',
            end_event = N'sqlserver.lock_released',
            end_matching_columns =
                N'resource_0, resource_1, resource_2, transaction_id, database_id',
            respond_to_memory_pressure = 1
    )
    WITH
    (
        MAX_MEMORY = 8192 KB,
        MAX_DISPATCH_LATENCY = 15 SECONDS
    );

Pour tester la session d’événements, nous avons délibérément empêché la libération de deux verrous acquis. Nous avons effectué cela en réalisant les étapes T-SQL suivantes :

1. BEGIN TRANSACTION.
2. UPDATE MyTable....
3. Inutile de émettre un COMMIT TRANSACTION, jusqu’à ce que nous ayons examiné les cibles.
4. Plus tard après le test, nous avons émis un COMMIT TRANSACTION.

La cible simple event_counter a fourni les lignes de sortie suivantes. Étant donné que 52-50=2, la sortie implique que nous voyons 2 événements non souhaités lock_acquired lorsque nous examinons la sortie de la cible de correspondance de paire.

package_name   event_name      count
------------   ----------      -----
sqlserver      lock_acquired   52
sqlserver      lock_released   50

La pair_matching cible a fourni la sortie suivante. Comme indiqué par la event_counter sortie, nous voyons en effet les deux lock_acquired lignes. Le fait que nous voyons ces lignes signifie que ces deux lock_acquired événements ne sont pas souhaités.

package_name   event_name      timestamp                     database_name   duration   mode   object_id   owner_type   resource_0   resource_1   resource_2   resource_description   resource_type   transaction_id
------------   ----------      ---------                     -------------   --------   ----   ---------   ----------   ----------   ----------   ----------   --------------------   -------------   --------------
sqlserver      lock_acquired   2016-08-05 12:45:47.9980000   InMemTest2      0          S      370100359   Transaction  370100359    3            0            [INDEX_OPERATION]      OBJECT          34126
sqlserver      lock_acquired   2016-08-05 12:45:47.9980000   InMemTest2      0          IX     370100359   Transaction  370100359    0            0                                   OBJECT          34126

Les lignes des événements non souhaités lock_acquired peuvent inclure le texte T-SQL fourni par l’action sqlserver.sql_text . Cela capture la requête qui a acquis les verrous.

Cible ring_buffer

La ring_buffer cible est pratique pour une collection d’événements rapide et simple en mémoire uniquement. Lorsque vous arrêtez la session d’événements, la sortie stockée est ignorée.

Dans cette section, nous montrons également comment utiliser XQuery pour convertir la représentation XML du contenu de la mémoire tampon en un ensemble de lignes relationnel plus lisible.

Vous consommez des données à partir d’une ring_buffer cible en la convertissant en XML, comme illustré dans l’exemple suivant. Pendant cette conversion, toutes les données qui ne correspondent pas à un document XML de 4 Mo sont omises. Par conséquent, même si vous capturez davantage d’événements dans la mémoire tampon d’anneau à l’aide de valeurs plus grandes MAX_MEMORY (ou en laissant ce paramètre à sa valeur par défaut), vous ne pourrez peut-être pas les consommer en raison de la limite de 4 Mo sur la taille du document XML, compte tenu de la surcharge de balisage XML et de chaînes Unicode.

Vous savez que le contenu de la mémoire tampon en anneau est omis lors de la conversion en XML si l’attribut truncated du document XML est défini 1sur , par exemple :

<RingBufferTarget truncated="1" processingTime="0" totalEventsProcessed="284" eventCount="284" droppedCount="0" memoryUsed="64139">

CREATE EVENT SESSION avec une cible ring_buffer

Voici un exemple de création d’une session d’événements avec une ring_buffer cible. Dans cet exemple, le MAX_MEMORY paramètre apparaît deux fois : une fois pour définir la ring_buffer mémoire cible sur 1024 Ko, et une fois pour définir la mémoire tampon de session d’événements sur 2 Mo.

CREATE EVENT SESSION [ring_buffer_lock_acquired_4]
    ON SERVER
    ADD EVENT sqlserver.lock_acquired
    (
        SET collect_resource_description=(1)
        ACTION(sqlserver.database_name)
        WHERE
        (
            [object_id]=(370100359)  -- ID of MyTable
            AND
            sqlserver.database_name='InMemTest2'
        )
    )
    ADD TARGET package0.ring_buffer
    (
        SET MAX_EVENTS_LIMIT = 98,
            MAX_MEMORY = 1024
    )
    WITH
    (
        MAX_MEMORY = 2 MB,
        MAX_DISPATCH_LATENCY = 3 SECONDS
    );

Sortie XML reçue pour lock_acquired par la cible ring_buffer

Lorsqu’une SELECT instruction est récupérée, le contenu d’une mémoire tampon en anneau est présenté sous la forme d’un document XML. Un exemple s’affiche ensuite. Toutefois, pour des raisons de concision, tous les deux <event> éléments ont été supprimés. En outre, dans chacun d’eux <event>, une poignée d’éléments <data> ont également été supprimés.

<RingBufferTarget truncated="0" processingTime="0" totalEventsProcessed="6" eventCount="6" droppedCount="0" memoryUsed="1032">
  <event name="lock_acquired" package="sqlserver" timestamp="2016-08-05T23:59:53.987Z">
    <data name="mode">
      <type name="lock_mode" package="sqlserver"></type>
      <value>1</value>
      <text><![CDATA[SCH_S]]></text>
    </data>
    <data name="transaction_id">
      <type name="int64" package="package0"></type>
      <value>111030</value>
    </data>
    <data name="database_id">
      <type name="uint32" package="package0"></type>
      <value>5</value>
    </data>
    <data name="resource_0">
      <type name="uint32" package="package0"></type>
      <value>370100359</value>
    </data>
    <data name="resource_1">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="resource_2">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="database_name">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[]]></value>
    </data>
    <action name="database_name" package="sqlserver">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[InMemTest2]]></value>
    </action>
  </event>
  <event name="lock_acquired" package="sqlserver" timestamp="2016-08-05T23:59:56.012Z">
    <data name="mode">
      <type name="lock_mode" package="sqlserver"></type>
      <value>1</value>
      <text><![CDATA[SCH_S]]></text>
    </data>
    <data name="transaction_id">
      <type name="int64" package="package0"></type>
      <value>111039</value>
    </data>
    <data name="database_id">
      <type name="uint32" package="package0"></type>
      <value>5</value>
    </data>
    <data name="resource_0">
      <type name="uint32" package="package0"></type>
      <value>370100359</value>
    </data>
    <data name="resource_1">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="resource_2">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="database_name">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[]]></value>
    </data>
    <action name="database_name" package="sqlserver">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[InMemTest2]]></value>
    </action>
  </event>
</RingBufferTarget>

Pour afficher le code XML précédent, vous pouvez émettre ce qui suit SELECT pendant que la session d’événements est active. Les données XML sont récupérées à partir de la vue sys.dm_xe_session_targetssystème.

SELECT CAST(LocksAcquired.TargetXml AS XML) AS RBufXml
INTO #XmlAsTable
FROM (
    SELECT CAST(t.target_data AS XML) AS TargetXml
    FROM sys.dm_xe_session_targets AS t
    INNER JOIN sys.dm_xe_sessions AS s
        ON s.address = t.event_session_address
    WHERE t.target_name = 'ring_buffer'
        AND s.name = 'ring_buffer_lock_acquired_4'
) AS LocksAcquired;

SELECT *
FROM #XmlAsTable;

XQuery pour afficher le code XML sous forme d’un ensemble de lignes

Pour voir le code XML précédent en tant qu’ensemble de lignes relationnelles, continuez à partir de l’instruction précédente SELECT en émettant le code T-SQL suivant. Les lignes commentées expliquent chaque utilisation de XQuery.

SELECT
    -- (A)
    ObjectLocks.value('(@timestamp)[1]', 'datetime') AS [OccurredDtTm],
    -- (B)
    ObjectLocks.value('(data[@name="mode"]/text)[1]', 'nvarchar(32)') AS [Mode],
    -- (C)
    ObjectLocks.value('(data[@name="transaction_id"]/value)[1]', 'bigint') AS [TxnId],
    -- (D)
    ObjectLocks.value('(action[@name="database_name" and @package="sqlserver"]/value)[1]', 'nvarchar(128)') AS [DatabaseName]
FROM #XmlAsTable
CROSS APPLY
    -- (E)
    TargetDateAsXml.nodes('/RingBufferTarget/event[@name="lock_acquired"]') AS T(ObjectLocks);

Notes de XQuery issues de l’instruction SELECT précédente

(A)

• timestamp= valeur de l’attribut, sur <event> l’élément.
• La '(...)[1]' construction garantit qu’une seule valeur retournée par itération est une limitation requise de la méthode XQuery de la .value() variable et des colonnes de type de données XML.

(B)

• <text> valeur interne de l’élément, dans un <data> élément, qui a son attribut name= égal à mode.

(C)

• <value> valeur interne des éléments, dans un <data> élément, qui a son attribut name= égal à transaction_id.

(D)

• <event> contient <action>.
• <action> avoir name= attribut égal à database_name, et package= attribut égal à sqlserver (non package0), obtenir la valeur interne de l’élément <value> .

(E)

• CROSS APPLY entraîne le traitement à répéter pour chaque élément individuel <event> , dont l’attribut name est égal à lock_acquired.
• Cela s’applique au code XML retourné par la clause précédente FROM .

Sortie de XQuery SELECT

Ensuite, l’ensemble de lignes généré par le T-SQL précédent, qui inclut XQuery.

OccurredDtTm              Mode    DatabaseName
------------              ----    ------------
2016-08-05 23:59:53.987   SCH_S   InMemTest2
2016-08-05 23:59:56.013   SCH_S   InMemTest2

cible event_stream

La event_stream cible ne peut être utilisée que dans les programmes .NET écrits dans des langages comme C#. C# et d’autres développeurs .NET peuvent accéder à un flux d’événements via des classes .NET Framework dans l’espace Microsoft.SqlServer.XEvents.Linq de noms. Cette cible ne peut pas être utilisée dans T-SQL.

Si vous rencontrez l’erreur 25726, The event data stream was disconnected because there were too many outstanding events. To avoid this error either remove events or actions from your session or add a more restrictive predicate filter to your session. lors de la lecture à partir de la event_stream cible, cela signifie que le flux d’événements remplis de données est plus rapide que le client peut consommer les données. Cela entraîne la déconnexion des Moteur de base de données du flux d’événements afin d’éviter d’affecter les performances Moteur de base de données.

Espaces de noms XEvent

• Espace de noms Microsoft.SqlServer.Management.XEvent
• Espace de noms Microsoft.SqlServer.XEvent.Linq