Macros contenedoras de seguimiento

  • Artículo

Las macros TraceLoggingWrite y TraceLoggingWriteActivity emiten eventos TraceLogging configurados según los parámetros de macro. Cada una de estas macros acepta un conjunto de parámetros necesarios seguidos de hasta 99 parámetros opcionales. Cada parámetro opcional configura el evento o agrega un campo al evento. Cada parámetro opcional debe ser una de las macros contenedoras de seguimiento descritas en esta página.

Por ejemplo:

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.

En este ejemplo, g_hProvider y "MyEvent1" son los parámetros necesarios. Especifican el proveedor que se va a usar para el evento y el nombre del evento. Cada uno de los parámetros restantes es una macro contenedora. Los TraceLoggingLevel parámetros y TraceLoggingKeyword configuran el evento . Los TraceLoggingString parámetros y TraceLoggingHResult agregan campos al evento .

Macros de configuración de eventos

Las macros siguientes configuran el evento.

Si no se proporciona una macro de configuración determinada en TraceLoggingWrite, se usa un valor predeterminado para ese evento. Por ejemplo, si no se usa ningún parámetro TraceLoggingLevel para un evento, el evento usa un nivel predeterminado de 5 (VERBOSE).

  • TraceLoggingLevel establece el nivel del evento. El nivel es un valor de 8 bits que indica la gravedad del evento. Los niveles de 1 (WINEVENT_LEVEL_CRITICAL) a 5 (WINEVENT_LEVEL_VERBOSE) se definen en <winmeta.h>. Si no se especifica, el evento tiene como valor predeterminado el nivel 5 (VERBOSE). El nivel es una parte importante del enrutamiento y el filtrado de eventos ETW, por lo que todos los eventos deben tener un nivel distinto de cero significativo.
  • TraceLoggingKeyword establece la palabra clave del evento. Una palabra clave es un valor de 64 bits con cada bit que indica una categoría a la que pertenece el evento. El propietario del proveedor define los 48 bits bajos de la palabra clave, mientras que Microsoft define los 16 bits altos de la palabra clave. Por ejemplo, puede decidir que todos los proveedores con el nombre "MyCompany.MyComponent" usarán la palabra clave 0x1 para significar "Redes". Si no se especifica, el evento tiene como valor predeterminado la palabra clave 0x0 (None). La palabra clave es una parte importante del enrutamiento y el filtrado de eventos ETW, por lo que todos los eventos deben tener una palabra clave significativa distinta de cero.
  • TraceLoggingOpcode establece el código de operación del evento. El código de operación es un valor de 8 bits que indica una semántica especial para el evento, por ejemplo, que el evento registra el principio (WINEVENT_OPCODE_START) o el final (WINEVENT_OPCODE_STOP) de una actividad ETW (un grupo de eventos relacionados). Si no se especifica, el evento tiene como valor predeterminado opcode 0 (WINEVENT_OPCODE_INFO) que indica que no se requiere ninguna semántica especial.
  • TraceLoggingChannel establece el canal del evento. El canal es un valor de 8 bits que se usa para diversos fines. Si no se especifica, el evento tiene como valor predeterminado el canal 11 (WINEVENT_CHANNEL_TRACELOGGING). La mayoría de los eventos no necesitan cambiar el canal del evento y no deben usar TraceLoggingChannel.
  • TraceLoggingEventTag establece la etiqueta del evento. La etiqueta es un valor de 28 bits con semántica definida por el proveedor. Por ejemplo, un proveedor podría definir el bit de etiqueta 0x1000000 para indicar que el evento contiene información de identificación personal y debe recibir un tratamiento especial de las herramientas de procesamiento de eventos específicas del proveedor. Si no se especifica, la etiqueta tiene como valor predeterminado 0.
  • TraceLoggingDescription establece la descripción del evento. La descripción es un literal de cadena con una descripción legible del evento. Esto sirve como comentario sobre el propósito del evento y la descripción también se registra como una anotación en los símbolos de depuración (PDB) del componente. Si no se especifica, la descripción tiene ""como valor predeterminado .
  • TraceLoggingCustomAttribute agrega una anotación clave-valor a los símbolos de depuración (PDB) del componente.

Macros de campo

TraceLogging admite muchas macros contenedoras para agregar campos a un evento. Cada campo es un par nombre-valor. Por ejemplo, TraceLoggingInt32(argc, "ArgCount") agregaría un campo INT32 denominado "ArgCount" con el valor argc.

