TraceLogging Wrapper Macros

As macros TraceLoggingWrite e TraceLoggingWriteActivity emitem eventos TraceLogging configurados de acordo com os parâmetros de macro. Cada uma dessas macros aceita um conjunto de parâmetros necessários seguido por até 99 parâmetros opcionais. Cada parâmetro opcional configura o evento ou adiciona um campo ao evento. Cada parâmetro opcional deve ser uma das macros TraceLogging Wrapper descritas nesta página.

Por exemplo:

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.

Neste exemplo, g_hProvider e "MyEvent1" são os parâmetros necessários. Eles especificam o provedor a ser usado para o evento e o nome do evento. Cada um dos parâmetros restantes é uma macro wrapper. Os parâmetros TraceLoggingLevel e TraceLoggingKeyword configuram o evento. Os parâmetros TraceLoggingString e TraceLoggingHResult adicionam campos ao evento.

Macros de configuração de eventos

As macros a seguir configuram o evento.

Se uma macro de configuração específica não for fornecida no TraceLoggingWrite , um padrão será usado para esse evento. Por exemplo, se nenhum parâmetro TraceLoggingLevel for usado para um evento, o evento usará um nível padrão de 5 (VERBOSE).

• TraceLoggingLevel define o nível de do evento. O nível é um valor de 8 bits que indica a gravidade do evento. Os níveis de 1 (WINEVENT_LEVEL_CRITICAL) a 5 (WINEVENT_LEVEL_VERBOSE) são definidos em <winmeta.h>. Se não for especificado, o evento assume como padrão o nível 5 (VERBOSE). O nível é uma parte importante do roteamento e filtragem de eventos ETW, portanto, todos os eventos devem ter um nível significativo diferente de zero.
• TraceLoggingKeyword define a palavra-chave do evento. Uma palavra-chave é um valor de 64 bits com cada bit indicando uma categoria à qual o evento pertence. Os 48 bits baixos da palavra-chave são definidos pelo proprietário do provedor, enquanto os 16 bits altos da palavra-chave são definidos pela Microsoft. Por exemplo, você pode decidir que todos os provedores com nome "MyCompany.MyComponent" usarão 0x1 palavra-chave para significar "Networking". Se não for especificado, o evento assume como padrão a palavra-chave 0x0 (Nenhum). A palavra-chave é uma parte importante do roteamento e filtragem de eventos ETW, portanto, todos os eventos devem ter uma palavra-chave diferente de zero significativa.
• TraceLoggingOpcode define o opcode do evento. O opcode é um valor de 8 bits que indica semântica especial para o evento, por exemplo, que o evento registra o início (WINEVENT_OPCODE_START) ou o fim (WINEVENT_OPCODE_STOP) de um de atividade ETW (um grupo de eventos relacionados). Se não for especificado, o evento assume como padrão o opcode 0 (WINEVENT_OPCODE_INFO), indicando que nenhuma semântica especial é necessária.
• TraceLoggingChannel define o canal de do evento. O canal é um valor de 8 bits que é usado para vários fins. Se não for especificado, o evento assume como padrão o canal 11 (WINEVENT_CHANNEL_TRACELOGGING). A maioria dos eventos não precisa alterar o canal do evento e não deve usar TraceLoggingChannel.
• TraceLoggingEventTag define a tag do evento. A tag é um valor de 28 bits com semântica definida pelo provedor. Por exemplo, um provedor pode definir bit de tag 0x1000000 para indicar que o evento potencialmente contém informações de identificação pessoal e deve receber tratamento especial de ferramentas de processamento de eventos específicas do provedor. Se não for especificado, o padrão da tag será 0.
• TraceLoggingDescription define a descrição do evento. A descrição é uma cadeia de caracteres literal com uma descrição legível por humanos do evento. Isso serve como um comentário sobre a finalidade do evento, e a descrição também é registrada como uma anotação nos símbolos de depuração (PDB) do componente. Se não for especificado, o padrão da descrição será "".
• TraceLoggingCustomAttribute adiciona uma anotação chave-valor aos símbolos de depuração (PDB) do componente.

