Glosario del protocolo de eventos de compilación

Informar un problema Ver fuente . Por la noche · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

Cada tipo de evento BEP tiene su propia semántica, mínimamente documentada en build_event_stream.proto. En el siguiente glosario, se describe cada tipo de evento.

Anulado

A diferencia de otros eventos, Aborted no tiene un tipo de ID correspondiente porque El evento Aborted reemplaza a los eventos de otros tipos. Este evento indica que La compilación finalizó antes de tiempo y no se produjo el ID del evento en el que aparece. normalmente. Aborted contiene una enum y una descripción sencilla que se puede explicar. por qué no se completó la compilación.

Por ejemplo, si una compilación evalúa un destino cuando el usuario interrumpe Bazel, BEP contiene un evento como el siguiente:

{
  "id": {
    "targetCompleted": {
      "label": "//:foo",
      "configuration": {
        "id": "544e39a7f0abdb3efdd29d675a48bc6a"
      }
    }
  },
  "aborted": {
    "reason": "USER_INTERRUPTED"
  }
}

ActionExecuted

Proporciona detalles sobre la ejecución de una instancia Action en una compilación. De forma predeterminada, este evento se se incluyen en el BEP solo para las acciones fallidas para respaldar la identificación de la causa raíz de fallas de compilación. Los usuarios pueden configurar la marca --build_event_publish_all_actions para incluir todos los eventos ActionExecuted.

BuildFinished

Se envía un solo evento BuildFinished después de que se completa el comando. incluye el código de salida del comando. Este evento proporciona información información de éxito o fracaso.

BuildMetadata

Contiene el contenido analizado de la marca --build_metadata. Este evento existe para admitir la integración de Bazel con otras herramientas mediante la canalización de datos externos (como identificadores).

BuildMetrics

Se envía un solo evento BuildMetrics al final de cada comando e incluye contadores y medidores útiles para cuantificar el comportamiento de la herramienta de compilación durante la kubectl. Estas métricas indican el trabajo realmente realizado y no cuenta el trabajo almacenado en caché y el trabajo que se reutiliza.

Ten en cuenta que es posible que memory_metrics no se propague si no había elementos no utilizados de Java. recopilación durante la ejecución del comando. Los usuarios pueden configurar las La opción --memory_profile=/dev/null que fuerza la recolección de elementos no utilizados recopilador para ejecutar al final del comando a fin de propagar memory_metrics.

{
  "id": {
    "buildMetrics": {}
  },
  "buildMetrics": {
    "actionSummary": {
      "actionsExecuted": "1"
    },
    "memoryMetrics": {},
    "targetMetrics": {
      "targetsLoaded": "9",
      "targetsConfigured": "19"
    },
    "packageMetrics": {
      "packagesLoaded": "5"
    },
    "timingMetrics": {
      "cpuTimeInMs": "1590",
      "wallTimeInMs": "359"
    }
  }
}

BuildStarted

El primer evento de una transmisión de BEP, BuildStarted, incluye metadatos que describen la comando antes de que comience cualquier trabajo significativo.

BuildToolLogs

Se envía un solo evento BuildToolLogs al final de un comando, incluidos los URI. de archivos generados por la herramienta de compilación que pueden ayudar a comprender o depurar de la herramienta de compilación. Es posible que parte de la información se incluya de forma intercalada.

{
  "id": {
    "buildToolLogs": {}
  },
  "lastMessage": true,
  "buildToolLogs": {
    "log": [
      {
        "name": "elapsed time",
        "contents": "MC4xMjEwMDA="
      },
      {
        "name": "process stats",
        "contents": "MSBwcm9jZXNzOiAxIGludGVybmFsLg=="
      },
      {
        "name": "command.profile.gz",
        "uri": "file:///tmp/.cache/bazel/_bazel_foo/cde87985ad0bfef34eacae575224b8d1/command.profile.gz"
      }
    ]
  }
}

CommandLine

El BEP contiene varios eventos CommandLine que contienen representaciones de todos argumentos de línea de comandos (incluidas opciones y argumentos no interpretados). Cada evento CommandLine tiene una etiqueta en su StructuredCommandLineId que indica qué representación transmite; tres de estos eventos aparecen en el BEP:

  • "original": Se reconstruyó la línea de comandos, ya que Bazel la recibió de Bazel. sin opciones de inicio provenientes de archivos .rc.
  • "canonical": Es la línea de comandos eficaz con archivos .rc expandidos y Se aplicó la política de invocación.
  • "tool": Se propaga a partir de la opción --experimental_tool_command_line. Esta es útil para transmitir la línea de comandos de una herramienta que une a Bazel a través de la BEP. Podría ser un mensaje de búfer de protocolo binario CommandLine codificado en base64 que se usa directamente, o una cadena que se analiza pero no se interpreta (como las opciones de la herramienta pueden diferir de las de Bazel).