La mayoría de las macros contenedoras de campos aceptan parámetros similares:

  • Valor: Expresión que se evaluará en tiempo de ejecución para determinar los datos que se van a incluir en el campo. La mayoría de las macros contenedoras de campo usan un único parámetro para especificar el valor, pero algunas macros requieren varios parámetros para el valor de campo, por ejemplo, un puntero y una longitud. Los parámetros de valor siempre son necesarios.
    • En algunos casos, el valor de campo se especifica como pszValue, en cuyo caso es un puntero a una cadena de caracteres terminada en 0 para incluir en el campo. pszValue puede ser NULL, en cuyo caso el valor del campo será una cadena ""vacía .
    • En algunos casos, el valor de campo se especifica como pchValue, en cuyo caso es un puntero a una cadena de caracteres cchValue que se van a incluir en el campo. pchValue solo puede ser NULL si cchValue es 0.
    • En algunos casos, el valor de campo se especifica como pValue con un tamaño determinado automáticamente (sin parámetro cbValue ), en cuyo caso es un puntero al valor que se va a incluir en el campo. pValue no puede ser NULL.
    • En algunos casos, el valor de campo se especifica como pValue con un parámetro cbValue para especificar el tamaño (en bytes) de los datos que se van a incluir en el campo. pValue solo puede ser NULL si cbValue es 0.
  • Nombre: Literal de cadena (constante en tiempo de compilación) con el nombre que se va a usar para el campo. La mayoría de las macros contenedoras de campo no requieren un parámetro name. Si omite el parámetro name, el nombre del campo se determina en función del texto del preprocesador del valor de la macro, pszValue, pchValue o el parámetro pValue . Por ejemplo, TraceLoggingInt32(x[4] + y) es equivalente a TraceLoggingInt32(x[4] + y, "x[4] + y"). Ambos agregarían un campo denominado "x[4] + y" al evento con un valor determinado mediante la evaluación de la expresión x[4] + y.
  • Descripción: Literal de cadena (constante en tiempo de compilación) con una descripción que se va a usar para el campo. Esto se usa principalmente como un lugar conveniente para colocar un comentario para el campo, pero la descripción también se registra como una anotación en los símbolos de depuración del componente (PDB). La descripción es opcional. Si se omite el parámetro description, la descripción del campo tiene ""como valor predeterminado .
  • etiqueta: Entero de 28 bits (constante en tiempo de compilación) con semántica definida por el proveedor. Por ejemplo, un proveedor podría definir la etiqueta 0x2 para indicar que el campo contiene un número de teléfono y debe recibir un tratamiento especial de las herramientas de procesamiento de eventos específicas del proveedor. Si se omite el parámetro tag, el valor predeterminado de la etiqueta del campo es 0.

Por ejemplo, las siguientes invocaciones de macro contenedor tienen el mismo efecto:

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

