Condividi tramite

Macro wrapper TraceLogging

  • Articolo

Le TraceLoggingWrite e TraceLoggingWriteActivity generano eventi TraceLogging configurati in base ai parametri della macro. Ognuna di queste macro accetta un set di parametri obbligatori seguito da un massimo di 99 parametri facoltativi. Ogni parametro facoltativo configura l'evento o aggiunge un campo all'evento. Ogni parametro facoltativo deve essere una delle macro TraceLogging Wrapper descritte in questa pagina.

Per esempio:

TraceLoggingWrite(
    g_hProvider,
    "MyEvent1",
    TraceLoggingLevel(WINEVENT_LEVEL_WARNING), // Levels defined in <winmeta.h>
    TraceLoggingKeyword(MyNetworkingKeyword),
    TraceLoggingString(operationName), // Adds an "operationName" field.
    TraceLoggingHResult(hr, "NetStatus")); // Adds a "NetStatus" field.

In questo esempio, g_hProvider e "MyEvent1" sono i parametri obbligatori. Specificano il provider da usare per l'evento e il nome dell'evento. Ognuno dei parametri rimanenti è una macro wrapper. I parametri TraceLoggingLevel e TraceLoggingKeyword configurano l'evento. I parametri TraceLoggingString e TraceLoggingHResult aggiungono campi all'evento.

Macro di configurazione eventi

Le macro seguenti configurano l'evento.

Se una particolare macro di configurazione non viene specificata nella TraceLoggingWrite, viene utilizzato un valore predefinito per tale evento. Ad esempio, se non viene usato alcun parametro TraceLoggingLevel per un evento, l'evento usa un livello predefinito di 5 (VERBOSE).

  • TraceLoggingLevel imposta il livello di dell'evento. Il livello è un valore a 8 bit che indica la gravità dell'evento. I livelli da 1 (WINEVENT_LEVEL_CRITICAL) a 5 (WINEVENT_LEVEL_VERBOSE) sono definiti in <winmeta.h>. Se non specificato, l'evento viene impostato per impostazione predefinita sul livello 5 (VERBOSE). Il livello è una parte importante del routing e del filtro degli eventi ETW, quindi tutti gli eventi devono avere un livello diverso da zero significativo.
  • TraceLoggingKeyword imposta la parola chiave dell'evento. Una parola chiave è un valore a 64 bit con ogni bit che indica una categoria a cui appartiene l'evento. I 48 bit bassi della parola chiave sono definiti dal proprietario del provider, mentre i 16 bit alti della parola chiave sono definiti da Microsoft. Ad esempio, è possibile decidere che tutti i provider con nome "MyCompany.MyComponent" useranno la parola chiave 0x1 per indicare "Rete". Se non specificato, l'evento usa per impostazione predefinita la parola chiave 0x0 (Nessuna). La parola chiave è una parte importante del routing e del filtro degli eventi ETW, pertanto tutti gli eventi devono avere una parola chiave significativa non zero.
  • TraceLoggingOpcode imposta il opcode dell'evento. Il codice operativo è un valore a 8 bit che indica una semantica speciale per l'evento, ad esempio che l'evento registra l'inizio (WINEVENT_OPCODE_START) o la fine (WINEVENT_OPCODE_STOP) di un'attività ETW (un gruppo di eventi correlati). Se non specificato, per impostazione predefinita l'evento è opcode 0 (WINEVENT_OPCODE_INFO) che indica che non è necessaria alcuna semantica speciale.
  • TraceLoggingChannel imposta il canale dell'evento. Il canale è un valore a 8 bit usato per vari scopi. Se non specificato, per impostazione predefinita l'evento è channel 11 (WINEVENT_CHANNEL_TRACELOGGING). La maggior parte degli eventi non deve modificare il canale dell'evento e non deve usare TraceLoggingChannel.
  • TraceLoggingEventTag imposta il tag dell'evento. Il tag è un valore a 28 bit con semantica definita dal provider. Ad esempio, un provider potrebbe definire bit di tag 0x1000000 per indicare che l'evento potenzialmente contiene informazioni personali e deve ricevere un trattamento speciale da strumenti di elaborazione eventi specifici del provider. Se non specificato, per impostazione predefinita il tag è 0.
  • TraceLoggingDescription imposta la descrizione dell'evento. La descrizione è un valore letterale stringa con una descrizione leggibile dell'evento. Viene usato come commento sullo scopo dell'evento e la descrizione viene registrata anche come annotazione nei simboli di debug del componente (PDB). Se non specificato, per impostazione predefinita la descrizione viene "".
  • TraceLoggingCustomAttribute aggiunge un'annotazione chiave-valore ai simboli di debug del componente (PDB).