Configuración

Se envía un evento Configuration por cada configuration que se usan en los objetivos de nivel superior de una compilación. Al menos un evento de configuración está esté siempre presente. TargetConfigured reutiliza el id y los IDs de los eventos TargetComplete, y es necesario para desambiguar esos eventos en compilaciones con múltiples parámetros de configuración.

{
  "id": {
    "configuration": {
      "id": "a5d130b0966b4a9ca2d32725aa5baf40e215bcfc4d5cdcdc60f5cc5b4918903b"
    }
  },
  "configuration": {
    "mnemonic": "k8-fastbuild",
    "platformName": "k8",
    "cpu": "k8",
    "makeVariable": {
      "COMPILATION_MODE": "fastbuild",
      "TARGET_CPU": "k8",
      "GENDIR": "bazel-out/k8-fastbuild/bin",
      "BINDIR": "bazel-out/k8-fastbuild/bin"
    }
  }
}

ConvenienceSymlinksIdentified

Experimental Si el elemento --experimental_convenience_symlinks_bep_event una opción, se produce un solo evento ConvenienceSymlinksIdentified Comandos build para indicar cómo se deben administrar los symlinks en el lugar de trabajo Esto permite compilar herramientas que invoquen a Bazel de forma remota y, luego, organicen la configuración como si Bazel se hubiera ejecutado de forma local.

{
  "id": {
    "convenienceSymlinksIdentified":{}
  },
  "convenienceSymlinksIdentified": {
    "convenienceSymlinks": [
      {
        "path": "bazel-bin",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out/k8-fastbuild/bin"
      },
      {
        "path": "bazel-genfiles",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out/k8-fastbuild/genfiles"
      },
      {
        "path": "bazel-out",
        "action": "CREATE",
        "target": "execroot/google3/bazel-out"
      }
    ]
  }
}

Recuperar

Indica que se produjo una operación de recuperación como parte de la ejecución del comando. A diferencia de otros eventos, si se vuelve a usar un resultado de recuperación en caché, este evento no aparecerán en el flujo de BEP.

NamedSetOfFiles

Los eventos NamedSetOfFiles informan una estructura que coincide con un depset de archivos producidos durante la evaluación del comando Los depósitos incluidos de forma transitiva se identifican mediante NamedSetOfFilesId.

Para obtener más información sobre cómo interpretar los eventos NamedSetOfFiles de una transmisión, consulta el Página de ejemplos de BEP.

OptionsParsed

Un solo evento OptionsParsed enumera todas las opciones que se aplican al comando. para separar las opciones de inicio de las opciones de comando. También incluye InvocationPolicy, si corresponde.

{
  "id": {
    "optionsParsed": {}
  },
  "optionsParsed": {
    "startupOptions": [
      "--max_idle_secs=10800",
      "--noshutdown_on_low_sys_mem",
      "--connect_timeout_secs=30",
      "--output_user_root=/tmp/.cache/bazel/_bazel_foo",
      "--output_base=/tmp/.cache/bazel/_bazel_foo/a61fd0fbee3f9d6c1e30d54b68655d35",
      "--deep_execroot",
      "--expand_configs_in_place",
      "--idle_server_tasks",
      "--write_command_log",
      "--nowatchfs",
      "--nofatal_event_bus_exceptions",
      "--nowindows_enable_symlinks",
      "--noclient_debug",
    ],
    "cmdLine": [
      "--enable_platform_specific_config",
      "--build_event_json_file=/tmp/bep.json"
    ],
    "explicitCmdLine": [
      "--build_event_json_file=/tmp/bep.json"
    ],
    "invocationPolicy": {}
  }
}

PatternExpanded

Los eventos PatternExpanded indican el conjunto de todos los objetivos que coinciden con los patrones que se proporcionan en la línea de comandos. Para que los comandos sean correctos, hay un solo evento presente con todos los patrones en PatternExpandedId y todos los objetivos en la Son los elementos secundarios del evento de PatternExpanded. Si el patrón se expande a cualquier test_suite es el conjunto de objetivos de prueba incluido por test_suite. Por cada que no se resuelve, el BEP contiene un Aborted adicional con un PatternExpandedId que identifica el patrón.