Escalares

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

    Agrega un campo con un tipo que se deduce automáticamente del tipo del parámetro value. (solo C++)

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

    Agrega un campo con un valor INT8.

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

    Agrega un campo con un valor UINT8.

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

    Agrega un campo con un valor INT16.

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

    Agrega un campo con un valor UINT16.

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

    Agrega un campo con un valor INT32.

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

    Agrega un campo con un valor UINT32.

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

    Agrega un campo con un valor INT64.

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

    Agrega un campo con un valor UINT64.

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

    Agrega un campo con un valor de INT_PTR (entero con signo con el mismo tamaño que un puntero).

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

    Agrega un campo con un valor de UINT_PTR (entero sin signo con el mismo tamaño que un puntero).

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

    Agrega un campo con un valor LONG (int long con signo, 32 bits en plataformas Windows).

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

    Agrega un campo con un valor de ULONG (int largo sin signo, 32 bits en plataformas Windows).

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

    Agrega un campo con un valor INT8 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor UINT8 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor INT16 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor UINT16 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor INT32 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor UINT32 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor INT64 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor UINT64 con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor de INT_PTR con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor de UINT_PTR con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor LONG con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor de ULONG con una sugerencia de formato hexadecimal.

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

    Agrega un campo con un valor FLOAT (punto flotante de 32 bits).

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

    Agrega un campo con un valor DOUBLE (punto flotante de 64 bits).

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

    Agrega un campo con un valor booleano de 8 bits (Win32 BOOLEAN o C++ bool).

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

    Agrega un campo con un valor booleano de 32 bits (Win32 BOOL).

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

    Agrega un campo con un char valor (entero de 8 bits con sugerencia de formato de cadena, que normalmente se trata como página de códigos 1252).

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

    Agrega un campo con un char16_t valor (entero de 16 bits con sugerencia de formato de cadena, normalmente tratado como UCS-2).

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

    Agrega un campo con un wchar_t valor (igual que char16_t en plataformas Windows).

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

    Agrega un campo con un void* valor (valor de tamaño de puntero con una sugerencia de formato hexadecimal).

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

    Agrega un campo con un void* valor (valor de tamaño de puntero con una sugerencia de formato de puntero de código).

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

    Agrega un campo con un valor INT32 con una sugerencia de formato de identificador de proceso.

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

    Agrega un campo con un valor INT32 con una sugerencia de formato de identificador de subproceso.

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

    Agrega un campo con un valor UINT32 con una sugerencia de formato IPv4 (orden de bytes de red).

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

    Agrega un campo con un valor binario de 16 bytes con una sugerencia de formato IPv6.

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

    Agrega un campo con un valor UINT16 con una sugerencia de formato de puerto IP (orden de bytes de red).

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

    Agrega un campo con un valor SOCKADDR .

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

    Agrega un campo con un valor UINT32 con una sugerencia de formato de código de error Win32.

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

    Agrega un campo con un valor NTSTATUS (LONG) con una sugerencia de formato de código de error winNT.

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

    Agrega un campo con un valor HRESULT (LONG) con una sugerencia de formato HRESULT de Windows.

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

    Agrega un campo con un valor FILETIME . Cuando se usa en el código de C, el value parámetro debe ser una expresión lvalue.

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

    Agrega un campo con un valor FILETIME con una sugerencia de formato de zona horaria UTC. Cuando se usa en el código de C, el value parámetro debe ser una expresión lvalue.

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

    Agrega un campo con un valor SYSTEMTIME . Cuando se usa en el código de C, el value parámetro debe ser una expresión lvalue.

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

    Agrega un campo con un valor SYSTEMTIME con una sugerencia de formato de zona horaria UTC. Cuando se usa en el código de C, el value parámetro debe ser una expresión lvalue.

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

    Agrega un campo con un valor GUID . Cuando se usa en el código de C, el value parámetro debe ser una expresión lvalue.

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

    Agrega un campo con una cadena terminada en 0 char (normalmente tratada como página de códigos 1252). Si pszValue es NULL, se usa una cadena "" vacía como valor de campo.

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

    Agrega un campo con una cadena terminada en 0 char con una sugerencia de formato UTF-8. Si pszValue es NULL, se usa una cadena "" vacía como valor de campo.

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

    Agrega un campo con una cadena terminada char16_t en 0 (UTF-16). Si pszValue es NULL, se usa una cadena u"" vacía como valor de campo.

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

    Agrega un campo con una cadena terminada wchar_t en 0 (UTF-16 en Windows). Si pszValue es NULL, se usa una cadena L"" vacía como valor de campo.

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

    Agrega un campo con una cadena contada char (normalmente tratada como página de códigos 1252). pchValue solo puede ser NULL si cchValue es 0.

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

    Agrega un campo con una cadena con una char sugerencia de formato UTF-8. pchValue solo puede ser NULL si cchValue es 0.

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

    Agrega un campo con una cadena con recuento char16_t (UTF-16). pchValue solo puede ser NULL si cchValue es 0.

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

    Agrega un campo con una cadena con recuento wchar_t (UTF-16 en Windows). pchValue solo puede ser NULL si cchValue es 0.

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

    Agrega un campo con un valor de ANSI_STRING . El puntero pValue no debe ser NULL.

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

    Agrega un campo con un valor de UNICODE_STRING . El puntero pValue no debe ser NULL.

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

    Agrega un campo con un valor de SID . El puntero pValue no debe ser NULL y debe apuntar a un SID inicializado correctamente (Revision y SubAuthorityCount deben ser válidos).

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

    Agrega un campo con datos binarios.

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

    Agrega un campo con datos binarios con la sugerencia de formato especificada por outType.

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

    Agrega un campo con datos binarios. pValue debe ser un puntero distinto de NULL a una StructType estructura. pValue->Buffer debe apuntar al principio de los datos y pValue->Length debe ser el número de bytes de datos que se van a incluir en el campo.

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

    Agrega un campo con datos binarios con la sugerencia de formato especificada por outType. pValue debe ser un puntero distinto de NULL a una StructType estructura. pValue->Buffer debe apuntar al principio de los datos y pValue->Length debe ser el número de bytes de datos que se van a incluir en el campo.

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

    Agrega un campo con datos binarios que se han serializado según un protocolo de serialización. La información de descodificación constante en tiempo de compilación se incluirá junto con el evento para permitir la deserialización por parte del descodificador de eventos.

Estructuras

Puede usar la macro TraceLoggingStruct(fieldCount, name, [...]) para crear una estructura con nombre (grupo de campos). El parámetro fieldCount indica cuántos de los campos subsiguientes se deben contar como parte de la estructura. Las estructuras se pueden anidar, en cuyo caso cada estructura anidada y sus campos contenidos cuentan como un único campo para definir la estructura primaria.

