TraceLogging Wrapper Macros

Les TraceLoggingWrite et TraceLoggingWriteActivity macros émettent des événements TraceLogging configurés en fonction des paramètres de macro. Chacune de ces macros accepte un ensemble de paramètres requis suivis de 99 paramètres facultatifs jusqu’à 99. Chaque paramètre facultatif configure l’événement ou ajoute un champ à l’événement. Chaque paramètre facultatif doit être l’une des macros TraceLogging Wrapper décrites dans cette page.

Par exemple:

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.

Dans cet exemple, g_hProvider et "MyEvent1" sont les paramètres requis. Ils spécifient le fournisseur à utiliser pour l’événement et le nom de l’événement. Chacun des paramètres restants est une macro wrapper. Les paramètres TraceLoggingLevel et TraceLoggingKeyword configurent l’événement. Les paramètres TraceLoggingString et TraceLoggingHResult ajoutent des champs à l’événement.

Macros Event Configuration

Les macros suivantes configurent l’événement.

Si une macro de configuration particulière n’est pas fournie dans le TraceLoggingWrite, une valeur par défaut est utilisée pour cet événement. Par exemple, si aucun paramètre TraceLoggingLevel est utilisé pour un événement, l’événement utilise un niveau par défaut de 5 (VERBOSE).

• TraceLoggingLevel définit le niveau de l’événement. Le niveau est une valeur 8 bits indiquant la gravité de l’événement. Les niveaux de 1 (WINEVENT_LEVEL_CRITICAL) à 5 (WINEVENT_LEVEL_VERBOSE) sont définis dans <winmeta.h>. S’il n’est pas spécifié, l’événement est défini par défaut sur le niveau 5 (VERBOSE). Le niveau est une partie importante du routage et du filtrage des événements ETW. Tous les événements doivent donc avoir un niveau non zéro significatif.
• TraceLoggingKeyword définit le mot clé de l’événement. Un mot clé est une valeur 64 bits avec chaque bit indiquant une catégorie à laquelle l’événement appartient. Les 48 bits faibles du mot clé sont définis par le propriétaire du fournisseur, tandis que les 16 bits élevés du mot clé sont définis par Microsoft. Par exemple, vous pouvez décider que tous les fournisseurs portant le nom « MyCompany.MyComponent » utilisent le mot clé 0x1 pour désigner « Networking ». S’il n’est pas spécifié, l’événement est défini par défaut sur le mot clé 0x0 (Aucun). Le mot clé est une partie importante du routage et du filtrage des événements ETW. Tous les événements doivent donc avoir un mot clé non nul significatif.
• TraceLoggingOpcode définit le opcodede l’événement . L’opcode est une valeur 8 bits indiquant une sémantique spéciale pour l’événement, par exemple que l’événement enregistre le début (WINEVENT_OPCODE_START) ou la fin (WINEVENT_OPCODE_STOP) d’une activité ETW (groupe d’événements connexes). S’il n’est pas spécifié, l’événement est défini par défaut sur opcode 0 (WINEVENT_OPCODE_INFO) indiquant qu’aucune sémantique spéciale n’est requise.
• TraceLoggingChannel définit le canal de l’événement. Le canal est une valeur 8 bits utilisée à diverses fins. S’il n’est pas spécifié, l’événement est défini par défaut sur le canal 11 (WINEVENT_CHANNEL_TRACELOGGING). La plupart des événements n’ont pas besoin de modifier le canal de l’événement et ne doivent pas utiliser TraceLoggingChannel.
• TraceLoggingEventTag définit la balise de l’événement. La balise est une valeur 28 bits avec une sémantique définie par le fournisseur. Par exemple, un fournisseur peut définir le bit d’étiquette 0x1000000 pour indiquer que l’événement contient potentiellement des informations d’identification personnelle et doit recevoir un traitement spécial des outils de traitement des événements spécifiques au fournisseur. Si elle n’est pas spécifiée, la balise est définie par défaut sur 0.
• TraceLoggingDescription définit la description de l’événement. La description est un littéral de chaîne avec une description lisible par l’homme de l’événement. Cela sert de commentaire sur l’objectif de l’événement, et la description est également enregistrée en tant qu’annotation dans les symboles de débogage de votre composant (PDB). Si elle n’est pas spécifiée, la description par défaut est "".
• TraceLoggingCustomAttribute ajoute une annotation clé-valeur aux symboles de débogage du composant (PDB).

Macros de champ

TraceLogging prend en charge de nombreuses macros wrapper pour ajouter des champs à un événement. Chaque champ est une paire nom-valeur. Par exemple, TraceLoggingInt32(argc, "ArgCount") ajouterait un champ INT32 nommé « ArgCount » avec la valeur argc.

