Destinazioni degli Eventi estesi

Si applica a: SQL Server, Database SQL di Azure e Istanza gestita di SQL di Azure

Questo articolo spiega quando e come usare le destinazioni per gli Eventi estesi. Per ogni destinazione, l'articolo presenta le informazioni seguenti:

• Le funzionalità di raccolta e creazione di report dei dati inviati dagli eventi
• I parametri, tranne nei casi in cui il parametro è facilmente comprensibile

Nella seguente tabella viene descritta la disponibilità di ogni tipo di destinazione in motori di database diversi.

Prerequisiti

Per sfruttare al meglio questo articolo, è necessario:

• Avere una certa familiarità con le nozioni di base relative agli Eventi estesi, come descritto in Avvio rapido: Eventi estesi.

• Avere installata la versione più recente di SQL Server Management Studio (SSMS). Per altre informazioni, vedere Scaricare SQL Server Management Studio (SSMS).

• In SSMS, sapere come usare Esplora oggetti per fare clic con il pulsante destro del mouse sul nodo di destinazione nella sessione eventi per semplificare la visualizzazione dei dati di output.

Parametri, azioni e campi

L'istruzione CREATE EVENT SESSION è fondamentale per gli Eventi estesi. Per scrivere l'istruzione, è necessario quanto segue:

• Eventi che si desidera aggiungere alla sessione
• I campi associati ad ogni evento selezionato
• Parametri associati a ogni destinazione che si desidera aggiungere alle sessioni

Le istruzioni SELECT, le quali restituiscono tali elenchi dalle visualizzazioni di sistema, possono essere copiate dalla sezione C dell'articolo seguente:

• Istruzioni SELECT e JOIN da viste di sistema per eventi estesi in SQL Server
  • C.4 Campi SELECT per un evento.
  • C.6 Parametri SELECT per una destinazione.
  • C.3 Azioni SELECT.

È possibile visualizzare parametri, campi e azioni usati nel contesto di un'istruzione effettiva CREATE EVENT SESSION, dalla sezione B2 (prospettiva T-SQL).

Destinazione etw_classic_sync_target

Gli Eventi estesi di SQL Server possono interagire con Event Tracing for Windows (ETW) per monitorare l'attività del sistema. Per altre informazioni, vedi:

• Destinazione di Event Tracing for Windows
• Monitorare l'attività del sistema mediante gli eventi estesi

Questa destinazione di ETW elaborai dati ricevuti in modalità sincrona, mentre la maggior parte delle destinazioni esegue l'elaborazione in modalità asincrona.

Destinazione event_counter

La destinazione event_counter calcola quante volte si verifica ogni evento specificato.

A differenza di quasi tutte le altre destinazioni:

• La destinazione event_counter non ha parametri.
• La destinazione event_counter elabora i dati ricevuti in modo sincrono.

Output di esempio acquisito dalla destinazione event_counter

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

Successivamente è l'istruzione CREATE EVENT SESSION che ha restituito i risultati precedenti. Per questo esempio, il campo package0.counter è stato usato nel predicato della clausola WHERE per interrompere il conteggio dopo che questo raggiunge 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
    );

Destinazione event_file

La destinazione event_file scrive l'output della sessione eventi dal buffer in un file disco o in un BLOB in Archiviazione di Azure:

• Specificare il parametro filename nella clausola ADD TARGET. L'estensione di file deve essere xel.
• Il nome file scelto viene usato dal sistema come prefisso a cui viene aggiunto un valore long integer basato su data-ora, seguito dall'estensione xel.

CREATE EVENT SESSION con destinazione event_file

Ecco un esempio di CREATE EVENT SESSION con una clausola ADD TARGET che aggiunge una destinazione event_file.

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

Funzione sys.fn_xe_file_target_read_file()

La destinazione event_file archivia i dati ricevuti in un formato binario che non è leggibile. La funzione sys.fn_xe_file_target_read_file consente di rappresentare il contenuto di un file xel come set di righe relazionale.

Per SQL Server 2016 e versioni successive, usare un'istruzione SELECT simile al seguente esempio.

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;

