Compartir a través de

Macros contenedoras de seguimiento

  • Artículo

Las macros TraceLoggingWriteWrite 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 seguido 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 parámetros TraceLoggingLevel y TraceLoggingKeyword configuran el evento. Los parámetros TraceLoggingString 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 el 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 de 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 significativo distinto de cero.
  • 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 elevados de la palabra clave. Por ejemplo, puede decidir que todos los proveedores con el nombre "MyCompany.MyComponent" usarán la palabra clave 0x1 para indicar "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 que no sea 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 con 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 0x1000000 de bits de etiqueta para indicar que el evento puede contener 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 campo 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 cchValue caracteres 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 (no parámetro cbValue), en cuyo caso es un puntero al valor que se va a incluir en el campo. pValue puede no 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: un 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 campos no requieren un parámetro de nombre. 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, pchValueo parámetro pValue. Por ejemplo, TraceLoggingInt32(x[4] + y) equivale 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: un literal de cadena (constante en tiempo de compilación) con una descripción que se 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, el valor predeterminado de la descripción del campo es "".
  • 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 de etiqueta, la etiqueta del campo tiene como valor predeterminado 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 (signo long int, 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 valor de char (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 valor de char16_t (entero de 16 bits con sugerencia de formato de cadena, que normalmente se trata como UCS-2).

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

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

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

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

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

    Agrega un campo con un valor de void* (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 de 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 de FILETIME. Cuando se usa en código C, el parámetro value 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 código C, el parámetro value debe ser una expresión lvalue.

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

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

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

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

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

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

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

    Agrega un campo con una cadena de char terminada en 0 (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 de char terminada en 0 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 de char16_t terminada en 0 (UTF-16). Si pszValue es NULL, se usa una cadena vacía u"" como valor de campo.

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

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

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

    Agrega un campo con una cadena de char con recuento (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 de char con una sugerencia de formato UTF-8. pchValue solo puede ser NULL si cchValue es 0.

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

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

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

    Agrega un campo con una cadena de wchar_t con recuento (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 (Revisión y SubAuthorityCount debe ser válido).

  • 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 no NULL a una estructura StructType. pValue->Buffer debe apuntar al principio de los datos y pValue->Length debe ser el número de bytes de datos que se incluirán 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 no NULL a una estructura StructType. pValue->Buffer debe apuntar al principio de los datos y pValue->Length debe ser el número de bytes de datos que se incluirán 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 posteriores 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, 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 serializando los datos en un búfer y usando las macros de TraceLoggingPacked que se describen a continuación.

TraceLogging admite matrices de longitud fija y de longitud variable.

  • Use la macro Array en los 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 macro FixedArray en los casos en los que la longitud de la matriz se conoce 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 apuntando al inicio del contenido de la matriz y cValues establecido 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 nombre, descripcióny etiqueta parámetros tal como se describe para las macros escalares. Si no se especifica nombre, el nombre del campo se determina a partir del texto del preprocesador de pValues. Si no se especifica descripción, la descripción del campo se "". Si no se especifica etiqueta, la etiqueta de campo se 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 todos estos eventos. Además, ETW también quitará los eventos que son mayores que el bufferSize de la sesión de 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 los tipos de campo blittable, es decir, los campos en los que cada macro de campo corresponde a un único campo y una sola región contigua con el valor del campo.

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

  • Registro de 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 macros de TraceLoggingPacked que permiten manipular directamente la definición de eventos (metadatos) y los valores de campo (datos) del evento.

Advertencia

Las macros de TraceLoggingPacked 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 del 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 (nombre, 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 metadatos.

  • TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

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