La plupart des macros wrapper de champ acceptent des paramètres similaires :

• valeur : Expression qui sera évaluée au moment de l’exécution pour déterminer les données à inclure dans le champ. La plupart des macros wrapper de champ utilisent un paramètre unique pour spécifier la valeur, mais certaines macros nécessitent plusieurs paramètres pour la valeur de champ, par exemple un pointeur et une longueur. Les paramètres de valeur sont toujours requis.
  • Dans certains cas, la valeur du champ est spécifiée comme pszValue, auquel cas il s’agit d’un pointeur vers une chaîne de caractères terminée par 0 à inclure dans le champ. pszValue peut être NULL, auquel cas la valeur du champ sera une chaîne vide "".
  • Dans certains cas, la valeur du champ est spécifiée comme pchValue, auquel cas il s’agit d’un pointeur vers une chaîne de cchValue caractères à inclure dans le champ. pchValue peut être NULL uniquement si cchValue est 0.
  • Dans certains cas, la valeur du champ est spécifiée comme pValue avec une taille déterminée automatiquement (aucun paramètre cbValue ), auquel cas il s’agit d’un pointeur vers la valeur à inclure dans le champ. pValue peut ne pas être NULL.
  • Dans certains cas, la valeur du champ est spécifiée en tant que pValue avec un paramètre cbValue pour spécifier la taille (en octets) des données à inclure dans le champ. pValue peut être NULL uniquement si cbValue est 0.
• nom : littéral de chaîne (constante de compilation) avec le nom à utiliser pour le champ. La plupart des macros wrapper de champ ne nécessitent pas de paramètre de nom. Si vous omettez le paramètre de nom, le nom du champ est déterminé en fonction du texte de préprocesseur de la valeur de la macro, pszValue, pchValueou paramètre pValue. Par exemple, TraceLoggingInt32(x[4] + y) équivaut à TraceLoggingInt32(x[4] + y, "x[4] + y"). Les deux ajouteraient un champ nommé "x[4] + y" à l’événement avec une valeur déterminée par l’évaluation de l’expression x[4] + y.
• description : littéral de chaîne (constante de compilation) avec une description à utiliser pour le champ. Il s’agit principalement d’un endroit pratique pour placer un commentaire pour le champ, mais la description est également enregistrée en tant qu’annotation dans les symboles de débogage du composant (PDB). La description est facultative. Si le paramètre de description est omis, la description du champ est par défaut "".
• balise : entier 28 bits (constante de compilation) avec sémantique définie par le fournisseur. Par exemple, un fournisseur peut définir une balise 0x2 pour indiquer que le champ contient un numéro de téléphone et doit recevoir un traitement spécial des outils de traitement des événements spécifiques au fournisseur. Si le paramètre de balise est omis, la balise du champ a la valeur 0 par défaut.

Par exemple, les appels de macro wrapper suivants ont tous le même effet :

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

Scalaires

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

  Ajoute un champ avec un type qui est automatiquement déduit du type du paramètre valeur. (C++ uniquement)

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

  Ajoute un champ avec une valeur INT8.

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

  Ajoute un champ avec une valeur UINT8.

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

  Ajoute un champ avec une valeur INT16.

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

  Ajoute un champ avec une valeur UINT16.

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

  Ajoute un champ avec une valeur INT32.

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

  Ajoute un champ avec une valeur UINT32.

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

  Ajoute un champ avec une valeur INT64.

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

  Ajoute un champ avec une valeur UINT64.

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

  Ajoute un champ avec une valeur INT_PTR (entier signé avec la même taille qu’un pointeur).

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

  Ajoute un champ avec une valeur UINT_PTR (entier non signé avec la même taille qu’un pointeur).

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

  Ajoute un champ avec une valeur LONG (signé long int, 32 bits sur les plateformes Windows).

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

  Ajoute un champ avec une valeur ULONG (int long non signé, 32 bits sur les plateformes Windows).

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

  Ajoute un champ avec une valeur INT8 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur UINT8 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur INT16 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur UINT16 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur INT32 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur UINT32 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur INT64 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur UINT64 avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur INT_PTR avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur UINT_PTR avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur LONG avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur ULONG avec un indicateur de mise en forme hexadécimal.

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

  Ajoute un champ avec une valeur flottante FLOAT (32 bits).

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

  Ajoute un champ avec une valeur à virgule flottante DOUBLE (64 bits).

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

  Ajoute un champ avec une valeur booléenne 8 bits (Win32 BOOLEAN ou C++ bool).

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

  Ajoute un champ avec une valeur booléenne 32 bits (Win32 BOOL).

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

  Ajoute un champ avec une valeur char (entier 8 bits avec indicateur de mise en forme de chaîne, généralement traité comme page de codes 1252).

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

  Ajoute un champ avec une valeur char16_t (entier 16 bits avec indicateur de mise en forme de chaîne, généralement traité comme UCS-2).

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

  Ajoute un champ avec une valeur wchar_t (identique à char16_t sur les plateformes Windows).

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

  Ajoute un champ avec une valeur void* (valeur de taille du pointeur avec un indicateur de mise en forme hexadécimale).

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

  Ajoute un champ avec une valeur void* (valeur de taille du pointeur avec un indicateur de mise en forme de pointeur de code).

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

  Ajoute un champ avec une valeur INT32 avec un indicateur de mise en forme d’ID de processus.

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

  Ajoute un champ avec une valeur INT32 avec un indicateur de mise en forme d’ID de thread.

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

  Ajoute un champ avec une valeur UINT32 avec un indicateur de mise en forme IPv4 (ordre d’octet réseau).

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

  Ajoute un champ avec une valeur binaire de 16 octets avec un indicateur de mise en forme IPv6.

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

  Ajoute un champ avec une valeur UINT16 avec un indicateur de mise en forme de port IP (ordre d’octet réseau).

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

  Ajoute un champ avec une valeur SOCKADDR.

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

  Ajoute un champ avec une valeur UINT32 avec un indicateur de mise en forme de code d’erreur Win32.

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

  Ajoute un champ avec une valeur NTSTATUS (LONG) avec un indicateur de mise en forme de code d’erreur WinNT.

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

  Ajoute un champ avec une valeur HRESULT (LONG) avec un indicateur de mise en forme HRESULT Windows.

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

  Ajoute un champ avec une valeur FILETIME. Lorsqu’il est utilisé dans le code C, le paramètre value doit être une expression lvalue.

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

  Ajoute un champ avec une valeur FILETIME avec un indicateur de mise en forme de fuseau horaire UTC. Lorsqu’il est utilisé dans le code C, le paramètre value doit être une expression lvalue.

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

  Ajoute un champ avec une valeur SYSTEMTIME. Lorsqu’il est utilisé dans le code C, le paramètre value doit être une expression lvalue.

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

  Ajoute un champ avec une valeur SYSTEMTIME avec un indicateur de mise en forme de fuseau horaire UTC. Lorsqu’il est utilisé dans le code C, le paramètre value doit être une expression lvalue.

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

  Ajoute un champ avec une valeur GUID. Lorsqu’il est utilisé dans le code C, le paramètre value doit être une expression lvalue.

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

  Ajoute un champ avec une chaîne de char terminée par 0 (généralement traitée comme page de codes 1252). Si pszValue a la valeur NULL, une chaîne vide "" est utilisée comme valeur de champ.

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

  Ajoute un champ avec une chaîne char terminée par 0 avec un indicateur de mise en forme UTF-8. Si pszValue a la valeur NULL, une chaîne vide "" est utilisée comme valeur de champ.

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

  Ajoute un champ avec une chaîne de char16_t terminée par 0 (UTF-16). Si pszValue a la valeur NULL, une chaîne vide u"" est utilisée comme valeur de champ.

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

  Ajoute un champ avec une chaîne de wchar_t terminée par 0 (UTF-16 sur Windows). Si pszValue a la valeur NULL, une chaîne vide L"" est utilisée comme valeur de champ.

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

  Ajoute un champ avec une chaîne char comptée (généralement traitée comme page de codes 1252). pchValue peut être NULL uniquement si cchValue est 0.

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

  Ajoute un champ avec une chaîne char comptée avec un indicateur de mise en forme UTF-8. pchValue peut être NULL uniquement si cchValue est 0.

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

  Ajoute un champ avec une chaîne char16_t comptée (UTF-16). pchValue peut être NULL uniquement si cchValue est 0.

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

  Ajoute un champ avec une chaîne wchar_t comptée (UTF-16 sur Windows). pchValue peut être NULL uniquement si cchValue est 0.

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

  Ajoute un champ avec une valeur ANSI_STRING. Le pointeur pValue ne doit pas être NULL.

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

  Ajoute un champ avec une valeur UNICODE_STRING. Le pointeur pValue ne doit pas être NULL.

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

  Ajoute un champ avec une valeur SID. Le pointeur pValue ne doit pas être NULL et doit pointer vers un SID correctement initialisé (Revision et SubAuthorityCount doit être valide).

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

  Ajoute un champ avec des données binaires.

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

  Ajoute un champ avec des données binaires avec l’indicateur de mise en forme spécifié par outType.

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

  Ajoute un champ avec des données binaires. pValue doit être un pointeur non NULL vers un struct StructType. pValue->Buffer devez pointer au début des données et pValue->Length doit être le nombre d’octets de données à inclure dans le champ.

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

  Ajoute un champ avec des données binaires avec l’indicateur de mise en forme spécifié par outType. pValue doit être un pointeur non NULL vers un struct StructType. pValue->Buffer devez pointer au début des données et pValue->Length doit être le nombre d’octets de données à inclure dans le champ.

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

  Ajoute un champ avec des données binaires sérialisées en fonction d’un protocole de sérialisation. Les informations de décodage constante au moment de la compilation sont incluses avec l’événement pour autoriser la désérialisation par le décodeur d’événement.