Macro di campo

TraceLogging supporta molte macro wrapper per l'aggiunta di campi a un evento. Ogni campo è una coppia nome-valore. Ad esempio, TraceLoggingInt32(argc, "ArgCount") aggiungerà un campo INT32 denominato "ArgCount" con valore argc.

La maggior parte delle macro wrapper dei campi accetta parametri simili:

  • valore: Espressione che verrà valutata in fase di esecuzione per determinare i dati da includere nel campo. La maggior parte delle macro wrapper dei campi usa un singolo parametro per specificare il valore, ma alcune macro richiedono più parametri per il valore del campo, ad esempio un puntatore e una lunghezza. I parametri del valore sono sempre obbligatori.
    • In alcuni casi, il valore del campo viene specificato come pszValue, nel qual caso si tratta di un puntatore a una stringa di caratteri con terminazione 0 da includere nel campo. pszValue può essere NULL, nel qual caso il valore del campo sarà una stringa vuota "".
    • In alcuni casi, il valore del campo viene specificato come pchValue, nel qual caso si tratta di un puntatore a una stringa di cchValue caratteri da includere nel campo. pchValue può essere NULL solo se cchValue è 0.
    • In alcuni casi, il valore del campo viene specificato come pValue con una dimensione determinata automaticamente (nessun parametro cbValue), nel qual caso si tratta di un puntatore al valore da includere nel campo. pValue potrebbe non essere NULL.
    • In alcuni casi, il valore del campo viene specificato come pValue con un parametro cbValue per specificare le dimensioni (in byte) dei dati da includere nel campo. pValue può essere NULL solo se cbValue è 0.
  • nome: Valore letterale stringa (costante in fase di compilazione) con il nome da usare per il campo. La maggior parte delle macro wrapper dei campi non richiede un parametro name. Se si omette il parametro name, il nome del campo viene determinato in base al testo del preprocessore del valore della macro, pszValue, pchValueo parametro pValue. Ad esempio, TraceLoggingInt32(x[4] + y) equivale a TraceLoggingInt32(x[4] + y, "x[4] + y"). Entrambi aggiungerebbero un campo denominato "x[4] + y" all'evento con un valore determinato dalla valutazione dell'espressione x[4] + y.
  • descrizione: Valore letterale stringa (costante in fase di compilazione) con una descrizione da usare per il campo. Viene usato principalmente come posizione comoda per inserire un commento per il campo, ma la descrizione viene registrata anche come annotazione nei simboli di debug del componente (PDB). La descrizione è facoltativa. Se il parametro description viene omesso, per impostazione predefinita la descrizione del campo viene "".
  • tag : un intero a 28 bit (costante di compilazione) con semantica definita dal provider. Ad esempio, un provider potrebbe definire tag 0x2 per indicare che il campo contiene un numero di telefono e deve ricevere un trattamento speciale da strumenti di elaborazione eventi specifici del provider. Se il parametro tag viene omesso, il tag del campo viene impostato su 0.

Ad esempio, le chiamate di macro wrapper seguenti hanno lo stesso effetto:

  • TraceLoggingInt32(argc)
  • TraceLoggingInt32(argc, "argc")
  • TraceLoggingInt32(argc, "argc", "")
  • TraceLoggingInt32(argc, "argc", "", 0)

