Destinazioni degli Eventi estesi
Si applica a:
SQL ServerDatabase SQL di AzureIstanza 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.
| Tipo di destinazione | SQL Server | database SQL di Azure | Istanza gestita di SQL di Azure |
|---|---|---|---|
| etw_classic_sync_target | Sì | No | No |
| event_counter | Sì | Sì | Sì |
| event_file | Sì | Sì | Sì |
| event_stream | Sì | Sì | Sì |
| histogram | Sì | Sì | Sì |
| pair_matching | Sì | No | No |
| ring_buffer | Sì | Sì | Sì |
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:
È 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.
Nota
L'istanza gestita di SQL di Azure e il database SQL di Azure non supportano la destinazione etw_classic_sync_target. In alternativa, usare la destinazione event_file con i BLOB archiviati in Archiviazione di Azure.
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_counternon ha parametri. - La destinazione
event_counterelabora 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
filenamenella clausolaADD TARGET. L'estensione di file deve esserexel. - 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.
Nota
Istanza gestita di SQL di Azure e database SQL di Azure solo BLOB in Archiviazione di Azure come valore del parametro filename.
Per un esempio di codice event_file specifico per il database SQL e Istanza gestita di SQL, vedere Codice di destinazione del file evento per Eventi estesi nel database SQL.
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;
Suggerimento
Se si specifica un prefisso del nome BLOB anziché il nome completo del BLOB nel primo argomento di sys.fn_xe_file_target_read_file(), la funzione restituirà i dati che corrispondono al prefisso da tutti i BLOB nel contenitore. In questo modo è possibile recuperare i dati da tutti i file di rollover di una determinata sessione eventi senza usare il carattere jolly *, il quale non è supportato da Archiviazione di Azure.
Gli esempi precedenti di Azure SQL omettono l'estensione xel per leggere tutti i file di rollover per una sessione denominata event-session-1.
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
histogramcome destinazione e raggruppamento perobject_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'.
Nota
Non è possibile aggiungere più di una destinazione dello stesso tipo per sessione di eventi. Ciò include la destinazione histogram. Inoltre, non è possibile avere più di un'origine (campo azione/evento) per ogni destinazione histogram. Pertanto, è necessaria una nuova sessione eventi per tenere traccia di eventuali azioni o campi eventi aggiuntivi in una destinazione separata histogram.
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 C.3SELECT 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 C.4SELECT 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:
BEGIN TRANSACTION.UPDATE MyTable....- Non emettere intenzionalmente
COMMIT TRANSACTION, fino a quando non sono state esaminate le destinazioni. - 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.
Suggerimento
Quando si aggiunge una destinazione ring_buffer, impostarne il parametro MAX_MEMORY su 1024 KB o meno. L'utilizzo di valori più grandi potrebbe aumentare inutilmente il consumo di memoria.
Per impostazione predefinita, MAX_MEMORY per una destinazione ring_buffer non è limitato in SQL Server ed è limitato a 32 MB in database SQL di Azure e Istanza gestita di SQL di Azure.
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 amode.
(C)
- Valore interno degli elementi
<value>, all'interno di un elemento<data>, con il relativo attributo name= uguale atransaction_id.
(D)
<event>contiene<action>.<action>, avendo name= attributo uguale adatabase_namee package= uguale asqlserver(nonpackage0), ottiene il valore interno dell'elemento<value>.
(E)
CROSS APPLYdetermina la ripetizione dell'elaborazione per ogni singolo elemento<event>con l'attributonameuguale alock_acquired.- Questo vale per il codice XML restituito dalla clausola
FROMprecedente.
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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per