Macros de campo

O TraceLogging suporta muitas macros wrapper para adicionar campos a um evento. Cada campo é um par nome-valor. Por exemplo, TraceLoggingInt32(argc, "ArgCount") adicionaria um campo INT32 chamado "ArgCount" com valor argc.

A maioria das macros de wrapper de campo aceita parâmetros semelhantes:

• valor: Uma expressão que será avaliada em tempo de execução para determinar os dados a serem incluídos no campo. A maioria das macros de wrapper de campo usa um único parâmetro para especificar o valor, mas algumas macros exigem vários parâmetros para o valor do campo, por exemplo, um ponteiro e um comprimento. O(s) parâmetro(s) de valor são sempre necessários.
  • Em alguns casos, o valor do campo é especificado como pszValue, caso em que é um ponteiro para uma cadeia de caracteres terminada por 0 a ser incluída no campo. pszValue pode ser NULL, caso em que o valor do campo será uma cadeia de caracteres vazia "".
  • Em alguns casos, o valor do campo é especificado como pchValue, caso em que é um ponteiro para uma cadeia de caracteres de cchValue incluir no campo. pchValue pode ser NULL somente se cchValue for 0.
  • Em alguns casos, o valor do campo é especificado como pValue com um tamanho determinado automaticamente (sem parâmetro cbValue), caso em que é um ponteiro para o valor a ser incluído no campo. pValue pode não ser NULL.
  • Em alguns casos, o valor do campo é especificado como pValue com um cbValue parâmetro para especificar o tamanho (em bytes) dos dados a serem incluídos no campo. pValue pode ser NULL somente se cbValue for 0.
• nome: Um literal de cadeia de caracteres (constante de tempo de compilação) com o nome a ser usado para o campo. A maioria das macros de wrapper de campo não requer um parâmetro name. Se você omitir o parâmetro name, o nome do campo será determinado com base no texto do pré-processador do valor da macro, pszValue, pchValueou pValue parâmetro. Por exemplo, TraceLoggingInt32(x[4] + y) é equivalente a TraceLoggingInt32(x[4] + y, "x[4] + y"). Ambos adicionariam um campo chamado "x[4] + y" ao evento com um valor determinado pela avaliação da expressão x[4] + y.
• descrição: Uma cadeia de caracteres literal (constante de tempo de compilação) com uma descrição a ser usada para o campo. Isso é usado principalmente como um lugar conveniente para colocar um comentário para o campo, mas a descrição também é registrada como uma anotação nos símbolos de depuração (PDB) do componente. A descrição é opcional. Se o parâmetro description for omitido, o padrão da descrição do campo será "".
• tag: Um inteiro de 28 bits (constante de tempo de compilação) com semântica definida pelo provedor. Por exemplo, um provedor pode definir 0x2 de tag para indicar que o campo contém um número de telefone e deve receber tratamento especial de ferramentas de processamento de eventos específicas do provedor. Se o parâmetro tag for omitido, o padrão da tag do campo será 0.

Por exemplo, as seguintes invocações de macro de wrapper têm o mesmo efeito:

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

Escalares

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

  Adiciona um campo com um tipo que é deduzido automaticamente do tipo do parâmetro value. (somente C++)

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

  Adiciona um campo com um valor INT8.

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

  Adiciona um campo com um valor UINT8.

• TraceLoggingInt16(valor, [nome, ...]):

  Adiciona um campo com um valor INT16.

• TraceLoggingUInt16(valor, [nome, ...]):

  Adiciona um campo com um valor UINT16.

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

  Adiciona um campo com um valor INT32.

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

  Adiciona um campo com um valor UINT32.