Per SQL Server 2014, usare un'istruzione SELECT simile al seguente esempio. Dopo SQL Server 2014, i file con estensione xem non sono stati più usati.

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;

In entrambi questi esempi, il carattere jolly * viene usato per leggere tutti i file xel che iniziano con il prefisso specificato.

In database SQL di Azure è possibile chiamare la funzione sys.fn_xe_file_target_read_file() dopo aver creato una credenziale con ambito database contenente un token di firma di accesso condiviso con le autorizzazioni Read e List per il contenitore con i BLOB xel:

/*
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;

Nell'istanza gestita di SQL di Azure è possibile chiamare la funzione sys.fn_xe_file_target_read_file() dopo aver creato una credenziale server contenente un token di firma di accesso condiviso con le autorizzazioni Read e List per il contenitore con i BLOB xel:

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;

Dati archiviati nella destinazione event_file

Questo è un esempio di dati restituiti da sys.fn_xe_file_target_read_file in SQL Server 2016 (13.x) e versioni successive.

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

Destinazione histogram

La destinazione histogram può:

• Contare le occorrenze per più elementi separatamente
• Contare le occorrenze di diversi tipi di elementi:
  • Campi dell'evento
  • Azioni

La destinazione histogram elabora i dati ricevuti in modo sincrono.

Il parametro source_type è l'elemento chiave per il controllo della destinazione istogramma:

• source_type=0: raccoglie i dati per un campo evento.
• source_type=1: raccogliere dati per un'azione. Si tratta dell'impostazione predefinita.

Il valore predefinito del parametro slots è 256. Se si assegna un altro valore, il valore viene arrotondato alla successiva potenza di 2. Ad esempio, slots=59 viene arrotondato a 64. Il numero massimo di slot istogrammi per una destinazione histogram è 16384.

Quando si usa histogram come destinazione, potrebbero in alcuni casi essere visualizzati risultati imprevisti. Alcuni eventi potrebbero non apparire negli slot previsti, mentre altri slot potrebbero mostrare un numero di eventi superiore a quello previsto.

Ciò può accadere se si verifica una collisione hash quando si assegnano eventi agli slot. Anche se questo è raro, se si verifica una collisione hash, un evento che deve essere conteggiato in uno slot viene conteggiato in un altro. Per questo motivo, è necessario valutare attentamente nel presupporre che un evento non si sia verificato solo perché il conteggio in uno slot specifico è pari a zero.

Come esempio, esaminare lo scenario seguente:

• Per raccogliere l'esecuzione della stored procedure, è possibile configurare una sessione Eventi estesi usando histogram come destinazione e raggruppamento per object_id.
• Si esegue la stored procedure A; eseguire quindi stored procedure B.

Se la funzione hash restituisce lo stesso valore per entrambe le stored procedure object_id, l'istogramma mostra stored procedure A in esecuzione due volte e la stored procedure B non viene visualizzata.

Per attenuare questo problema quando il numero di valori distinti è relativamente piccolo, impostare il numero di slot istogrammi superiore al quadrato dei valori distinti previsti. Ad esempio, se la destinazione histogram ha source impostato sul campo evento table_name e nel database sono presenti 20 tabelle, 20*20 = 400. La potenza successiva di 2 maggiore di 400 è 512, ossia il numero consigliato di slot in questo esempio.

Destinazione istogramma con un'azione

Nella clausola ADD TARGET ... (SET ...), l'istruzione CREATE EVENT SESSION seguente specifica l'assegnazione di parametri di destinazione source_type=1. Questo significa che la destinazione istogramma tiene traccia di un'azione.

Nell'esempio presente la clausola ADD EVENT ... (ACTION ...) viene offerta solo un'azione da scegliere, ovvero sqlos.system_thread_id. Nella clausola ADD TARGET ... (SET ...) viene visualizzata l'assegnazione 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
        );

Sono stati acquisiti i dati seguenti. I valori nella colonna value sono valori system_thread_id. Ad esempio, sono stati acquisiti 236 blocchi nell'ambito del thread 6540.

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

Istruzione SELECT per individuare le azioni disponibili

L'istruzione SELECT C.3 può trovare le azioni che il sistema consente di specificare nell'istruzione CREATE EVENT SESSION. Nella clausola WHERE modificare prima di tutto il filtro o.name LIKE in modo da filtrare le azioni a cui si è interessati.

Di seguito è riportato un set di righe di esempio restituito da C.3 SELECT. L'azione system_thread_id è visualizzata nella seconda riga.

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

Destinazione istogramma con un campo evento

L'esempio imposta source_type=0. Il valore assegnato a source è un campo evento.

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

I dati seguenti sono stati acquisiti dalla destinazione histogram. I dati mostrano che nel database con ID=5 si sono verificati 7 eventi checkpoint_begin.

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

Istruzione SELECT per individuare i campi disponibili nell'evento selezionato

L'istruzione SELECT C.4 mostra i campi di evento che è possibile selezionare. Modificare prima di tutto il filtro o.name LIKE in modo da restituire il nome dell'evento scelto.

C.4 SELECT ha restituito il set di righe seguente. Il set di righe mostra che database_id è l'unico campo dell'evento checkpoint_begin che può fornire valori per la destinazione histogram.

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

Destinazione pair_matching

La destinazione pair_matching consente di individuare gli eventi iniziali che si verificano senza un evento finale corrispondente. Ad esempio, se si verifica un evento lock_acquired che non è seguito tempestivamente da un evento lock_released, questo può costituire un problema.

Il sistema non stabilisce automaticamente la corrispondenza tra eventi iniziali ed eventi finali. Al contrario, la corrispondenza viene definita nell'istruzione CREATE EVENT SESSION. Quando viene stabilita una corrispondenza tra un evento iniziale e uno finale, la coppia viene eliminata per concentrarsi sugli eventi iniziali senza eventi finali corrispondenti.

Ricercare campi associabili per la coppia di eventi iniziale e finale

Usando C.4 SELECT, è possibile notare che nel set di righe seguente sono presenti circa 16 campi per l'evento lock_acquired. Il set di righe visualizzato qui è stato suddiviso manualmente per mostrare i campi in base ai quali è stata stabilita la corrispondenza. Per alcuni campi, ad esempio duration, il tentativo di corrispondenza è privo di significato.

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

Un esempio della destinazione pair_matching

L'istruzione CREATE EVENT SESSION seguente specifica due eventi e due destinazioni. La destinazione pair_matching specifica due set di campi in modo da stabilire la corrispondenza tra le coppie. La sequenza di campi delimitati da virgole assegnati a begin_matching_columns e end_matching_columns deve essere la stessa. Tra i campi indicati nel valore delimitato da virgole non sono consentiti caratteri di tabulazione o di nuova riga, ma possono essere usati gli spazi.

Per limitare i risultati, si è selezionato prima da sys.objects per trovare object_id della tabella di test. È stato aggiunto un filtro per tale ID oggetto nella clausola ADD EVENT ... (WHERE ...).

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

Per testare la sessione eventi, si è intenzionalmente impedito il rilascio di blocchi acquisiti. A tal fine, si sono eseguiti i passaggi T-SQL seguenti:

1. BEGIN TRANSACTION.
2. UPDATE MyTable....
3. Non emettere intenzionalmente COMMIT TRANSACTION, fino a quando non sono state esaminate le destinazioni.
4. Successivamente, dopo il test, è stato emesso COMMIT TRANSACTION.

La semplice destinazione event_counter ha fornito le righe di output seguenti. Poiché 52-50=2, l'output indica che, quando si esamina l'output della destinazione pair-matching, sono visibili due eventi lock_acquired non abbinati.

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

La destinazione pair_matching ha fornito le righe di output seguenti. Come suggerito dall'output event_counter, le due righe lock_acquired vengono effettivamente visualizzate. Ciò significa che questi due eventi lock_acquired non sono abbinati.

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

Le righe per gli eventi lock_acquired non abbinati possono includere il testo T-SQL fornito dall'azione sqlserver.sql_text. In questo modo viene acquisita la query che ha a sua volta acquisito i blocchi.

destinazione ring_buffer

La destinazione ring_buffer è utile solo per una raccolta di eventi rapida e semplice in memoria. Quando si arresta la sessione eventi, l'output archiviato viene rimosso.

In questa sezione viene inoltre illustrato come usare XQuery per convertire la rappresentazione XML dei contenuti del buffer circolare in un set di righe relazionale più leggibile.

I dati vengono utilizzati da una destinazione ring_buffer convertendoli in XML, come illustrato nell'esempio seguente. Durante questa conversione, tutti i dati che non rientrano in un documento XML da 4 MB vengono omessi. Pertanto, anche se si acquisiscono più eventi nel buffer circolare utilizzando valori MAX_MEMORY più grandi (o lasciando questo parametro al valore predefinito), potrebbe non essere possibile utilizzarli tutti a causa del limite di 4 MB per le dimensioni del documento XML, considerando il sovraccarico di markup XML e stringhe Unicode.

Si sa che il contenuto del buffer circolare viene omesso durante la conversione in XML se l'attributo truncated nel documento XML è impostato su 1, ad esempio:

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

CREATE EVENT SESSION con destinazione ring_buffer

Ecco un esempio di creazione di una sessione eventi con una destinazione ring_buffer. In questo esempio il parametro MAX_MEMORY viene visualizzato due volte: una volta per impostare la memoria di destinazione ring_buffer su 1024 KB e una volta per impostare la memoria del buffer della sessione eventi su 2 MB.

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

Output XML ricevuto per lock_acquired dalla destinazione ring_buffer

Quando viene recuperato da un'istruzione SELECT, il contenuto di un buffer circolare viene presentato come documento XML. Viene mostrato un esempio di seguito. Tuttavia, per brevità, tutti gli elementi <event> tranne due sono stati rimossi. Inoltre, all'interno di ogni <event>, sono stati rimossi anche alcuni elementi <data>.

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

Per visualizzare il codice XML precedente, è possibile eseguire l'istruzione SELECT seguente mentre è attiva la sessione eventi. I dati XML vengono recuperati dalla vista di sistema sys.dm_xe_session_targets.

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 per visualizzare il codice XML come set di righe

Per visualizzare il codice XML precedente come set di righe relazionale, continuare dall'istruzione SELECT precedente ed eseguire il codice T-SQL seguente. Le righe commentate spiegano ogni uso di 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);

Note di XQuery dall'istruzione SELECT precedente

(A)

• Valore dell'attributo timestamp= sull'elemento <event>.
• Il costrutto '(...)[1]' garantisce la restituzione di un solo valore per iterazione, poiché questa è una limitazione obbligatoria del metodo di XQuery .value() per variabili e colonne di tipo XML.

(B)

• Valore interno dell'elemento <text>, all'interno di un elemento <data>, con il relativo attributo name= uguale a mode.

(C)

• Valore interno degli elementi <value>, all'interno di un elemento <data>, con il relativo attributo name= uguale a transaction_id.

(D)

• <event> contiene <action>.
• <action>, avendo name= attributo uguale a database_name e package= uguale a sqlserver (non package0), ottiene il valore interno dell'elemento <value>.

(E)

• CROSS APPLY determina la ripetizione dell'elaborazione per ogni singolo elemento <event> con l'attributo name uguale a lock_acquired.
• Questo vale per il codice XML restituito dalla clausola FROM precedente.

Output di XQuery SELECT

Di seguito è riportato il set di righe generato dal codice T-SQL precedente che include XQuery.

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

destinazione event_stream

La destinazione event_stream può essere usata nei programmi .NET scritti in linguaggi come C#. C# e altri sviluppatori .NET possono accedere a un flusso di eventi tramite classi .NET Framework nello spazio dei nomi Microsoft.SqlServer.XEvents.Linq. Questa destinazione non può essere usata in T-SQL.

Se rilevato l'errore 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. durante la lettura della destinazione event_stream indica che il flusso di eventi riempito più velocemente rispetto al client può avere determinato il consumo dei dati. Di conseguenza, il motore di database si è disconnesso dal flusso di eventi per evitare di incidere sulle prestazioni del server.

Spazi dei nomi XEvent

• Spazio dei nomi Microsoft.SqlServer.Management.XEvent
• Spazio dei nomi Microsoft.SqlServer.XEvent.Linq