Scalari

  • TraceLoggingValue(value, [name, ...]):

    Aggiunge un campo con un tipo dedotto automaticamente dal tipo del parametro value. (solo C++)

  • TraceLoggingInt8(value, [name, ...]):

    Aggiunge un campo con un valore INT8.

  • TraceLoggingUInt8(value, [name, ...]):

    Aggiunge un campo con un valore UINT8.

  • TraceLoggingInt16(value, [name, ...]):

    Aggiunge un campo con un valore INT16.

  • TraceLoggingUInt16(value, [name, ...]):

    Aggiunge un campo con un valore UINT16.

  • TraceLoggingInt32(value, [name, ...]):

    Aggiunge un campo con un valore INT32.

  • TraceLoggingUInt32(value, [name, ...]):

    Aggiunge un campo con un valore UINT32.

  • TraceLoggingInt64(value, [name, ...]):

    Aggiunge un campo con un valore INT64.

  • TraceLoggingUInt64(value, [name, ...]):

    Aggiunge un campo con un valore UINT64.

  • TraceLoggingIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore INT_PTR (intero con segno con le stesse dimensioni di un puntatore).

  • TraceLoggingUIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore UINT_PTR (intero senza segno con le stesse dimensioni di un puntatore).

  • TraceLoggingLong(value, [name, ...]):

    Aggiunge un campo con un valore LONG (con segno long int, 32 bit nelle piattaforme Windows).

  • TraceLoggingULong(value, [name, ...]):

    Aggiunge un campo con un valore ULONG (unsigned long int, 32 bit nelle piattaforme Windows).

  • TraceLoggingHexInt8(value, [name, ...]):

    Aggiunge un campo con un valore INT8 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt8(value, [name, ...]):

    Aggiunge un campo con un valore UINT8 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt16(value, [name, ...]):

    Aggiunge un campo con un valore INT16 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt16(value, [name, ...]):

    Aggiunge un campo con un valore UINT16 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt32(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt32(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt64(value, [name, ...]):

    Aggiunge un campo con un valore INT64 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt64(value, [name, ...]):

    Aggiunge un campo con un valore UINT64 con un hint di formattazione esadecimale.

  • TraceLoggingHexIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore INT_PTR con un hint di formattazione esadecimale.

  • TraceLoggingHexUIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore UINT_PTR con un hint di formattazione esadecimale.

  • TraceLoggingHexLong(value, [name, ...]):

    Aggiunge un campo con un valore LONG con un hint di formattazione esadecimale.

  • TraceLoggingHexULong(value, [name, ...]):

    Aggiunge un campo con un valore ULONG con un hint di formattazione esadecimale.

  • TraceLoggingFloat32(value, [name, ...]):

    Aggiunge un campo con un valore FLOAT (a virgola mobile a 32 bit).

  • TraceLoggingFloat64(value, [name, ...]):

    Aggiunge un campo con un valore DOUBLE (a virgola mobile a 64 bit).

  • TraceLoggingBoolean(value, [name, ...]):

    Aggiunge un campo con un valore booleano a 8 bit (win32 BOOLEAN o C++ bool).

  • TraceLoggingBool(value, [name, ...]):

    Aggiunge un campo con un valore booleano a 32 bit (Win32 BOOL).

  • TraceLoggingChar(value, [name, ...]):

    Aggiunge un campo con un valore char (intero a 8 bit con hint di formattazione della stringa, in genere considerato come tabella codici 1252).

  • TraceLoggingChar16(value, [name, ...]):

    Aggiunge un campo con un valore char16_t (intero a 16 bit con hint di formattazione della stringa, in genere trattato come UCS-2).

  • TraceLoggingWChar(value, [name, ...]):

    Aggiunge un campo con un valore wchar_t (uguale a char16_t nelle piattaforme Windows).

  • TraceLoggingPointer(value, [name, ...]):

    Aggiunge un campo con un valore void* (valore con dimensioni del puntatore con un hint di formattazione esadecimale).

  • TraceLoggingCodePointer(value, [name, ...]):

    Aggiunge un campo con un valore void* (valore con dimensioni del puntatore con un hint di formattazione del puntatore del codice).

  • TraceLoggingPid(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione ID processo.

  • TraceLoggingTid(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione dell'ID thread.

  • TraceLoggingIPv4Address(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione IPv4 (ordine dei byte di rete).

  • TraceLoggingIPv6Address(pValue, [name, ...]):

    Aggiunge un campo con un valore binario a 16 byte con un hint di formattazione IPv6.

  • TraceLoggingPort(value, [name, ...]):

    Aggiunge un campo con un valore UINT16 con un hint di formattazione della porta IP (ordine dei byte di rete).

  • TraceLoggingSocketAddress(pValue, cbValue, [name, ...]):

    Aggiunge un campo con un valore SOCKADDR.

  • TraceLoggingWinError(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione del codice di errore Win32.

  • TraceLoggingNTStatus(value, [name, ...]):

    Aggiunge un campo con un valore NTSTATUS (LONG) con un hint di formattazione del codice di errore WinNT.

  • TraceLoggingHResult(value, [name, ...]):

    Aggiunge un campo con un valore HRESULT (LONG) con un hint di formattazione HRESULT di Windows.

  • TraceLoggingFileTime(value, [name, ...]):

    Aggiunge un campo con un valore FILETIME. Se usato nel codice C, il parametro value deve essere un'espressione lvalue.

  • TraceLoggingFileTimeUtc(value, [name, ...]):

    Aggiunge un campo con un valore FILETIME con un hint di formattazione del fuso orario UTC. Se usato nel codice C, il parametro value deve essere un'espressione lvalue.

  • TraceLoggingSystemTime(value, [name, ...]):

    Aggiunge un campo con un valore di SYSTEMTIME. Se usato nel codice C, il parametro value deve essere un'espressione lvalue.

  • TraceLoggingSystemTimeUtc(value, [name, ...]):

    Aggiunge un campo con un valore SYSTEMTIME con un hint di formattazione del fuso orario UTC. Se usato nel codice C, il parametro value deve essere un'espressione lvalue.

  • TraceLoggingGuid(value, [name, ...]):

    Aggiunge un campo con un valore GUID. Se usato nel codice C, il parametro value deve essere un'espressione lvalue.

  • TraceLoggingString(pszValue, [name, ...]):

    Aggiunge un campo con una stringa di char con terminazione 0,in genere considerata come tabella codici 1252. Se pszValue è NULL, viene usata una stringa vuota "" come valore del campo.

  • TraceLoggingUtf8String(pszValue, [name, ...]):

    Aggiunge un campo con una stringa di char con terminazione 0 con un hint di formattazione UTF-8. Se pszValue è NULL, viene usata una stringa vuota "" come valore del campo.

  • TraceLoggingString16(pszValue, [name, ...]):

    Aggiunge un campo con una stringa di char16_t con terminazione 0 (UTF-16). Se pszValue è NULL, viene usata una stringa vuota u"" come valore del campo.

  • TraceLoggingWideString(pszValue, [name, ...]):

    Aggiunge un campo con una stringa di wchar_t con terminazione 0 (UTF-16 in Windows). Se pszValue è NULL, viene usata una stringa vuota L"" come valore del campo.

  • TraceLoggingCountedString(pchValue, cchValue, [name, ...]):

    Aggiunge un campo con una stringa di char conteggiata (in genere considerata come tabella codici 1252). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedUtf8String(pchValue, cchValue, [name, description, tag]):

    Aggiunge un campo con un char stringa con conteggiato con un hint di formattazione UTF-8. pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedString16(pchValue, cchValue, [name, ...]):

    Aggiunge un campo con una stringa char16_t conteggiata (UTF-16). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedWideString(pchValue, cchValue, [name, description, tag]):

    Aggiunge un campo con una stringa wchar_t conteggiata (UTF-16 in Windows). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingAnsiString(pValue, [name, ...]):

    Aggiunge un campo con un valore ANSI_STRING. Il puntatore pValue non deve essere NULL.

  • TraceLoggingUnicodeString(pValue, [name, ...]):

    Aggiunge un campo con un valore UNICODE_STRING. Il puntatore pValue non deve essere NULL.

  • TraceLoggingSid(pValue, [name, ...]):

    Aggiunge un campo con un valore SID. Il puntatore pValue non deve essere NULL e deve puntare a un SID correttamente inizializzato (Revisione e SubAuthorityCount devono essere validi).

  • TraceLoggingBinary(pValue, cbValue, [name, ...]):

    Aggiunge un campo con dati binari.

  • TraceLoggingBinaryEx(pValue, cbValue, outType, [name, ...]):

    Aggiunge un campo con dati binari con l'hint di formattazione specificato da outType.

  • TraceLoggingBinaryBuffer(pValue, StructType, [name, ...]):

    Aggiunge un campo con dati binari. pValue deve essere un puntatore non NULL a uno struct StructType. pValue->Buffer deve puntare all'inizio dei dati e pValue->Length deve essere il numero di byte di dati da includere nel campo.

  • TraceLoggingBinaryBufferEx(pValue, StructType, outType, name, description, tag):

    Aggiunge un campo con dati binari con l'hint di formattazione specificato da outType. pValue deve essere un puntatore non NULL a uno struct StructType. pValue->Buffer deve puntare all'inizio dei dati e pValue->Length deve essere il numero di byte di dati da includere nel campo.

  • TraceLoggingCustom(pValue, cbValue, protocol, bSchema, cbSchema, [name, ...]):

    Aggiunge un campo con dati binari serializzati in base a un protocollo di serializzazione. Le informazioni di decodifica costante in fase di compilazione verranno incluse insieme all'evento per consentire la deserializzazione dal decodificatore di eventi.

Strutture

È possibile usare la macro TraceLoggingStruct(fieldCount, name, [...]) per creare una struttura denominata (gruppo di campi). Il parametro fieldCount indica quanti campi successivi devono essere conteggiati come parte della struttura. Le strutture possono essere annidate, nel qual caso ogni struttura annidata e i relativi campi contenuti vengono conteggiati come un singolo campo allo scopo di definire lo struct padre.

Matrici

È possibile creare un campo contenente una matrice di valori scalari (singoli). Ad esempio, si aggiunge una matrice di GUID come singolo campo nell'evento.

Nota

Sebbene il protocollo TraceLogging supporti matrici di tutti i tipi, TraceLoggingProvider.h fornisce solo macro wrapper per matrici di valori semplici, ad esempio fornisce macro per matrici di INT32 e GUID, ma non fornisce macro per matrici di strutture stringhe o matrici di strutture. È possibile creare eventi con matrici di valori complessi eseguendo il marshalling dei dati in un buffer e quindi usando le macro TraceLoggingPacked descritte di seguito.

TraceLogging supporta matrici a lunghezza fissa e a lunghezza variabile.

  • Utilizzare la macro Array nei casi in cui la lunghezza della matrice non è nota in fase di compilazione e può essere diversa ogni volta che viene generato l'evento.
  • Usare la macro FixedArray nei casi in cui la lunghezza della matrice è nota in fase di compilazione,ad esempio quando la lunghezza della matrice è una costante. Ciò comunica al consumer di eventi che tutti gli eventi con un nome di evento specifico avranno lo stesso numero di elementi nel campo della matrice.

Per tutte le macro di matrice è necessario specificare i parametri pValues e cValues, con pValues che punta all'inizio del contenuto della matrice e cValues impostato sul numero di elementi nella matrice. pValues può essere NULL solo se cValues è 0.

Tutte le macro di matrice accettano facoltativamente nome, descrizionee tag parametri come descritto per le macro scalari. Se non viene specificato nome, il nome del campo viene determinato dal testo del preprocessore di pValues. Se non viene specificata descrizione, la descrizione del campo verrà "". Se tag non viene specificato, il tag di campo verrà 0.

Nota

Per assicurarsi che ETW non elimina gli eventi, evitare di creare eventi con matrici di grandi dimensioni. ETW non supporta eventi di dimensioni superiori a 64 KB. Eventuali eventi di questo tipo verranno eliminati automaticamente da ETW. Inoltre, gli eventi di dimensioni superiori a quelle della sessione consumer BufferSize verranno eliminati anche da ETW. La dimensione dell'evento si basa sulla somma delle intestazioni, dei metadati (provider, eventi e nomi dei campi) e dei dati (valori di campo).

  • TraceLoggingInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingUIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingLongArray(pValues, cValues, [name, ...])
  • TraceLoggingLongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingULongArray(pValues, cValues, [name, ...])
  • TraceLoggingULongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingHexIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexLongArray(pValues, cValues, [name, ...])
  • TraceLoggingHexLongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexULongArray(pValues, cValues, [name, ...])
  • TraceLoggingHexULongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFloat32Array(pValues, cValues, [name, ...])
  • TraceLoggingFloat32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFloat64Array(pValues, cValues, [name, ...])
  • TraceLoggingFloat64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingBooleanArray(pValues, cValues, [name, ...])
  • TraceLoggingBooleanFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingBoolArray(pValues, cValues, [name, ...])
  • TraceLoggingBoolFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingCharArray(pValues, cValues, [name, ...])
  • TraceLoggingCharFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingChar16Array(pValues, cValues, [name, ...])
  • TraceLoggingChar16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingWCharArray(pValues, cValues, [name, ...])
  • TraceLoggingWCharFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingPointerArray(pValues, cValues, [name, ...])
  • TraceLoggingPointerFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingCodePointerArray(pValues, cValues, [name, ...])
  • TraceLoggingCodePointerFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeUtcArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeUtcFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeUtcArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeUtcFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingGuidArray(pValues, cValues, [name, ...])
  • TraceLoggingGuidFixedArray(pValues, cValues, [name, ...])

Macro confezionate

TraceLoggingProvider.h fornisce solo macro di campo per i tipi di campo copiabili, ad esempio campi in cui ogni macro di campo corrisponde a un singolo campo e a una singola area contigua di memoria con il valore del campo.

TraceLoggingProvider.h non fornisce supporto diretto per casi più complessi, ad esempio:

  • Registrazione di una matrice di un tipo a lunghezza variabile, ad esempio una matrice di stringhe.
  • Registrazione di una matrice di strutture.
  • Passaggio di più campi a ETW tramite un singolo buffer per ridurre l'overhead della registrazione degli eventi.

Per supportare questi scenari, TraceLoggingProvider.h definisce diverse macro TraceLoggingPacked che consentono di modificare direttamente la definizione dell'evento (metadati) e i valori di campo (dati) dell'evento.

Avvertimento

Le macro TraceLoggingPacked sono difficili da usare correttamente e richiedono una buona comprensione del modo in cui vengono creati gli eventi TraceLogging. Se usato in modo non corretto, genereranno eventi danneggiati che non decodificano correttamente.

Per informazioni dettagliate sull'uso di queste macro, vedere i commenti nell'intestazione TraceLoggingProvider.h.

  • TraceLoggingPackedField(pValue, cbValue, inType, [name, description, tags]):

    Aggiunge i dati dei campi (pValue, cbValue) e i metadati dei campi (name, inType).

  • TraceLoggingPackedFieldEx(pValue, cbValue, inType, outType, [name, ...]):

    Aggiunge i dati dei campi (pValue, cbValue) e i metadati dei campi (nome, inType) insieme a un hint di formattazione (outType).

  • TraceLoggingPackedMetadata(inType, [name, ...]):

    Aggiunge i metadati del campo (nome, inType) senza aggiungere dati sul campo. I dati dei campi corrispondenti devono essere aggiunti tramite TraceLoggingPackedData.

  • TraceLoggingPackedMetadataEx(inType, outType, [name, ...]):

    Aggiunge i metadati del campo (nome, inType) e un hint di formattazione (outType) senza aggiungere dati di campo. I dati dei campi corrispondenti devono essere aggiunti tramite TraceLoggingPackedData.

  • TraceLoggingPackedStruct(fieldCount, name, [...]):

    Aggiunge i metadati del campo (nome, fieldCount) per uno struct.

  • TraceLoggingPackedStructArray(fieldCount, [name, ...]):

    Aggiunge i metadati del campo (nome, fieldCount) per una matrice a lunghezza variabile di struct. La lunghezza della matrice deve essere specificata tramite TraceLoggingPackedData.

  • TraceLoggingPackedData(pValue, cbValue):

    Aggiunge dati di campo a un evento senza aggiungere metadati di campo. I metadati corrispondenti devono essere aggiunti tramite le macro Metadati.

  • TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

    Aggiunge dati di campo a un evento senza aggiungere metadati di campo, usando un Type specifico nel EVENT_DATA_DESCRIPTOR per i dati. I metadati corrispondenti devono essere aggiunti tramite le macro Metadati.