{
  "id": {
    "pattern": {
      "pattern":["//base:all"]
    }
  },
  "children": [
    {"targetConfigured":{"label":"//base:foo"}},
    {"targetConfigured":{"label":"//base:foobar"}}
  ],
  "expanded": {
    "testSuiteExpansions": {
      "suiteLabel": "//base:suite",
      "testLabels": "//base:foo_test"
    }
  }
}

Progreso

Los eventos de progreso contienen la salida estándar y el error estándar producidos por Bazel. durante la ejecución del comando. Estos eventos también se generan automáticamente según sea necesario para Anunciar eventos que no haya anunciado un "principal" lógico evento (en particular, NamedSetOfFiles).

TargetComplete

Por cada combinación de (target, configuration, aspect) que complete el de ejecución, se incluye un evento TargetComplete en BEP. El evento contiene el éxito o fracaso del objetivo y los grupos de salida solicitados del objetivo.

{
  "id": {
    "targetCompleted": {
      "label": "//examples/py:bep",
      "configuration": {
        "id": "a5d130b0966b4a9ca2d32725aa5baf40e215bcfc4d5cdcdc60f5cc5b4918903b"
      }
    }
  },
  "completed": {
    "success": true,
    "outputGroup": [
      {
        "name": "default",
        "fileSets": [
          {
            "id": "0"
          }
        ]
      }
    ]
  }
}

TargetConfigured

Para cada destino que complete la fase de análisis, se crea un evento TargetConfigured incluidas en BEP. Esta es la fuente autorizada para el "tipo de regla" de un destino . Las configuraciones que se aplican al destino aparecen en el elementos secundarios del evento.

Por ejemplo, compilar con las opciones --experimental_multi_cpu puede producir el siguiente evento TargetConfigured para un solo objetivo con dos parámetros de configuración:

{
  "id": {
    "targetConfigured": {
      "label": "//starlark_configurations/multi_arch_binary:foo"
    }
  },
  "children": [
    {
      "targetCompleted": {
        "label": "//starlark_configurations/multi_arch_binary:foo",
        "configuration": {
          "id": "c62b30c8ab7b9fc51a05848af9276529842a11a7655c71327ade26d7c894c818"
        }
      }
    },
    {
      "targetCompleted": {
        "label": "//starlark_configurations/multi_arch_binary:foo",
        "configuration": {
          "id": "eae0379b65abce68d54e0924c0ebcbf3d3df26c6e84ef7b2be51e8dc5b513c99"
        }
      }
    }
  ],
  "configured": {
    "targetKind": "foo_binary rule"
  }
}

TargetSummary

Por cada par (target, configuration) que se ejecuta, se agrega un TargetSummary junto con un resultado exitoso agregado que comprende la configuración la ejecución del objetivo y todos los aspectos aplicados a ese destino configurado.

TestResult

Si se solicitan pruebas, se envía un evento TestResult para cada intento. fragmentar y ejecutar por prueba. Esto permite que los consumidores de BEP identifiquen con precisión qué acciones de prueba fallaron sus pruebas e identifican los resultados de la prueba (como registros, test.xml) para cada acción de prueba.

TestSummary

Si se solicitan pruebas, se envía un evento TestSummary para cada (target, configuration) de prueba, el cual contiene la información necesaria para interpretar los resultados. Se incluye la cantidad de intentos, fragmentos y ejecuciones por prueba para habilitar a los consumidores de BEP para diferenciar los artefactos en estas dimensiones. Los intentos y ejecuciones por prueba se consideran mientras se produce el TestStatus agregado a diferenciar las pruebas de FLAKY de las de FAILED

UnstructuredCommandLine

A diferencia de la CommandLine, este evento lleva la línea de comandos sin analizar. marcas en formato de cadena como las encuentra la herramienta de compilación después de expandir todo .bazelrc archivos y teniendo en cuenta la marca --config.

Se puede confiar en que el evento UnstructuredCommandLine reproduce con precisión una la ejecución de comandos dado.

WorkspaceConfig

Un solo evento WorkspaceConfig contiene información de configuración relacionada con el como la raíz de ejecución.

WorkspaceStatus

Un solo evento WorkspaceStatus contiene el resultado del estado del espacio de trabajo kubectl: