Partager via

TraceLogging Wrapper Macros

  • Article

Les macros TraceLoggingWrite et TraceLoggingWriteActivity émettent des événements TraceLogging configurés en fonction des paramètres de macro. Chacune de ces macros accepte un ensemble de paramètres obligatoires suivis de 99 paramètres facultatifs au maximum. 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 Wrapper TraceLogging décrites sur 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 TraceLoggingLevel paramètres et TraceLoggingKeyword configurent l’événement. Les TraceLoggingString paramètres et TraceLoggingHResult ajoutent des champs à l’événement.

Macros event Configuration

Les macros suivantes configurent l’événement.

Si aucune macro de configuration particulière n’est fournie dans TraceLoggingWrite, une valeur par défaut est utilisée pour cet événement. Par exemple, si aucun paramètre TraceLoggingLevel n’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). Level étant une partie importante du routage et du filtrage des événements ETW, tous les événements doivent avoir un niveau significatif autre que zéro.
  • TraceLoggingKeyword définit la mot clé de l’événement. Une mot clé est une valeur de 64 bits, chaque bit indiquant une catégorie à laquelle l’événement appartient. Les 48 bits inférieurs 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 » utiliseront mot clé 0x1 pour signifier « Mise en réseau ». S’il n’est pas spécifié, l’événement est mot clé 0x0 par défaut (Aucun). Le mot clé étant une partie importante du routage et du filtrage des événements ETW, tous les événements doivent avoir une mot clé significative non nulle.
  • TraceLoggingOpcode définit l’opcode de 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 (un groupe d’événements associés). S’il n’est pas spécifié, l’événement est défini par défaut sur opcode 0 (WINEVENT_OPCODE_INFO), ce qui indique qu’aucune sémantique particulière n’est requise.
  • TraceLoggingChannel définit le canal de l’événement. Le canal est une valeur 8 bits qui est 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 des 0x1000000 de bits de balise pour indiquer que l’événement contient potentiellement des informations d’identification personnelle et doit recevoir un traitement spécial des outils de traitement d’événements spécifiques au fournisseur. Si elle n’est pas spécifiée, la valeur par défaut de la balise est 0.
  • TraceLoggingDescription définit la description de l’événement. La description est un littéral de chaîne avec une description lisible 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 (PDB) de votre composant. Si elle n’est pas spécifiée, la description est définie par défaut sur "".
  • TraceLoggingCustomAttribute ajoute une annotation clé-valeur aux symboles de débogage (PDB) du composant.

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 seul paramètre 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. Le ou les paramètres de valeur sont toujours requis.
    • Dans certains cas, la valeur du champ est spécifiée en tant que 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 en tant que pchValue, auquel cas il s’agit d’un pointeur vers une chaîne de caractères cchValue à inclure dans le champ. pchValue peut être NULL uniquement si cchValue a la valeur 0.
    • Dans certains cas, la valeur du champ est spécifiée en tant que 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 ne peut 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 a la valeur 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 name. Si vous omettez le paramètre name, le nom du champ est déterminé en fonction du texte du préprocesseur de la valeur de la macro, pszValue, pchValue ou pValue . Par exemple, TraceLoggingInt32(x[4] + y) équivaut à TraceLoggingInt32(x[4] + y, "x[4] + y"). Les deux ajoutent 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 emplacement 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 (PDB) du composant. La description est facultative. Si le paramètre description est omis, la description du champ est définie par défaut sur "".
  • étiquette: Entier 28 bits (constante de compilation) avec sémantique définie par le fournisseur. Par exemple, un fournisseur peut définir une étiquette 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 d’événements spécifiques au fournisseur. Si le paramètre de balise est omis, la balise du champ est 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)

Valeurs scalaires

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

    Ajoute un champ avec un type qui est automatiquement déduit du type du paramètre value. (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 (long int signé, 32 bits sur les plateformes Windows).

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

    Ajoute un champ avec une valeur ULONG (long int 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écimale.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • 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 char valeur (entier 8 bits avec indicateur de mise en forme de chaîne, généralement traité comme la page de codes 1252).

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

    Ajoute un champ avec une char16_t valeur (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 wchar_t valeur (identique à char16_t sur les plateformes Windows).

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

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

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

    Ajoute un champ avec une void* valeur (valeur de taille 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 du 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 value paramètre 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 value paramètre doit être une expression lvalue.

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

    Ajoute un champ avec une valeur SYSTEMTIME . Lorsqu’il est utilisé dans le code C, le value paramètre 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 value paramètre doit être une expression lvalue.

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

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

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

    Ajoute un champ avec une chaîne terminée par char 0 (généralement traité comme la 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 terminée par char 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 terminée par char16_t 0 (UTF-16). Si pszValue a la valeur NULL, une chaîne u"" vide est utilisée comme valeur de champ.

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

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

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

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

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

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

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

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

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

    Ajoute un champ avec une chaîne comptée wchar_t (UTF-16 sur Windows). pchValue peut être NULL uniquement si cchValue a la valeur 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 doivent être valides).

  • 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 StructType struct. pValue->Buffer doit 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 StructType struct. pValue->Buffer doit 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 selon un protocole de sérialisation. Les informations de décodage constant au moment de la compilation sont incluses avec l’événement pour permettre la désérialisation par le décodeur d’événements.

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 qui doivent être comptés dans la structure. Les structures peuvent être imbriquées, auquel cas chaque structure imbriquée et ses champs contenus comptent comme un seul champ dans le but de 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.

Notes

Alors que le protocole TraceLogging prend en charge les tableaux de tous les types, TraceLoggingProvider.h fournit uniquement des macros wrapper pour les tableaux de valeurs simples, par exemple, il fournit des macros pour les tableaux d’INT32 et GUID, mais il ne fournit pas de macros pour les tableaux de chaînes ou de tableaux de structures. Il est possible de créer des événements avec des tableaux de valeurs complexes en marshalant les données dans une mémoire tampon, puis en utilisant les TraceLoggingPacked macros décrites ci-dessous.

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

  • Utilisez la Array macro 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 FixedArray macro 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 indique au 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 dans le tableau. pValues peut être NULL uniquement si cValues a la valeur 0.

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

Notes

Pour vous assurer qu’ETW ne supprime pas vos événements, évitez de créer des événements avec des tableaux volumineux. ETW ne prend pas en charge les événements dont la taille dépasse 64 Ko. Tous ces événements seront supprimés silencieusement par ETW. En outre, les événements qui sont plus grands que bufferSize de la session consommateur seront également supprimés par ETW. La taille de l’événement est basée sur la somme des en-têtes, des métadonnées (fournisseurs, noms d’événements et de champs) et des données (valeurs de champ) de l’événement.

  • 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 empaqueté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 champ unique 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 les 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 TraceLoggingPacked macros 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.

Avertissement

Les TraceLoggingPacked macros sont difficiles à utiliser correctement et nécessitent une bonne compréhension de la façon dont les événements TraceLogging sont créés. Si elles sont utilisées de manière incorrecte, elles entraînent des événements endommagés qui ne décodent pas correctement.

Pour plus d’informations sur l’utilisation de ces macros, reportez-vous aux commentaires dans 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 (name, inType).

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

    Ajoute des données de champ (pValue, cbValue) et des métadonnées de champ (name, 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 (name, 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 (name, fieldCount) pour un struct.

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

    Ajoute des métadonnées de champ (name, fieldCount) pour un tableau de longueur variable de struct. 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 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 spécifique Type dans le EVENT_DATA_DESCRIPTOR pour les données. Les métadonnées correspondantes doivent être ajoutées via les macros métadonnées.