Structures

Vous pouvez utiliser la macro TraceLoggingStruct(fieldCount, name, [...]) pour créer une structure nommée (groupe de champs). Le paramètre fieldCount indique le nombre de champs suivants à compter dans le cadre de la structure. Les structures peuvent être imbriquées, auquel cas chaque structure imbriquée et ses champs contenus comptent comme un seul champ pour définir le struct parent.

Tableaux

Vous pouvez créer un champ qui contient un tableau de valeurs scalaires (uniques). Par exemple, vous ajoutez un tableau de GUID en tant que champ unique dans votre événement.

TraceLogging prend en charge les tableaux de longueur fixe et de longueur variable.

• Utilisez la macro Array dans les cas où la longueur du tableau n’est pas connue au moment de la compilation et peut être différente chaque fois que l’événement est généré.
• Utilisez la macro FixedArray dans les cas où la longueur du tableau est connue au moment de la compilation (c’est-à-dire lorsque la longueur du tableau est une constante). Cela communique avec le consommateur d’événements que tous les événements portant un nom d’événement particulier auront le même nombre d’éléments dans le champ de tableau.

Toutes les macros de tableau nécessitent que les paramètres pValues et cValues soient spécifiés, avec pValues pointant vers le début du contenu du tableau et cValues défini sur le nombre d’éléments du tableau. pValues peut être NULL uniquement si cValues est 0.

Toutes les macros de tableau acceptent éventuellement nom, descriptionet paramètres de balise comme décrit pour les macros Scalaires. Si nom n’est pas spécifié, le nom du champ est déterminé à partir du texte de préprocesseur de pValues. Si description n’est pas spécifiée, la description du champ est "". Si balise n’est pas spécifiée, la balise de champ est 0.

• 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, ...])

Macros packées

TraceLoggingProvider.h fournit uniquement des macros de champ pour les types de champs blittables, c’est-à-dire les champs où chaque macro de champ correspond à un seul champ et une seule région contiguë de mémoire avec la valeur du champ.

TraceLoggingProvider.h ne fournit pas de prise en charge directe pour des cas plus complexes tels que :

• Journalisation d’un tableau d’un type de longueur variable, tel qu’un tableau de chaînes.
• Journalisation d’un tableau de structures.
• Passage de plusieurs champs à ETW via une mémoire tampon unique pour réduire la surcharge de journalisation des événements.

Pour prendre en charge ces scénarios, TraceLoggingProvider.h définit plusieurs macros TraceLoggingPacked qui vous permettent de manipuler directement la définition d’événement (métadonnées) et les valeurs de champ (données) de l’événement.

Pour plus d’informations sur l’utilisation de ces macros, reportez-vous aux commentaires de l’en-tête TraceLoggingProvider.h.

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

  Ajoute des données de champ (pValue, cbValue) et des métadonnées de champ (nom, inType).

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

  Ajoute des données de champ (pValue, cbValue) et des métadonnées de champ (nom, inType) ainsi qu’un indicateur de mise en forme (outType).

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

  Ajoute des métadonnées de champ (nom, inType) sans ajouter de données de champ. Les données de champ correspondantes doivent être ajoutées via TraceLoggingPackedData.

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

  Ajoute des métadonnées de champ (nom, inType) et un indicateur de mise en forme (outType) sans ajouter de données de champ. Les données de champ correspondantes doivent être ajoutées via TraceLoggingPackedData.

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

  Ajoute des métadonnées de champ (nom, fieldCount) pour un struct.

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

  Ajoute des métadonnées de champ (nom, fieldCount) pour un tableau de struct de longueur variable. La longueur du tableau doit être spécifiée via TraceLoggingPackedData.

• TraceLoggingPackedData(pValue, cbValue) :

  Ajoute des données de champ à un événement sans ajouter de métadonnées de champ. Les métadonnées correspondantes doivent être ajoutées via les macros de métadonnées.

• TraceLoggingPackedDataEx(pValue, cbValue, dataDescType) :

  Ajoute des données de champ à un événement sans ajouter de métadonnées de champ à l’aide d’un Type spécifique dans l'EVENT_DATA_DESCRIPTOR pour les données. Les métadonnées correspondantes doivent être ajoutées via les macros de métadonnées.