• TraceLoggingInt64(valor, [nome, ...]):

  Adiciona um campo com um valor INT64.

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

  Adiciona um campo com um valor UINT64.

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

  Adiciona um campo com um valor INT_PTR (inteiro assinado com o mesmo tamanho de um ponteiro).

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

  Adiciona um campo com um valor UINT_PTR (inteiro não assinado com o mesmo tamanho de um ponteiro).

• TraceLoggingLong(valor, [nome, ...]):

  Adiciona um campo com um valor LONG (assinado long int, 32 bits em plataformas Windows).

• TraceLoggingULong(valor, [nome, ...]):

  Adiciona um campo com um valor ULONG (long int não assinado, 32 bits em plataformas Windows).

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

  Adiciona um campo com um valor INT8 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor UINT8 com uma dica de formatação hexadecimal.

• TraceLoggingHexInt16(valor, [nome, ...]):

  Adiciona um campo com um valor INT16 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor UINT16 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor INT32 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor UINT32 com uma dica de formatação hexadecimal.

• TraceLoggingHexInt64(valor, [nome, ...]):

  Adiciona um campo com um valor INT64 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor UINT64 com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor INT_PTR com uma dica de formatação hexadecimal.

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

  Adiciona um campo com um valor UINT_PTR com uma dica de formatação hexadecimal.

• TraceLoggingHexLong (valor, [nome, ...]):

  Adiciona um campo com um valor LONG com uma dica de formatação hexadecimal.

• TraceLoggingHexULong(valor, [nome, ...]):

  Adiciona um campo com um valor ULONG com uma dica de formatação hexadecimal.

• TraceLoggingFloat32(valor, [nome, ...]):

  Adiciona um campo com um valor FLOAT (ponto flutuante de 32 bits).

• TraceLoggingFloat64(valor, [nome, ...]):

  Adiciona um campo com um valor DOUBLE (ponto flutuante de 64 bits).

• TraceLoggingBoolean (valor, [nome, ...]):

  Adiciona um campo com um valor booleano de 8 bits (Win32 BOOLEAN ou C++ bool).

• TraceLoggingBool (valor, [nome, ...]):

  Adiciona um campo com um valor booleano de 32 bits (Win32 BOOL).

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

  Adiciona um campo com um valor char (inteiro de 8 bits com dica de formatação de cadeia de caracteres, normalmente tratado como página de código 1252).

• TraceLoggingChar16(valor, [nome, ...]):

  Adiciona um campo com um valor char16_t (inteiro de 16 bits com dica de formatação de cadeia de caracteres, normalmente tratado como UCS-2).

• TraceLoggingWChar(valor, [nome, ...]):

  Adiciona um campo com um valor wchar_t (igual ao char16_t em plataformas Windows).

• TraceLoggingPointer(valor, [nome, ...]):

  Adiciona um campo com um valor void* (valor do tamanho do ponteiro com uma dica de formatação hexadecimal).

• TraceLoggingCodePointer(valor, [nome, ...]):

  Adiciona um campo com um valor void* (valor do tamanho do ponteiro com uma dica de formatação de ponteiro de código).

• TraceLoggingPid(valor, [nome, ...]):

  Adiciona um campo com um valor INT32 com uma dica de formatação de ID de processo.

• TraceLoggingTid(valor, [nome, ...]):

  Adiciona um campo com um valor INT32 com uma dica de formatação de ID de thread.

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

  Adiciona um campo com um valor UINT32 com uma dica de formatação IPv4 (ordem de bytes de rede).

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

  Adiciona um campo com um valor binário de 16 bytes com uma dica de formatação IPv6.

• TraceLoggingPort(valor, [nome, ...]):

  Adiciona um campo com um valor UINT16 com uma dica de formatação de porta IP (ordem de bytes de rede).

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

  Adiciona um campo com um valor de SOCKADDR.

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

  Adiciona um campo com um valor UINT32 com uma dica de formatação de código de erro Win32.

• TraceLoggingNTStatus(valor, [nome, ...]):

  Adiciona um campo com um valor NTSTATUS (LONG) com uma dica de formatação de código de erro WinNT.