Matrices

Puede crear un campo que contenga una matriz de valores escalares (únicos). Por ejemplo, se agrega una matriz de GUID como un único campo en el evento.

Nota

Aunque el protocolo TraceLogging admite matrices de todos los tipos, TraceLoggingProvider.h solo proporciona macros contenedoras para matrices de valores simples, por ejemplo, proporciona macros para matrices de INT32 y GUID, pero no proporciona macros para matrices de cadenas o matrices de estructuras. Es posible crear eventos con matrices de valores complejos serializar los datos en un búfer y, a continuación, usar las TraceLoggingPacked macros que se describen a continuación.

TraceLogging admite matrices de longitud fija y longitud variable.

  • Use la Array macro en casos en los que la longitud de la matriz no se conoce en tiempo de compilación y puede ser diferente cada vez que se genera el evento.
  • Use la FixedArray macro en los casos en los que se conoce la longitud de la matriz en tiempo de compilación (es decir, cuando la longitud de la matriz es una constante). Esto se comunica con el consumidor de eventos que todos los eventos con un nombre de evento determinado tendrán el mismo número de elementos en el campo de matriz.

Todas las macros de matriz requieren que se especifiquen los parámetros pValues y cValues , con pValues que apuntan al inicio del contenido de la matriz y cValues establecidos en el número de elementos de la matriz. pValues solo puede ser NULL si cValues es 0.

Todas las macros de matriz aceptan opcionalmente parámetros de nombre, descripción y etiqueta , como se describe para las macros escalares. Si no se especifica name , el nombre del campo se determina a partir del texto del preprocesador de pValues. Si no se especifica description , la descripción del campo será "". Si no se especifica la etiqueta , la etiqueta de campo será 0.

Nota

Para asegurarse de que ETW no quita los eventos, evite crear eventos con matrices grandes. ETW no admite eventos de más de 64 KB. ETW eliminará silenciosamente cualquier evento de este tipo. Además, ETW también quitará los eventos que sean mayores que el bufferSize de la sesión del consumidor. El tamaño del evento se basa en la suma de los encabezados, metadatos (proveedor, evento y nombres de campo) y datos (valores de 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, ...])

Macros empaquetadas

TraceLoggingProvider.h solo proporciona macros de campo para tipos de campo que se pueden transferir en bloque, es decir, campos en los que cada macro de campo corresponde a un único campo y una sola región contigua de memoria con el valor del campo.

TraceLoggingProvider.h no proporciona compatibilidad directa con casos más complejos, como:

  • Registrar una matriz de un tipo de longitud variable, como una matriz de cadenas.
  • Registro de una matriz de estructuras.
  • Pasar varios campos a ETW a través de un único búfer para reducir la sobrecarga del registro de eventos.

Para admitir estos escenarios, TraceLoggingProvider.h define varias TraceLoggingPacked macros que permiten manipular directamente la definición de eventos (metadatos) y los valores de campo (datos) del evento.

Advertencia

Las TraceLoggingPacked macros son complicadas de usar correctamente y requieren una buena comprensión de cómo se crean los eventos tracelogging. Si se usa incorrectamente, producirá eventos dañados que no descodifiquen correctamente.

Para obtener más información sobre el uso de estas macros, consulte los comentarios en el encabezado TraceLoggingProvider.h.

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

    Agrega datos de campo (pValue, cbValue) y metadatos de campo (nombre, inType).

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

    Agrega datos de campo (pValue, cbValue) y metadatos de campo (name, inType) junto con una sugerencia de formato (outType).

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

    Agrega metadatos de campo (nombre, inType) sin agregar datos de campo. Los datos de campo correspondientes se deben agregar a través de TraceLoggingPackedData.

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

    Agrega metadatos de campo (name, inType) y una sugerencia de formato (outType) sin agregar datos de campo. Los datos de campo correspondientes se deben agregar a través de TraceLoggingPackedData.

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

    Agrega metadatos de campo (nombre, fieldCount) para una estructura.

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

    Agrega metadatos de campo (nombre, fieldCount) para una matriz de longitud variable de struct. La longitud de la matriz debe especificarse a través de TraceLoggingPackedData.

  • TraceLoggingPackedData(pValue, cbValue):

    Agrega datos de campo a un evento sin agregar metadatos de campo. Los metadatos correspondientes se deben agregar a través de las macros de metadatos.

  • TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

    Agrega datos de campo a un evento sin agregar metadatos de campo, usando un elemento específico Type de la EVENT_DATA_DESCRIPTOR para los datos. Los metadatos correspondientes se deben agregar a través de las macros de metadatos.