• TraceLoggingHResult(valor, [nome, ...]):

  Adiciona um campo com um valor HRESULT (LONG) com uma dica de formatação HRESULT do Windows.

• TraceLoggingFileTime(valor, [nome, ...]):

  Adiciona um campo com um valor de FILETIME. Quando usado no código C, o parâmetro value deve ser uma expressão lvalue.

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

  Adiciona um campo com um valor de FILETIME com uma dica de formatação de fuso horário UTC. Quando usado no código C, o parâmetro value deve ser uma expressão lvalue.

• TraceLoggingSystemTime(valor, [nome, ...]):

  Adiciona um campo com um valor de SYSTEMTIME. Quando usado no código C, o parâmetro value deve ser uma expressão lvalue.

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

  Adiciona um campo com um valor SYSTEMTIME com uma dica de formatação de fuso horário UTC. Quando usado no código C, o parâmetro value deve ser uma expressão lvalue.

• TraceLoggingGuid(valor, [nome, ...]):

  Adiciona um campo com um GUID valor. Quando usado no código C, o parâmetro value deve ser uma expressão lvalue.

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

  Adiciona um campo com uma cadeia de caracteres de char terminada por 0 (normalmente tratada como página de código 1252). Se pszValue for NULL, uma cadeia de caracteres vazia "" será usada como o valor do campo.

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

  Adiciona um campo com uma cadeia de caracteres de char terminada por 0 com uma dica de formatação UTF-8. Se pszValue for NULL, uma cadeia de caracteres vazia "" será usada como o valor do campo.

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

  Adiciona um campo com uma cadeia de caracteres de char16_t terminada por 0 (UTF-16). Se pszValue for NULL, uma cadeia de caracteres vazia u"" será usada como o valor do campo.

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

  Adiciona um campo com uma cadeia de caracteres de wchar_t terminada por 0 (UTF-16 no Windows). Se pszValue for NULL, uma cadeia de caracteres vazia L"" será usada como o valor do campo.

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

  Adiciona um campo com uma cadeia de caracteres char contada (normalmente tratada como página de código 1252). pchValue pode ser NULL somente se cchValue for 0.

• TraceLoggingCountedUtf8String(pchValue, cchValue, [nome, descrição, tag]):

  Adiciona um campo com uma cadeia de char contada com uma dica de formatação UTF-8. pchValue pode ser NULL somente se cchValue for 0.

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

  Adiciona um campo com uma cadeia de char16_t contada (UTF-16). pchValue pode ser NULL somente se cchValue for 0.

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

  Adiciona um campo com uma cadeia de wchar_t contada (UTF-16 no Windows). pchValue pode ser NULL somente se cchValue for 0.

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

  Adiciona um campo com um valor ANSI_STRING. O ponteiro pValue não deve ser NULL.

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

  Adiciona um campo com um valor UNICODE_STRING. O ponteiro pValue não deve ser NULL.

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

  Adiciona um campo com um valor de SID. O ponteiro pValue não deve ser NULL e deve apontar para um SID inicializado corretamente (Revision e SubAuthorityCount devem ser válidos).

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

  Adiciona um campo com dados binários.

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

  Adiciona um campo com dados binários com a dica de formatação especificada por outType.

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

  Adiciona um campo com dados binários. pValue deve ser um ponteiro não-NULL para uma StructType struct. pValue->Buffer deve apontar para o início dos dados e pValue->Length deve ser o número de bytes de dados a serem incluídos no campo.

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

  Adiciona um campo com dados binários com a dica de formatação especificada por outType. pValue deve ser um ponteiro não-NULL para uma StructType struct. pValue->Buffer deve apontar para o início dos dados e pValue->Length deve ser o número de bytes de dados a serem incluídos no campo.

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

  Adiciona um campo com dados binários que foram serializados de acordo com um protocolo de serialização. Informações de decodificação constante em tempo de compilação serão incluídas junto com o evento para permitir a desserialização pelo decodificador de eventos.

Estruturas

Você pode usar a macroTraceLoggingStruct(fieldCount, name, [...]) para criar uma estrutura nomeada (grupo de campos). O parâmetro fieldCount indica quantos dos campos subsequentes devem ser contados como parte da estrutura. As estruturas podem ser aninhadas, caso em que cada estrutura aninhada e seus campos contidos contam como um único campo para fins de definição da estrutura pai.

Matrizes

Você pode criar um campo que contenha uma matriz de valores escalares (únicos). Por exemplo, você adiciona uma matriz de GUIDs como um único campo em seu evento.

O TraceLogging suporta arrays de comprimento fixo e variável.

• Use a macro Array nos casos em que o comprimento da matriz não é conhecido em tempo de compilação e pode ser diferente cada vez que o evento é gerado.
• Use a macro FixedArray nos casos em que o comprimento da matriz é conhecido em tempo de compilação (ou seja, quando o comprimento da matriz é uma constante). Isso comunica ao consumidor de eventos que todos os eventos com um nome de evento específico terão o mesmo número de itens no campo de matriz.

Todas as macros de matriz exigem que os pValues e cValues parâmetros sejam especificados, com pValues apontando para o início do conteúdo da matriz e cValues definido para o número de itens na matriz. pValues pode ser NULL somente se cValues for 0.

Todas as macros de matriz aceitam opcionalmente nome, descriçãoe marcar parâmetros conforme descrito para as macros escalares. Se nome não for especificado, o nome do campo será determinado a partir do texto do pré-processador de pValues. Se descrição não for especificada, a descrição do campo será "". Se de tag não for especificado, a tag de campo será 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 compactadas

TraceLoggingProvider.h fornece apenas macros de campo para tipos de campo blittable, ou seja, campos em que cada macro de campo corresponde a um único campo e uma única região contígua de memória com o valor do campo.

TraceLoggingProvider.h não fornece suporte direto para casos mais complexos, como:

• Registro em log de uma matriz de um tipo de comprimento variável, como uma matriz de cadeias de caracteres.
• Registro de uma matriz de estruturas.
• Passagem de vários campos para o ETW através de um único buffer para reduzir a sobrecarga do log de eventos.

Para dar suporte a esses cenários, TraceLoggingProvider.h define várias macros TraceLoggingPacked que permitem manipular diretamente a definição de evento (metadados) e os valores de campo (dados) do evento.

Para obter detalhes sobre o uso dessas macros, consulte os comentários no cabeçalho TraceLoggingProvider.h.

• TraceLoggingPackedField(pValue, cbValue, inType, [nome, descrição, tags]):

  Adiciona dados de campo (pValue, cbValue) e metadados de campo (name, inType).

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

  Adiciona dados de campo (pValue, cbValue) e metadados de campo (name, inType) juntamente com uma dica de formatação (outType).

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

  Adiciona metadados de campo (nome, inType) sem adicionar dados de campo. Os dados de campo correspondentes devem ser adicionados via TraceLoggingPackedData.

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

  Adiciona metadados de campo (name, inType) e uma dica de formatação (outType) sem adicionar dados de campo. Os dados de campo correspondentes devem ser adicionados via TraceLoggingPackedData.

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

  Adiciona metadados de campo (name, fieldCount) para uma struct.

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

  Adiciona metadados de campo (name, fieldCount) para uma matriz de struct de comprimento variável. O comprimento da matriz deve ser especificado via TraceLoggingPackedData.

• TraceLoggingPackedData(pValue, cbValue):

  Adiciona dados de campo a um evento sem adicionar metadados de campo. Os metadados correspondentes devem ser adicionados através das macros de Metadados.

• TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

  Adiciona dados de campo a um evento sem adicionar metadados de campo, usando um Type específico no EVENT_DATA_DESCRIPTOR para os dados. Os metadados correspondentes devem ser adicionados através das macros de Metadados.