# Acceso a datos de telemetría en tiempo real para extensiones mediante la API de telemetría La API de telemetría de Lambda les permite a sus extensiones recibir datos de telemetría directamente de Lambda. Durante la inicialización e invocación de la función, Lambda captura automáticamente la telemetría, como los registros, las métricas de la plataforma y los seguimientos de la plataforma. La API de telemetría les permite a las extensiones obtener estos datos de telemetría directamente de Lambda casi en tiempo real. Dentro del entorno de ejecución de Lambda, puede suscribir las extensiones de Lambda a flujos de telemetría. Tras suscribirse, Lambda envía automáticamente todos los datos de telemetría a sus extensiones. A continuación, tiene flexibilidad para procesar, filtrar y despachar los datos a su destino preferido, como un bucket de Amazon Simple Storage Service (Amazon S3) o un proveedor de herramientas de observabilidad de terceros. El siguiente diagrama muestra cómo la API de extensiones y la API de telemetría enlazan las extensiones a Lambda desde el entorno de ejecución. Además, la API de tiempo de ejecución conecta el tiempo de ejecución y la función a Lambda. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/telemetry-api-concept-diagram.png) **importante** La API de telemetría de Lambda reemplaza a la API de registros de Lambda. **Si bien la API de registros sigue siendo completamente funcional, recomendamos utilizar solo la API de telemetría en el futuro.** Puede suscribir su extensión a una transmisión de telemetría mediante la API de telemetría o la API de registros. Tras suscribirse mediante una de estas API, cualquier intento de suscribirse mediante la otra API volverá a causar un error. **Requisito de versión del esquema de instancias administradas de Lambda** Las instancias administradas de Lambda solo admiten la versión de esquema `2025-01-29` de la API de telemetría. Si se suscribe a flujos de telemetría para funciones de instancias administradas, **debe** utilizar `"schemaVersion": "2025-01-29"` en su solicitud de suscripción. El uso de versiones anteriores del esquema provocará que Lambda rechace los eventos. La versión del esquema `2025-01-29` es compatible con versiones anteriores y se puede utilizar tanto con las instancias administradas de Lambda como con las funciones de Lambda (predeterminadas). Recomendamos utilizar esta versión para todas las extensiones nuevas a fin de garantizar la compatibilidad entre ambos modelos de implementación. Las extensiones pueden utilizar la API de telemetría para suscribirse a tres flujos de telemetría diferentes: + **Telemetría de plataforma**: registros, métricas y seguimientos, que describen los eventos y errores relacionados con el ciclo de vida del tiempo de ejecución del entorno de ejecución, el ciclo de vida de las extensiones y las invocaciones de funciones. + **Registros de funciones**: registros personalizados que genera el código de la función de Lambda. + **Registros de extensiones**: registros personalizados generados por el código de extensión de Lambda. **nota** Lambda envía registros y métricas a CloudWatch y seguimientos a X-Ray (si lo tiene activado), incluso si una extensión se suscribe a los flujos de telemetría. **Topics** + [ ## Creación de extensiones mediante la API de telemetría ](#telemetry-api-creating-extensions) + [ ## Registro de sus extensiones ](#telemetry-api-registration) + [ ## Creación de un oyente de telemetría ](#telemetry-api-listener) + [ ## Especificación de un protocolo de destino ](#telemetry-api-destination) + [ ## Configuración del uso de memoria y el almacenamiento en búfer ](#telemetry-api-buffering) + [ ## Envío de una solicitud de suscripción a la API de telemetría ](#telemetry-api-subscription) + [ ## Mensajes entrantes de la API de telemetría ](#telemetry-api-messages) + [ # Referencia de la API de telemetría de Lambda ](telemetry-api-reference.md) + [ # Referencia del esquema `Event` de la API de telemetría de Lambda ](telemetry-schema-reference.md) + [ # Conversión de objetos `Event` de la API de telemetría de Lambda en OpenTelemetry Spans ](telemetry-otel-spans.md) + [ # Uso de la API de registros de Lambda ](runtimes-logs-api.md) ## Creación de extensiones mediante la API de telemetría Las extensiones de Lambda se ejecutan como un proceso independiente en el entorno de ejecución. Las extensiones se pueden seguir ejecutando una vez que finaliza la invocación de la función. Dado que las extensiones son procesos separados, puede escribirlas en un idioma diferente al del código de la función. Recomendamos al usuario que escriba extensiones mediante un lenguaje compilado como Golang o Rust. De esta manera, la extensión es un binario autónomo compatible con cualquier tiempo de ejecución admitido. El siguiente diagrama ilustra un proceso de cuatro pasos para crear una extensión que reciba y procese datos de telemetría mediante la API de telemetría. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/telemetry-api-creation-steps.png) A continuación, se muestra cada paso en mayor profundidad: 1. Registre su extensión mediante [Utilice la API de las extensiones de Lambda para crear extensiones](runtimes-extensions-api.md). Esto le proporciona un `Lambda-Extension-Identifier`, que necesitará en los siguientes pasos. Para obtener más información sobre cómo registrar su extensión, consulte [Registro de sus extensiones](#telemetry-api-registration). 1. Cree un oyente de telemetría. Puede ser un servidor HTTP o TCP básico. Lambda usa el URI del oyente de telemetría para enviar datos de telemetría a su extensión. Para obtener más información, consulte [Creación de un oyente de telemetría](#telemetry-api-listener). 1. Mediante la API de suscripción de la API de telemetría, suscriba su extensión a los flujos de telemetría deseados. Necesitará el URI de su oyente de telemetría para este paso. Para obtener más información, consulte [Envío de una solicitud de suscripción a la API de telemetría](#telemetry-api-subscription). 1. Obtenga datos de telemetría de Lambda a través del oyente de telemetría. Puede realizar cualquier procesamiento personalizado de estos datos, como enviar los datos a Amazon S3 o a un servicio de observabilidad externo. **nota** El entorno de ejecución de una función de Lambda puede iniciarse y detenerse varias veces como parte de su [ciclo de vida](runtimes-extensions-api.md#runtimes-extensions-api-lifecycle). En general, el código de extensión se ejecuta durante las invocaciones de funciones y también hasta dos segundos durante la fase de apagado. Se recomienda agrupar la telemetría en lotes a medida que llegue al oyente. A continuación, utilice los eventos del ciclo de vida `Invoke` y `Shutdown` para enviar cada lote a los destinos que desee. ## Registro de sus extensiones Antes de poder suscribirse para recibir datos de telemetría, debe registrar su extensión de Lambda. El registro se produce durante la [fase de inicialización de la extensión](runtimes-extensions-api.md#runtimes-extensions-api-reg). En el siguiente ejemplo se muestra una solicitud HTTP para registrar una extensión. ``` POST http://${AWS_LAMBDA_RUNTIME_API}/2020-01-01/extension/register Lambda-Extension-Name: lambda_extension_name { 'events': [ 'INVOKE', 'SHUTDOWN'] } ``` Si la solicitud se realiza correctamente, el suscriptor recibe una respuesta correcta HTTP 200. El encabezado de la respuesta contiene el `Lambda-Extension-Identifier`. El cuerpo de respuesta contiene otras propiedades de la función. ``` HTTP/1.1 200 OK Lambda-Extension-Identifier: a1b2c3d4-5678-90ab-cdef-EXAMPLE11111 { "functionName": "lambda_function", "functionVersion": "$LATEST", "handler": "lambda_handler", "accountId": "123456789012" } ``` Para obtener más información, consulte [Referencia de la API de extensiones](runtimes-extensions-api.md#runtimes-extensions-registration-api). ## Creación de un oyente de telemetría La extensión de Lambda debe tener un oyente que gestione las solicitudes entrantes de la API de telemetría. En el siguiente código se muestra un ejemplo de implementación de un oyente de telemetría en Golang: ``` // Starts the server in a goroutine where the log events will be sent func (s *TelemetryApiListener) Start() (string, error) { address := listenOnAddress() l.Info("[listener:Start] Starting on address", address) s.httpServer = &http.Server{Addr: address} http.HandleFunc("/", s.http_handler) go func() { err := s.httpServer.ListenAndServe() if err != http.ErrServerClosed { l.Error("[listener:goroutine] Unexpected stop on Http Server:", err) s.Shutdown() } else { l.Info("[listener:goroutine] Http Server closed:", err) } }() return fmt.Sprintf("http://%s/", address), nil } // http_handler handles the requests coming from the Telemetry API. // Everytime Telemetry API sends log events, this function will read them from the response body // and put into a synchronous queue to be dispatched later. // Logging or printing besides the error cases below is not recommended if you have subscribed to // receive extension logs. Otherwise, logging here will cause Telemetry API to send new logs for // the printed lines which may create an infinite loop. func (s *TelemetryApiListener) http_handler(w http.ResponseWriter, r *http.Request) { body, err := ioutil.ReadAll(r.Body) if err != nil { l.Error("[listener:http_handler] Error reading body:", err) return } // Parse and put the log messages into the queue var slice []interface{} _ = json.Unmarshal(body, &slice) for _, el := range slice { s.LogEventsQueue.Put(el) } l.Info("[listener:http_handler] logEvents received:", len(slice), " LogEventsQueue length:", s.LogEventsQueue.Len()) slice = nil } ``` ## Especificación de un protocolo de destino Al suscribirse para recibir telemetría mediante la API de telemetría, puede especificar un protocolo de destino además del URI de destino: ``` { "destination": { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } } ``` Lambda acepta dos protocolos para recibir telemetría: + **HTTP (recomendado)**: Lambda entrega telemetría a un punto de conexión HTTP local (`http://sandbox.localdomain:${PORT}/${PATH}`) como una matriz de registros en formato JSON. El parámetro `$PATH` es opcional. Lambda solo admite HTTP, no HTTPS. Lambda ofrece telemetría a través de solicitudes POST. + **TCP**: Lambda entrega telemetría a un puerto TCP en [formato JSON delimitado por línea nueva (NDJSON)](https://github.com/ndjson/ndjson-spec). **nota** Recomendamos encarecidamente utilizar HTTP en lugar de TCP. Con TCP, la plataforma de Lambda no puede reconocer cuando la telemetría se entrega a la capa de aplicación. Por lo tanto, si su extensión se bloquea, puede perder la telemetría. HTTP no tiene esta limitación. Antes de suscribirse para recibir telemetría, establezca el oyente HTTP local o el puerto TCP. Durante la instalación, tenga en cuenta lo siguiente: + Lambda envía telemetría solo a destinos que se encuentran dentro del entorno de ejecución. + Lambda vuelve a intentar enviar telemetría (con retroceso) si no hay ningún oyente o si la solicitud POST encuentra un error. Si el oyente de telemetría se bloquea, continuará recibiendo telemetría después de que Lambda reinicie el entorno de ejecución. + Lambda reserva el puerto 9001. No hay otras restricciones ni recomendaciones sobre el número de puerto. ## Configuración del uso de memoria y el almacenamiento en búfer El uso de memoria en un entorno de ejecución aumenta de forma lineal con el número de suscriptores. Las suscripciones consumen recursos de memoria porque cada una abre un nuevo búfer de memoria para almacenar datos de telemetría. El uso de memoria del búfer cuenta para el consumo general de memoria en el entorno de ejecución. Al suscribirse para recibir telemetría mediante la API de telemetría, tiene la opción de almacenar en búfer los datos de telemetría y entregarlos a los suscriptores en lotes. Para optimizar el uso de memoria, puede especificar la configuración de almacenamiento en búfer: ``` { "buffering": { "maxBytes": 256*1024, "maxItems": 1000, "timeoutMs": 100 } } ``` | Parámetro | Descripción | Valores predeterminados y límites | | --- | --- | --- | | `maxBytes` | El volumen máximo de telemetría (en bytes) que se debe almacenar en memoria. | Predeterminado: 262 144 Mínimo: 262 144 Máximo: 1 048 576 | | `maxItems` | El número máximo de eventos que se deben almacenar en memoria. | Predeterminado: 10 000 Mínimo: 1000 Máximo: 10 000 | | `timeoutMs` | Tiempo máximo (en milisegundos) para almacenar en búfer un lote. | Predeterminado: 1000 Mínimo: 25 Máximo: 30 000 | Cuando configure el almacenamiento en búfer, tenga en cuenta lo siguiente: + Si alguno de los flujos de entrada está cerrado, Lambda vacía los registros. Esto puede suceder si, por ejemplo, se bloquea el tiempo de ejecución. + Cada suscriptor puede personalizar su configuración de almacenamiento en búfer en la solicitud de suscripción. + Cuando determine el tamaño del búfer para leer los datos, prevea recibir cargas tan grandes como `2 * maxBytes + metadataBytes`, donde `maxBytes` es un componente de su configuración de almacenamiento en búfer. Para calcular la cantidad de `metadataBytes` a tener en cuenta, revise los siguientes metadatos. Lambda agrega apéndices de metadatos similares a este a cada registro: ``` { "time": "2022-08-20T12:31:32.123Z", "type": "function", "record": "Hello World" } ``` + Si el suscriptor no puede procesar la telemetría entrante con la suficiente rapidez o su código de función genera un volumen muy alto de registro, Lambda podría soltar registros para mantener limitada la utilización de la memoria. Cuando esto ocurre, Lambda envía un evento `platform.logsDropped`. ## Envío de una solicitud de suscripción a la API de telemetría Las extensiones de Lambda pueden suscribirse para recibir datos de telemetría enviando una solicitud de suscripción a la API de telemetría. La solicitud de suscripción debe contener información sobre los tipos de eventos a los que quiere que se suscriba la extensión. Además, la solicitud puede contener [información sobre el destino de la entrega](#telemetry-api-destination) y una [configuración de almacenamiento en búfer](#telemetry-api-buffering). Antes de enviar una solicitud de suscripción, debe tener un ID de extensión (`Lambda-Extension-Identifier`). Cuando [registra su extensión con la API de extensiones](#telemetry-api-registration), obtiene un ID de extensión de la respuesta de la API. La suscripción se produce durante la [fase de inicialización de la extensión](runtimes-extensions-api.md#runtimes-extensions-api-reg). El siguiente ejemplo muestra una solicitud HTTP para suscribirse a los tres flujos de telemetría: telemetría de plataforma, registros de funciones y registros de extensiones. ``` PUT http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry HTTP/1.1 { "schemaVersion": "2025-01-29", "types": [ "platform", "function", "extension" ], "buffering": { "maxItems": 1000, "maxBytes": 256*1024, "timeoutMs": 100 }, "destination": { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } } ``` Si la solicitud se realiza correctamente, entonces el suscriptor recibe una respuesta correcta HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` ## Mensajes entrantes de la API de telemetría Tras suscribirse mediante la API de telemetría, una extensión comienza a recibir automáticamente la telemetría de Lambda mediante solicitudes POST. El cuerpo de cada solicitud POST contiene una matriz de objetos `Event`. Cada `Event` tiene el siguiente esquema: ``` { time: String, type: String, record: Object } ``` + La propiedad `time` define cuándo la plataforma Lambda generó el evento. Esto difiere de cuando ocurrió realmente el evento. El valor de la cadena de `time` es una marca de tiempo en formato ISO 8601. + La propiedad `type` define el tipo de evento. En la siguiente table se describen todos los posibles valores. + La propiedad `record` define un objeto JSON que contiene los datos de telemetría. El esquema de este objeto JSON depende del `type`. **Orden de eventos con invocaciones simultáneas** En el caso de las [instancias administradas de Lambda](lambda-managed-instances.md), las invocaciones de varias funciones se pueden ejecutar simultáneamente en el mismo entorno de ejecución. En este caso, el orden de los eventos de `platform.start` y `platform.report` no está garantizado entre distintas invocaciones simultáneas. Las extensiones deben gestionar los eventos de varias invocaciones que se ejecutan en paralelo y no deben adoptar un orden secuencial. Para atribuir correctamente los eventos a invocaciones específicas, las extensiones deben usar el campo de `requestId` presente en estos eventos de plataforma. Cada invocación tiene un identificador de solicitud único que permanece coherente en todos los eventos de esa invocación, lo que permite que las extensiones correlacionen los eventos correctamente, incluso cuando llegan fuera de orden. La siguiente tabla resume todos los tipos de objetos de `Event` y se enlaza con la [referencia del `Event` del esquema de la API de telemetría](telemetry-schema-reference.md) para cada tipo de evento. | Categoría | Tipo de evento | Descripción | Esquema de registro de eventos | | --- | --- | --- | --- | | Evento de plataforma | `platform.initStart` | Se inició la inicialización de la función. | esquema [`platform.initStart`](telemetry-schema-reference.md#platform-initStart) | | Evento de plataforma | `platform.initRuntimeDone` | Se completó la inicialización de la función. | esquema [`platform.initRuntimeDone`](telemetry-schema-reference.md#platform-initRuntimeDone) | | Evento de plataforma | `platform.initReport` | Un informe de inicialización de la función. | esquema [`platform.initReport`](telemetry-schema-reference.md#platform-initReport) | | Evento de plataforma | `platform.start` | Se inició la invocación de la función. | esquema [`platform.start`](telemetry-schema-reference.md#platform-start) | | Evento de plataforma | `platform.runtimeDone` | El tiempo de ejecución terminó de procesar un evento con éxito o con falla. | esquema [`platform.runtimeDone`](telemetry-schema-reference.md#platform-runtimeDone) | | Evento de plataforma | `platform.report` | Un informe de la invocación de funciones. | esquema [`platform.report`](telemetry-schema-reference.md#platform-report) | | Evento de plataforma | `platform.restoreStart` | Se inició la restauración en tiempo de ejecución. | esquema [`platform.restoreStart`](telemetry-schema-reference.md#platform-restoreStart) | | Evento de plataforma | `platform.restoreRuntimeDone` | Se completó la restauración en tiempo de ejecución. | esquema [`platform.restoreRuntimeDone`](telemetry-schema-reference.md#platform-restoreRuntimeDone) | | Evento de plataforma | `platform.restoreReport` | Informe de restauración en tiempo de ejecución. | esquema [`platform.restoreReport`](telemetry-schema-reference.md#platform-restoreReport) | | Evento de plataforma | `platform.telemetrySubscription` | La extensión suscrita a la API de telemetría. | esquema [`platform.telemetrySubscription`](telemetry-schema-reference.md#platform-telemetrySubscription) | | Evento de plataforma | `platform.logsDropped` | Lambda ha eliminado las entradas de registro. | esquema [`platform.logsDropped`](telemetry-schema-reference.md#platform-logsDropped) | | Registros de funciones | `function` | Una línea de registro del código de la función. | esquema [`function`](telemetry-schema-reference.md#telemetry-api-function) | | Registros de extensión | `extension` | Una línea de registro del código de extensión. | esquema [`extension`](telemetry-schema-reference.md#telemetry-api-extension) | # Referencia de la API de telemetría de Lambda Utilice el punto de conexión de la API de telemetría de Lambda para suscribir extensiones a los flujos de telemetría. Puede recuperar el punto de conexión de la API de telemetría desde la variable de entorno `AWS_LAMBDA_RUNTIME_API`. Para enviar una solicitud de API, agregue la versión de la API (`2022-07-01/`) y `telemetry/`. Por ejemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/ ``` Para ver la definición de la especificación OpenAPI (OAS) de la versión de respuestas de suscripción `2025-01-29`, consulte lo siguiente: + **HTTP**: [telemetry-api-http-schema.zip](samples/events_http_schema_v2025_01_29.zip) + **TCP**: [telemetry-api-tcp-schema.zip](samples/events_tcp_schema_v2025_01_29.zip) **Topics** + [ ## Suscribirse ](#telemetry-subscribe-api) ## Suscribirse Para suscribirse a un flujo de telemetría, una extensión de Lambda puede enviar una solicitud de API de suscripción. + **Ruta** – `/telemetry` + **Método** – `PUT` + **Encabezados** + `Content-Type`: `application/json` + **Parámetros del cuerpo de la solicitud** + **schemaVersion** + Obligatorio: sí + Tipo: cadena + Valores válidos: `"2025-01-29"`, `"2022-12-13"` o `"2022-07-01"` + **Nota:** Las instancias administradas de Lambda requieren `"2025-01-29"`. Esta versión es compatible con versiones anteriores de las funciones de Lambda (predeterminadas). + **destino**: los parámetros de configuración que definen el destino del evento de telemetría y el protocolo para la entrega del evento. + Obligatorio: sí + Tipo: objeto ``` { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } ``` + **protocolo**: el protocolo que utiliza Lambda para enviar datos de telemetría. + Obligatorio: sí + Tipo: cadena + Valores válidos: `"HTTP"`\$1`"TCP"` + **URI**: el URI al que se envían los datos de telemetría. + Obligatorio: sí + Tipo: cadena + Para obtener más información, consulte [Especificación de un protocolo de destino](telemetry-api.md#telemetry-api-destination). + **tipos**: los tipos de telemetría a los que desea que se suscriba la extensión. + Obligatorio: sí + Tipo: matriz de cadenas + Valores válidos: `"platform"`\$1`"function"`\$1`"extension"` + **almacenamiento en búfer**: los ajustes de configuración para el almacenamiento en búfer de eventos. + Obligatorio: no + Tipo: objeto ``` { "buffering": { "maxItems": 1000, "maxBytes": 256*1024, "timeoutMs": 100 } } ``` + **maxItems**: el número máximo de eventos que se deben almacenar en memoria. + Obligatorio: no + Tipo: número entero + Predeterminado: 1000 + Mínimo: 1000 + Máximo: 10 000 + **maxBytes**: el volumen máximo de telemetría (en bytes) que se debe almacenar en memoria. + Obligatorio: no + Tipo: número entero + Predeterminado: 262 144 + Mínimo: 262 144 + Máximo: 1 048 576 + **timeoutMs**: el tiempo máximo (en milisegundos) para almacenar en búfer un lote. + Obligatorio: no + Tipo: número entero + Predeterminado: 1000 + Mínimo: 25 + Máximo: 30 000 + Para obtener más información, consulte [Configuración del uso de memoria y el almacenamiento en búfer](telemetry-api.md#telemetry-api-buffering). ### Ejemplo de solicitud de API de suscripción ``` PUT http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry HTTP/1.1 { "schemaVersion": "2025-01-29", "types": [ "platform", "function", "extension" ], "buffering": { "maxItems": 1000, "maxBytes": 256*1024, "timeoutMs": 100 }, "destination": { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } } ``` Si la solicitud de suscripción se realiza correctamente, la extensión recibe una respuesta correcta HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` Si la suscripción falla, la extensión recibe una respuesta de error. Por ejemplo: ``` HTTP/1.1 400 OK { "errorType": "ValidationError", "errorMessage": "URI port is not provided; types should not be empty" } ``` Estos son algunos códigos de respuesta adicionales que puede recibir la extensión: + 200: solicitud completada correctamente + 202: solicitud aceptada. Respuesta a la solicitud de suscripción en un entorno de pruebas locales + 400: solicitud errónea + 500: error de servicio # Referencia del esquema `Event` de la API de telemetría de Lambda Utilice el punto de conexión de la API de telemetría de Lambda para suscribir extensiones a los flujos de telemetría. Puede recuperar el punto de conexión de la API de telemetría desde la variable de entorno `AWS_LAMBDA_RUNTIME_API`. Para enviar una solicitud de API, agregue la versión de la API (`2022-07-01/`) y `telemetry/`. Por ejemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/ ``` Para ver la definición de la especificación OpenAPI (OAS) de la versión de respuestas de suscripción `2025-01-29`, consulte lo siguiente: + **HTTP**: [telemetry-api-http-schema.zip](samples/events_http_schema_v2025_01_29.zip) + **TCP**: [telemetry-api-tcp-schema.zip](samples/events_tcp_schema_v2025_01_29.zip) La siguiente tabla resume de todos los tipos de objetos de `Event` que admite la API de telemetría. | Categoría | Tipo de evento | Descripción | Esquema de registro de eventos | | --- | --- | --- | --- | | Evento de plataforma | `platform.initStart` | Se inició la inicialización de la función. | esquema [`platform.initStart`](#platform-initStart) | | Evento de plataforma | `platform.initRuntimeDone` | Se completó la inicialización de la función. | esquema [`platform.initRuntimeDone`](#platform-initRuntimeDone) | | Evento de plataforma | `platform.initReport` | Un informe de inicialización de la función. | esquema [`platform.initReport`](#platform-initReport) | | Evento de plataforma | `platform.start` | Se inició la invocación de la función. | esquema [`platform.start`](#platform-start) | | Evento de plataforma | `platform.runtimeDone` | El tiempo de ejecución terminó de procesar un evento con éxito o con falla. | esquema [`platform.runtimeDone`](#platform-runtimeDone) | | Evento de plataforma | `platform.report` | Un informe de la invocación de funciones. | esquema [`platform.report`](#platform-report) | | Evento de plataforma | `platform.restoreStart` | Se inició la restauración en tiempo de ejecución. | esquema [`platform.restoreStart`](#platform-restoreStart) | | Evento de plataforma | `platform.restoreRuntimeDone` | Se completó la restauración en tiempo de ejecución. | esquema [`platform.restoreRuntimeDone`](#platform-restoreRuntimeDone) | | Evento de plataforma | `platform.restoreReport` | Informe de restauración en tiempo de ejecución. | esquema [`platform.restoreReport`](#platform-restoreReport) | | Evento de plataforma | `platform.telemetrySubscription` | La extensión suscrita a la API de telemetría. | esquema [`platform.telemetrySubscription`](#platform-telemetrySubscription) | | Evento de plataforma | `platform.logsDropped` | Lambda ha eliminado las entradas de registro. | esquema [`platform.logsDropped`](#platform-logsDropped) | | Registros de funciones | `function` | Una línea de registro del código de la función. | esquema [`function`](#telemetry-api-function) | | Registros de extensión | `extension` | Una línea de registro del código de extensión. | esquema [`extension`](#telemetry-api-extension) | **Contents** + [ ## Tipos de objetos `Event` de la API de telemetría ](#telemetry-api-events) + [ ### `platform.initStart` ](#platform-initStart) + [ ### `platform.initRuntimeDone` ](#platform-initRuntimeDone) + [ ### `platform.initReport` ](#platform-initReport) + [ ### `platform.start` ](#platform-start) + [ ### `platform.runtimeDone` ](#platform-runtimeDone) + [ ### `platform.report` ](#platform-report) + [ ### `platform.restoreStart` ](#platform-restoreStart) + [ ### `platform.restoreRuntimeDone` ](#platform-restoreRuntimeDone) + [ ### `platform.restoreReport` ](#platform-restoreReport) + [ ### `platform.extension` ](#platform-extension) + [ ### `platform.telemetrySubscription` ](#platform-telemetrySubscription) + [ ### `platform.logsDropped` ](#platform-logsDropped) + [ ### `function` ](#telemetry-api-function) + [ ### `extension` ](#telemetry-api-extension) + [ ## Tipos de objetos compartidos ](#telemetry-api-objects) + [ ### `InitPhase` ](#InitPhase) + [ ### `InitReportMetrics` ](#InitReportMetrics) + [ ### `InitType` ](#InitType) + [ ### `ReportMetrics` ](#ReportMetrics) + [ ### `RestoreReportMetrics` ](#RestoreReportMetrics) + [ ### `RuntimeDoneMetrics` ](#RuntimeDoneMetrics) + [ ### `Span` ](#Span) + [ ### `Status` ](#Status) + [ ### `TraceContext` ](#TraceContext) + [ ### `TracingType` ](#TracingType) ## Tipos de objetos `Event` de la API de telemetría En esta sección, se detallan los tipos de objetos `Event` que admite la API de telemetría de Lambda. En las descripciones de los eventos, un signo de interrogación (`?`) indica que el atributo puede no estar presente en el objeto. ### `platform.initStart` Un evento `platform.initStart` indica que se ha iniciado la fase de inicialización de la función. Un objeto `platform.initStart` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.initStart - record: PlatformInitStart ``` El objeto `PlatformInitStart` tiene los siguientes atributos: + **functionName** – `String` + **functionVersion**: `String` + **InitializationType**: objeto ``InitType`` + **instanceId?**: `String` + **instanceMaxMemory?**: `Integer` + **phase**: objeto ``InitPhase`` + **runtimeVersion?** – `String` + **runtimeVersionArn?** – `String` A continuación, se muestra un ejemplo de `Event` de tipo `platform.initStart`: ``` { "time": "2022-10-12T00:00:15.064Z", "type": "platform.initStart", "record": { "initializationType": "on-demand", "phase": "init", "runtimeVersion": "nodejs-14.v3", "runtimeVersionArn": "arn", "functionName": "myFunction", "functionVersion": "$LATEST", "instanceId": "82561ce0-53dd-47d1-90e0-c8f5e063e62e", "instanceMaxMemory": 256 } } ``` ### `platform.initRuntimeDone` Un evento `platform.initRuntimeDone` indica que se ha completado la fase de inicialización de la función. Un objeto `platform.initRuntimeDone` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.initRuntimeDone - record: PlatformInitRuntimeDone ``` El objeto `PlatformInitRuntimeDone` tiene los siguientes atributos: + **InitializationType**: objeto ``InitType`` + **phase**: objeto ``InitPhase`` + **status**: objeto ``Status`` + **spans?** Lista de objetos ``Span`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.initRuntimeDone`: ``` { "time": "2022-10-12T00:01:15.000Z", "type": "platform.initRuntimeDone", "record": { "initializationType": "on-demand" "status": "success", "spans": [ { "name": "someTimeSpan", "start": "2022-06-02T12:02:33.913Z", "durationMs": 70.5 } ] } } ``` ### `platform.initReport` Un evento `platform.initReport` contiene un informe general de la fase de inicialización de la función. Un objeto `platform.initReport` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.initReport - record: PlatformInitReport ``` El objeto `PlatformInitReport` tiene los siguientes atributos: + **errorType?**: cadena + **InitializationType**: objeto ``InitType`` + **phase**: objeto ``InitPhase`` + **metrics**: objeto ``InitReportMetrics`` + **spans?** Lista de objetos ``Span`` + **status**: objeto ``Status`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.initReport`: ``` { "time": "2022-10-12T00:01:15.000Z", "type": "platform.initReport", "record": { "initializationType": "on-demand", "status": "success", "phase": "init", "metrics": { "durationMs": 125.33 }, "spans": [ { "name": "someTimeSpan", "start": "2022-06-02T12:02:33.913Z", "durationMs": 90.1 } ] } } ``` ### `platform.start` Un evento `platform.start` indica que se ha iniciado la fase de invocación de la función. Un objeto `platform.start` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.start - record: PlatformStart ``` El objeto `PlatformStart` tiene los siguientes atributos: + **requestId** – `String` + **version?** – `String` + **tracing?** – ``TraceContext`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.start`: ``` { "time": "2022-10-12T00:00:15.064Z", "type": "platform.start", "record": { "requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa", "version": "$LATEST", "tracing": { "spanId": "54565fb41ac79632", "type": "X-Amzn-Trace-Id", "value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1" } } } ``` ### `platform.runtimeDone` Un evento `platform.runtimeDone` indica que se ha completado la fase de invocación de la función. Un objeto `platform.runtimeDone` `Event` tiene la siguiente forma: **Instancias administradas de Lambda** El evento de `platform.runtimeDone` no es compatible con las instancias administradas de Lambda. Las extensiones que se ejecuten en instancias administradas no recibirán este evento porque las extensiones no pueden suscribirse al evento de `INVOKE` en instancias administradas. Debido al modelo de ejecución simultánea, en el que se pueden procesar varias invocaciones simultáneamente, las extensiones no pueden realizar el procesamiento posterior a la invocación para las invocaciones individuales como lo hacen tradicionalmente en las funciones de Lambda (predeterminadas). En el caso de las instancias administradas, los intervalos de `responseLatency` y `responseDuration` que se incluyen en `platform.runtimeDone` normalmente están disponibles en el evento de `platform.report`. Para obtener más información, consulte [`platform.report`](#platform-report). ``` Event: Object - time: String - type: String = platform.runtimeDone - record: PlatformRuntimeDone ``` El objeto `PlatformRuntimeDone` tiene los siguientes atributos: + **errorType?** – `String` + **metrics?**: objeto ``RuntimeDoneMetrics`` + **requestId** – `String` + **status**: objeto ``Status`` + **spans?** Lista de objetos ``Span`` + **tracing?**: objeto ``TraceContext`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.runtimeDone`: ``` { "time": "2022-10-12T00:01:15.000Z", "type": "platform.runtimeDone", "record": { "requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa", "status": "success", "tracing": { "spanId": "54565fb41ac79632", "type": "X-Amzn-Trace-Id", "value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1" }, "spans": [ { "name": "someTimeSpan", "start": "2022-08-02T12:01:23:521Z", "durationMs": 80.0 } ], "metrics": { "durationMs": 140.0, "producedBytes": 16 } } } ``` ### `platform.report` Un evento `platform.report` contiene un informe general de la fase de invocación de la función. Un objeto `platform.report` `Event` tiene la siguiente forma: **Instancias administradas de Lambda** El evento de `platform.report` de las instancias administradas de Lambda tiene métricas e intervalos diferentes en comparación con las funciones de Lambda (predeterminadas). En el caso de instancias administradas: **Intervalos**: contiene `responseLatency` y `responseDuration` en lugar de `extensionOverhead`. El intervalo `extensionOverhead` no está disponible porque las extensiones no pueden suscribirse al evento de `INVOKE` en las instancias administradas debido al modelo de ejecución simultánea. **Métricas**: solo incluye `durationMs`. No se incluyen las siguientes métricas: `billedDurationMs`, `initDurationMs`, `maxMemoryUsedMB` y `memorySizeMB`. Estas métricas por invocación no son aplicables en el entorno de ejecución simultánea. Para las métricas de utilización de recursos, utilice [Supervisión de instancias de administración de Lambda](lambda-managed-instances-monitoring.md) [Lambda Insights](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-insights.html). ``` Event: Object - time: String - type: String = platform.report - record: PlatformReport ``` El objeto `PlatformReport` tiene los siguientes atributos: + **metrics**: objeto ``ReportMetrics`` + **requestId** – `String` + **spans?** Lista de objetos ``Span`` + **status**: objeto ``Status`` + **tracing?**: objeto ``TraceContext`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.report`: ``` { "time": "2022-10-12T00:01:15.000Z", "type": "platform.report", "record": { "metrics": { "billedDurationMs": 694, "durationMs": 693.92, "initDurationMs": 397.68, "maxMemoryUsedMB": 84, "memorySizeMB": 128 }, "requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa", } } ``` ### `platform.restoreStart` Un evento `platform.restoreStart` indica que se inició un evento de restauración del entorno de funciones. En un evento de restauración del entorno, Lambda crea el entorno a partir de una instantánea almacenada en caché en lugar de inicializarlo desde cero. Para obtener más información, consulte [Lambda SnapStart](snapstart.md). Un objeto `platform.restoreStart` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.restoreStart - record: PlatformRestoreStart ``` El objeto `PlatformRestoreStart` tiene los siguientes atributos: + **functionName** – `String` + **functionVersion** – `String` + **instanceId?** – `String` + **instanceMaxMemory?** – `String` + **runtimeVersion?** – `String` + **runtimeVersionArn?** – `String` A continuación, se muestra un ejemplo de `Event` de tipo `platform.restoreStart`: ``` { "time": "2022-10-12T00:00:15.064Z", "type": "platform.restoreStart", "record": { "runtimeVersion": "nodejs-14.v3", "runtimeVersionArn": "arn", "functionName": "myFunction", "functionVersion": "$LATEST", "instanceId": "82561ce0-53dd-47d1-90e0-c8f5e063e62e", "instanceMaxMemory": 256 } } ``` ### `platform.restoreRuntimeDone` Un evento `platform.restoreRuntimeDone` indica que se completó un evento de restauración del entorno de funciones. En un evento de restauración del entorno, Lambda crea el entorno a partir de una instantánea almacenada en caché en lugar de inicializarlo desde cero. Para obtener más información, consulte [Lambda SnapStart](snapstart.md). Un objeto `platform.restoreRuntimeDone` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.restoreRuntimeDone - record: PlatformRestoreRuntimeDone ``` El objeto `PlatformRestoreRuntimeDone` tiene los siguientes atributos: + **errorType?** – `String` + **spans?** Lista de objetos ``Span`` + **status**: objeto ``Status`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.restoreRuntimeDone`: ``` { "time": "2022-10-12T00:00:15.064Z", "type": "platform.restoreRuntimeDone", "record": { "status": "success", "spans": [ { "name": "someTimeSpan", "start": "2022-08-02T12:01:23:521Z", "durationMs": 80.0 } ] } } ``` ### `platform.restoreReport` Un evento `platform.restoreReport` contiene un informe general de un evento de restauración de funciones. Un objeto `platform.restoreReport` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.restoreReport - record: PlatformRestoreReport ``` El objeto `PlatformRestoreReport` tiene los siguientes atributos: + **errorType?**: cadena + **metrics?**: objeto ``RestoreReportMetrics`` + **spans?** Lista de objetos ``Span`` + **status**: objeto ``Status`` A continuación, se muestra un ejemplo de `Event` de tipo `platform.restoreReport`: ``` { "time": "2022-10-12T00:00:15.064Z", "type": "platform.restoreReport", "record": { "status": "success", "metrics": { "durationMs": 15.19 }, "spans": [ { "name": "someTimeSpan", "start": "2022-08-02T12:01:23:521Z", "durationMs": 30.0 } ] } } ``` ### `platform.extension` Un evento `extension` contiene registros del código de extensión. Un objeto `extension` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = extension - record: {} ``` El objeto `PlatformExtension` tiene los siguientes atributos: + **events**: Lista de `String` + **name** – `String` + **state** – `String` A continuación, se muestra un ejemplo de `Event` de tipo `platform.extension`: ``` { "time": "2022-10-12T00:02:15.000Z", "type": "platform.extension", "record": { "events": [ "INVOKE", "SHUTDOWN" ], "name": "my-telemetry-extension", "state": "Ready" } } ``` ### `platform.telemetrySubscription` Un evento `platform.telemetrySubscription` contiene información sobre una suscripción de extensión. Un objeto `platform.telemetrySubscription` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.telemetrySubscription - record: PlatformTelemetrySubscription ``` El objeto `PlatformTelemetrySubscription` tiene los siguientes atributos: + **name** – `String` + **state** – `String` + **types**: lista de `String` A continuación, se muestra un ejemplo de `Event` de tipo `platform.telemetrySubscription`: ``` { "time": "2022-10-12T00:02:35.000Z", "type": "platform.telemetrySubscription", "record": { "name": "my-telemetry-extension", "state": "Subscribed", "types": [ "platform", "function" ] } } ``` ### `platform.logsDropped` Un evento `platform.logsDropped` contiene información sobre los eventos eliminados. Lambda emite el evento `platform.logsDropped` cuando una función genera registros a una velocidad demasiado alta para que Lambda los procese. Cuando Lambda no puede enviar registros a CloudWatch o a la extensión suscripta a la API de telemetría a la velocidad a la que su función los produce, elimina los registros para evitar que la ejecución de la función se ralentice. Un objeto `platform.logsDropped` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = platform.logsDropped - record: PlatformLogsDropped ``` El objeto `PlatformLogsDropped` tiene los siguientes atributos: + **droppedBytes** – `Integer` + **droppedRecords** – `Integer` + **reason** – `String` A continuación, se muestra un ejemplo de `Event` de tipo `platform.logsDropped`: ``` { "time": "2022-10-12T00:02:35.000Z", "type": "platform.logsDropped", "record": { "droppedBytes": 12345, "droppedRecords": 123, "reason": "Some logs were dropped because the downstream consumer is slower than the logs production rate" } } ``` ### `function` Un evento `function` contiene registros del código de la función. Un objeto `function` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = function - record: {} ``` El formato del campo `record` depende de si los registros de la función están formateados en texto sin formato o en formato JSON. Para obtener más información sobre las opciones de configuración del formato de registro, consulte [Configuración de los formatos de registro JSON y de texto sin formato](monitoring-cloudwatchlogs-logformat.md) El siguiente es un ejemplo de `Event` de un tipo `function` en el que el formato de registro es texto sin formato: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "function", "record": "[INFO] Hello world, I am a function!" } ``` El siguiente es un ejemplo de `Event` de un tipo `function` en el que el formato de registro es texto en formato JSON: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "function", "record": { "timestamp": "2022-10-12T00:03:50.000Z", "level": "INFO", "requestId": "79b4f56e-95b1-4643-9700-2807f4e68189", "message": "Hello world, I am a function!" } } ``` **nota** Si la versión del esquema que está utilizando es anterior a la versión `2022-12-13`, entonces `"record"` siempre se representa como una cadena, incluso cuando el formato de registro de la función esté configurado como JSON. Para las instancias administradas de Lambda, debe utilizar la versión de esquema `2025-01-29`. ### `extension` Un evento `extension` contiene registros del código de extensión. Un objeto `extension` `Event` tiene la siguiente forma: ``` Event: Object - time: String - type: String = extension - record: {} ``` El formato del campo `record` depende de si los registros de la función están formateados en texto sin formato o en formato JSON. Para obtener más información sobre las opciones de configuración del formato de registro, consulte [Configuración de los formatos de registro JSON y de texto sin formato](monitoring-cloudwatchlogs-logformat.md) El siguiente es un ejemplo de `Event` de un tipo `extension` en el que el formato de registro es texto sin formato: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "extension", "record": "[INFO] Hello world, I am an extension!" } ``` El siguiente es un ejemplo de `Event` de un tipo `extension` en el que el formato de registro es texto en formato JSON: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "extension", "record": { "timestamp": "2022-10-12T00:03:50.000Z", "level": "INFO", "requestId": "79b4f56e-95b1-4643-9700-2807f4e68189", "message": "Hello world, I am an extension!" } } ``` **nota** Si la versión del esquema que está utilizando es anterior a la versión `2022-12-13`, entonces `"record"` siempre se representa como una cadena, incluso cuando el formato de registro de la función esté configurado como JSON. Para las instancias administradas de Lambda, debe utilizar la versión de esquema `2025-01-29`. ## Tipos de objetos compartidos En esta sección, se detallan los tipos de objetos compartidos que admite la API de telemetría de Lambda. ### `InitPhase` Una enumeración de la cadena que describe la fase en la que se produce el paso de inicialización. En la mayoría de los casos, Lambda ejecuta el código de inicialización de la función durante la fase `init`. Sin embargo, en algunos casos de error, Lambda puede volver a ejecutar el código de inicialización de la función durante la fase `invoke`. (Esto se denomina *inicio suprimido*). + **Tipo** – `String` + **Valores válidos** – `init`\$1`invoke`\$1`snap-start` ### `InitReportMetrics` Un objeto que contiene métricas sobre una fase de inicialización. + **Tipo** – `Object` Un objeto `InitReportMetrics` tiene la siguiente forma: ``` InitReportMetrics: Object - durationMs: Double ``` A continuación, se muestra un ejemplo de objeto `InitReportMetrics`: ``` { "durationMs": 247.88 } ``` ### `InitType` Una enumeración de la cadena que describe cómo Lambda inicializó el entorno. + **Tipo** – `String` + **Valores válidos** – `on-demand`\$1`provisioned-concurrency` ### `ReportMetrics` Un objeto que contiene métricas sobre una fase completa. + **Tipo** – `Object` Un objeto `ReportMetrics` tiene la siguiente forma: ``` ReportMetrics: Object - billedDurationMs: Integer - durationMs: Double - initDurationMs?: Double - maxMemoryUsedMB: Integer - memorySizeMB: Integer - restoreDurationMs?: Double ``` A continuación, se muestra un ejemplo de objeto `ReportMetrics`: ``` { "billedDurationMs": 694, "durationMs": 693.92, "initDurationMs": 397.68, "maxMemoryUsedMB": 84, "memorySizeMB": 128 } ``` ### `RestoreReportMetrics` Un objeto que contiene métricas sobre una fase de restauración completa. + **Tipo** – `Object` Un objeto `RestoreReportMetrics` tiene la siguiente forma: ``` RestoreReportMetrics: Object - durationMs: Double ``` A continuación, se muestra un ejemplo de objeto `RestoreReportMetrics`: ``` { "durationMs": 15.19 } ``` ### `RuntimeDoneMetrics` Un objeto que contiene métricas sobre una fase de invocación completa. + **Tipo** – `Object` Un objeto `RuntimeDoneMetrics` tiene la siguiente forma: ``` RuntimeDoneMetrics: Object - durationMs: Double - producedBytes?: Integer ``` A continuación, se muestra un ejemplo de objeto `RuntimeDoneMetrics`: ``` { "durationMs": 200.0, "producedBytes": 15 } ``` ### `Span` Un objeto que contiene detalles acerca de un intervalo. Un intervalo representa una unidad de trabajo u operación en un seguimiento. Para obtener más información sobre intervalos, consulte [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) en la página de la **API de seguimiento** del sitio web de OpenTelemetry Docs. Lambda admite los siguientes intervalos para el evento `platform.RuntimeDone`: + El intervalo `responseLatency` describe cuánto tiempo tardó la función de Lambda en empezar a enviar la respuesta. + El intervalo `responseDuration` describe cuánto tiempo tardó la función de Lambda en terminar de enviar toda la respuesta. + El intervalo `runtimeOverhead` describe cuánto tiempo tardó el tiempo de ejecución de Lambda en indicar que estaba listo para procesar la siguiente invocación de la función. Este es el tiempo que tardó el tiempo de ejecución en llamar a la API de [siguiente invocación](runtimes-api.md#runtimes-api-next) para obtener el siguiente evento después de devolver la respuesta de su función. A continuación, se muestra un ejemplo de objeto de intervalo `responseLatency`: ``` { "name": "responseLatency", "start": "2022-08-02T12:01:23.521Z", "durationMs": 23.02 } ``` ### `Status` Un objeto que describe el estado de una fase de inicialización o invocación. Si el estado es `failure` o `error`, el objeto `Status` también contiene un campo `errorType` que describe el error. + **Tipo** – `Object` + **Valores de estado válidos** – `success`\$1`failure`\$1`error`\$1`timeout` ### `TraceContext` Un objeto que describe las propiedades de un seguimiento. + **Tipo** – `Object` Un objeto `TraceContext` tiene la siguiente forma: ``` TraceContext: Object - spanId?: String - type: TracingType enum - value: String ``` A continuación, se muestra un ejemplo de objeto `TraceContext`: ``` { "spanId": "073a49012f3c312e", "type": "X-Amzn-Trace-Id", "value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1" } ``` ### `TracingType` Una enumeración de la cadena que describe el tipo de seguimiento de un objeto ``TraceContext``. + **Tipo** – `String` + **Valores válidos** – `X-Amzn-Trace-Id` # Conversión de objetos `Event` de la API de telemetría de Lambda en OpenTelemetry Spans El esquema de la API de telemetría AWS Lambda es semánticamente compatible con OpenTelemetry (OTel). Esto significa que puede convertir sus objetos `Event` de la API de telemetría AWS Lambda en OpenTelemetry (OTel) Spans. Al realizar la conversión, no debe asignar un solo objeto de `Event` a un solo OTel Span. En su lugar, debe presentar los tres eventos relacionados con una fase del ciclo de vida en un solo OTel Span. Por ejemplo, los eventos `start`, `runtimeDone` y `runtimeReport` representan una sola invocación de función. Presente estos tres eventos como un solo OTel Span. Puede convertir sus eventos mediante Span Events o Child Spans (agrupados). Las tablas de esta página describen las asignaciones entre las propiedades del esquema de la API de telemetría y las propiedades de OTel Span para ambos enfoques. Para obtener más información sobre OTel Spans, consulte [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) en la página de la **API de seguimiento** del sitio web de OpenTelemetry Docs. **Topics** + [ ## Mapeo de OTel Spans con Span Events ](#telemetry-otel-span-events) + [ ## Mapeo de OTel Spans con Child Spans ](#telemetry-otel-child-spans) ## Mapeo de OTel Spans con Span Events En las siguientes tablas, `e` representa el evento que proviene del origen de telemetría. **Mapeo de los eventos \$1Start** | OpenTelemetry | Esquema de la API de telemetría de Lambda | | --- | --- | | `Span.Name` | Su extensión genera este valor en función del campo `type`. | | `Span.StartTime` | Utilice `e.time`. | | `Span.EndTime` | N/D, porque el evento aún no se ha completado. | | `Span.Kind` | Establece en `Server`. | | `Span.Status` | Establece en `Unset`. | | `Span.TraceId` | Analice el encabezado AWS X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `TraceId`. | | `Span.ParentId` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Parent`. | | `Span.SpanId` | Utilice `e.tracing.spanId` si está disponible. De lo contrario, genere un nuevo `SpanId`. | | `Span.SpanContext.TraceState` | N/D para un contexto de seguimiento de X-Ray. | | `Span.SpanContext.TraceFlags` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Sampled`. | | `Span.Attributes` | Su extensión puede agregar aquí cualquier valor personalizado. | **Mapeo de los eventos \$1RuntimeDone** | OpenTelemetry | Esquema de la API de telemetría de Lambda | | --- | --- | | `Span.Name` | Su extensión genera el valor en función del campo `type`. | | `Span.StartTime` | Utilice `e.time` desde el evento coincidente `*Start`. Para otras opciones, consulte `e.time - e.metrics.durationMs`. | | `Span.EndTime` | N/D, porque el evento aún no se ha completado. | | `Span.Kind` | Establezca en `Server`. | | `Span.Status` | S i`e.status` no es igual a `success`, entonces configúrelo en `Error`. De lo contrario, establézcala en `Ok`. | | `Span.Events[]` | Utilice `e.spans[]`. | | `Span.Events[i].Name` | Utilice `e.spans[i].name`. | | `Span.Events[i].Time` | Utilice `e.spans[i].start`. | | `Span.TraceId` | Analice el encabezado AWS X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `TraceId`. | | `Span.ParentId` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Parent`. | | `Span.SpanId` | Use el mismo `SpanId` del evento `*Start`. Si no está disponible, entonces utilice `e.tracing.spanId` o genere un nuevo `SpanId`. | | `Span.SpanContext.TraceState` | N/D para un contexto de seguimiento de X-Ray. | | `Span.SpanContext.TraceFlags` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Sampled`. | | `Span.Attributes` | Su extensión puede agregar aquí cualquier valor personalizado. | **Mapeo de los eventos \$1Report** | OpenTelemetry | Esquema de la API de telemetría de Lambda | | --- | --- | | `Span.Name` | Su extensión genera el valor en función del campo `type`. | | `Span.StartTime` | Utilice `e.time` desde el evento coincidente `*Start`. Para otras opciones, consulte `e.time - e.metrics.durationMs`. | | `Span.EndTime` | Utilice `e.time`. | | `Span.Kind` | Establezca en `Server`. | | `Span.Status` | Usa el mismo valor que el evento `*RuntimeDone`. | | `Span.TraceId` | Analice el encabezado AWS X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `TraceId`. | | `Span.ParentId` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Parent`. | | `Span.SpanId` | Use el mismo `SpanId` del evento `*Start`. Si no está disponible, entonces utilice `e.tracing.spanId` o genere un nuevo `SpanId`. | | `Span.SpanContext.TraceState` | N/D para un contexto de seguimiento de X-Ray. | | `Span.SpanContext.TraceFlags` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Sampled`. | | `Span.Attributes` | Su extensión puede agregar aquí cualquier valor personalizado. | ## Mapeo de OTel Spans con Child Spans En la siguiente tabla se describe cómo convertir los eventos de la API de telemetría de Lambda en OTel Spans con Child Spans (agrupados) para los Spans `*RuntimeDone`. Para las asignaciones de `*Start` y `*Report`, consulte las tablas en [Mapeo de OTel Spans con Span Events](#telemetry-otel-span-events), ya que son las mismas para Child Spans. En esta tabla, `e` representa el evento que proviene del origen de telemetría. **Mapeo de los eventos \$1RuntimeDone** | OpenTelemetry | Esquema de la API de telemetría de Lambda | | --- | --- | | `Span.Name` | Su extensión genera el valor en función del campo `type`. | | `Span.StartTime` | Utilice `e.time` desde el evento coincidente `*Start`. Para otras opciones, consulte `e.time - e.metrics.durationMs`. | | `Span.EndTime` | N/D, porque el evento aún no se ha completado. | | `Span.Kind` | Establezca en `Server`. | | `Span.Status` | S i`e.status` no es igual a `success`, entonces configúrelo en `Error`. De lo contrario, establézcala en `Ok`. | | `Span.TraceId` | Analice el encabezado AWS X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `TraceId`. | | `Span.ParentId` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Parent`. | | `Span.SpanId` | Use el mismo `SpanId` del evento `*Start`. Si no está disponible, entonces utilice `e.tracing.spanId` o genere un nuevo `SpanId`. | | `Span.SpanContext.TraceState` | N/D para un contexto de seguimiento de X-Ray. | | `Span.SpanContext.TraceFlags` | Analice el encabezado X-Ray que se encuentra en `e.tracing.value` y, a continuación, use el valor `Sampled`. | | `Span.Attributes` | Su extensión puede agregar aquí cualquier valor personalizado. | | `ChildSpan[i].Name` | Utilice `e.spans[i].name`. | | `ChildSpan[i].StartTime` | Utilice `e.spans[i].start`. | | `ChildSpan[i].EndTime` | Utilice `e.spans[i].start + e.spans[i].durations`. | | `ChildSpan[i].Kind` | Igual que el `Span.Kind` principal. | | `ChildSpan[i].Status` | Igual que el `Span.Status` principal. | | `ChildSpan[i].TraceId` | Igual que el `Span.TraceId` principal. | | `ChildSpan[i].ParentId` | Utilice el `Span.SpanId` principal. | | `ChildSpan[i].SpanId` | Genere una nueva `SpanId`. | | `ChildSpan[i].SpanContext.TraceState` | N/D para un contexto de seguimiento de X-Ray. | | `ChildSpan[i].SpanContext.TraceFlags` | Igual que el `Span.SpanContext.TraceFlags` principal. | # Uso de la API de registros de Lambda **importante** La API de telemetría de Lambda reemplaza a la API de registros de Lambda. **Si bien la API de registros sigue siendo completamente funcional, recomendamos utilizar solo la API de telemetría en el futuro.** Puede suscribir su extensión a una transmisión de telemetría mediante la API de telemetría o la API de registros. Tras suscribirse mediante una de estas API, cualquier intento de suscribirse mediante la otra API volverá a causar un error. **Las instancias administradas de Lambda no admiten la API de registros.** Las instancias administradas de Lambda no admiten la API de registros. Si utiliza funciones de instancias administradas, utilice la [API de telemetría](telemetry-api.md) en su lugar. La API de telemetría proporciona capacidades mejoradas para recopilar y procesar datos de telemetría de las funciones de Lambda. Lambda captura automáticamente los registros de tiempo de ejecución y los transmite a Amazon CloudWatch. Esta secuencia de registro contiene los registros que generan el código de función y las extensiones, así como los registros que genera Lambda como parte de la invocación de la función. [Las extensiones Lambda](runtimes-extensions-api.md) pueden usar la API de registros de tiempo de ejecución de Lambda para suscribirse a flujos de registro directamente desde el [entorno de ejecución](lambda-runtime-environment.md). Lambda transfiere los registros a la extensión y la extensión puede procesar, filtrar y enviar los registros a cualquier destino preferido. ![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/logs-api-concept-diagram.png) La API Logs permite que las extensiones se suscriban a tres flujos de registros diferentes: + Registros de funciones que la función de Lambda genera y escribe en `stdout` o `stderr`. + La extensión registra que genera el código de extensión. + Registros de plataforma de Lambda en los que se registran eventos y errores relacionados con invocaciones y extensiones. **nota** Lambda envía todos los registros a CloudWatch, incluso cuando una extensión se suscribe a una o más de los flujos de registro. **Topics** + [ ## Suscribirse para recibir registros ](#runtimes-logs-api-subscribing) + [ ## Uso de memoria ](#runtimes-logs-api-memory) + [ ## Protocolos de destino ](#runtimes-logs-api-dest) + [ ## Configuración de almacenamiento en búfer ](#runtimes-logs-api-buffering) + [ ## Ejemplo de suscripción ](#runtimes-logs-api-subs-example) + [ ## Código de ejemplo para Logs API ](#runtimes-logs-api-samples) + [ ## Referencia de la API de registros ](#runtimes-logs-api-ref) + [ ## Mensajes de registro ](#runtimes-logs-api-msg) ## Suscribirse para recibir registros Una extensión de Lambda puede suscribirse para recibir registros enviando una solicitud de suscripción a la API de registros. Para suscribirse para recibir registros, necesita el identificador de extensión (`Lambda-Extension-Identifier`). Primero [registre la extensión](runtimes-extensions-api.md#extensions-registration-api-a) para recibir el identificador de extensión. A continuación, suscríbase a la API de registros durante [la inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib). Una vez finalizada la fase de inicialización, Lambda no procesa las solicitudes de suscripción. **nota** La suscripción a la API de registros es idempotente. Las solicitudes de suscripción duplicadas no dan lugar a suscripciones duplicadas. ## Uso de memoria El uso de memoria aumenta linealmente a medida que aumenta el número de suscriptores. Las suscripciones consumen recursos de memoria porque cada suscripción abre un nuevo búfer de memoria para almacenar los registros. Para ayudar a optimizar el uso de memoria, puede ajustar la [configuración de almacenamiento en búfer](#runtimes-logs-api-buffering). El uso de memoria del búfer cuenta para el consumo general de memoria en el entorno de ejecución. ## Protocolos de destino Puede elegir uno de los siguientes protocolos para recibir los registros: 1. **HTTP** (recomendado): Lambda entrega registros a un punto de enlace HTTP local (`http://sandbox.localdomain:${PORT}/${PATH}`) como una matriz de registros en formato JSON. El parámetro `$PATH` es opcional. Tenga en cuenta que solo se admite HTTP, no HTTPS. Puede optar por recibir registros a través de PUT o POST. 1. **TCP**: Lambda entrega registros a un puerto TCP en [formato JSON delimitado por línea nueva (NDJSON)](https://github.com/ndjson/ndjson-spec). Recomendamos utilizar HTTP en lugar de TCP. Con TCP, la plataforma de Lambda no puede reconocer cuando los registros se entregan a la capa de aplicación. Por lo tanto, puede perder registros si su extensión se bloquea. HTTP no comparte esta limitación. También recomendamos configurar el agente de escucha HTTP local o el puerto TCP antes de suscribirse para recibir registros. Durante la instalación, tenga en cuenta lo siguiente: + Lambda envía registros solo a destinos que se encuentran dentro del entorno de ejecución. + Lambda intenta volver a enviar los registros (con retroceso) si no hay ningún agente de escucha o si la solicitud POST o PUT da como resultado un error. Si el suscriptor del registro se bloquea, continuará recibiendo registros después de que Lambda reinicie el entorno de ejecución. + Lambda reserva el puerto 9001. No hay otras restricciones ni recomendaciones sobre el número de puerto. ## Configuración de almacenamiento en búfer Lambda puede almacenar en búfer los registros y entregarlos al suscriptor. Puede configurar este comportamiento en la solicitud de suscripción al especificar los siguientes campos opcionales: Tenga en cuenta que Lambda utiliza el valor predeterminado para cualquier campo que no especifique. + **timeoutMs**: el tiempo máximo (en milisegundos) para almacenar en búfer un lote. Predeterminado: 1000. Mínimo: 25 Máximo: 30 000. + **maxBytes**: el tamaño máximo (en bytes) de los registros que se deben almacenar en memoria. Predeterminado: 262 144. Mínimo: 262 144 Máximo: 1 048 576 + **maxItems**: el número máximo de eventos que se deben almacenar en memoria. Predeterminado: 10 000. Mínimo: 1000. Máximo: 10 000. Durante la configuración del almacenamiento en búfer, tenga en cuenta los siguientes puntos: + Lambda vacía los registros si alguno de los flujos de entrada está cerrado, por ejemplo, si el tiempo de ejecución se bloquea. + Cada suscriptor puede especificar una configuración de almacenamiento en búfer diferente en la solicitud de suscripción. + Considere el tamaño del búfer que necesita para leer los datos. Espere recibir cargas útiles tan grandes como `2*maxBytes+metadata`, donde `maxBytes` está configurado en la solicitud de suscripción. Por ejemplo, Lambda agrega los siguientes bytes de metadatos a cada registro: ``` { "time": "2020-08-20T12:31:32.123Z", "type": "function", "record": "Hello World" } ``` + Si el suscriptor no puede procesar los registros entrantes con la suficiente rapidez, Lambda podría soltar registros para mantener limitada la utilización de la memoria. Para indicar el número de registros eliminados, Lambda envía un registro `platform.logsDropped`. Para obtener más información, consulte [Lambda: no aparecen todos los registros de mi función](troubleshooting-execution.md#troubleshooting-execution-missinglogs). ## Ejemplo de suscripción En el siguiente ejemplo se muestra una solicitud para suscribirse a los registros de la plataforma y de las funciones. ``` PUT http://${AWS_LAMBDA_RUNTIME_API}/2020-08-15/logs HTTP/1.1 { "schemaVersion": "2020-08-15", "types": [ "platform", "function" ], "buffering": { "maxItems": 1000, "maxBytes": 262144, "timeoutMs": 100 }, "destination": { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080/lambda_logs" } } ``` Si la solicitud se realiza correctamente, el suscriptor recibe una respuesta correcta HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` ## Código de ejemplo para Logs API Para obtener un código de ejemplo que muestra cómo enviar registros a un destino personalizado, consulte [Uso de extensiones de AWS Lambda para enviar registros a destinos personalizados](https://aws.amazon.com/blogs/compute/using-aws-lambda-extensions-to-send-logs-to-custom-destinations/) en el blog de informática de AWS. Para ver ejemplos de código de Python and Go que muestran cómo desarrollar una extensión básica de Lambda y suscribirse a la API de registros, consulte [Extensiones de AWS Lambda](https://github.com/aws-samples/aws-lambda-extensions) en el repositorio de ejemplos de AWS de GitHub. Para obtener más información sobre cómo crear una extensión de Lambda, consulte [Utilice la API de las extensiones de Lambda para crear extensiones](runtimes-extensions-api.md). ## Referencia de la API de registros Puede recuperar el extremo de la API de registros desde la variable de entorno `AWS_LAMBDA_RUNTIME_API`. Para enviar una solicitud de API, utilice el prefijo `2020-08-15/` antes de la ruta de la API. Por ejemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2020-08-15/logs ``` La especificación OpenAPI para la solicitud de suscripción de registros de la API, versión **2020-08-15**, está disponible aquí: [logs-api-request.zip](samples/logs-api-request.zip) ### Suscribirse Para suscribirse a una o más de los flujos de registro que están disponibles en el entorno de ejecución de Lambda, las extensiones envían una solicitud de Suscribe API. **Ruta** – `/logs` **Método**: **PUT** **Body parameters (Parámetros del cuerpo** `destination` – consulte [Protocolos de destino](#runtimes-logs-api-dest). Requerido: sí. Tipo: cadenas. `buffering` – consulte [Configuración de almacenamiento en búfer](#runtimes-logs-api-buffering). Obligatorio: no Tipo: cadenas. `types`: matriz de los tipos de registros que se deben recibir. Requerido: sí. Tipo: matriz de cadenas. Valores válidos: «plataforma», «función», «extensión». `schemaVersion`: Obligatorio: no. Valor predeterminado: “2020-08-15”. Establezca el valor en "2021-03-18" para que la extensión reciba mensajes [`platform.runtimeDone`](#runtimes-logs-api-ref-done). ****Parámetros de respuesta**** Las especificaciones de OpenAPI para las respuestas de suscripción, versión **2020-08-15**, están disponibles para protocolos HTTP y TCP: + HTTP: [logs-api-http-response.zip](samples/logs-api-http-response.zip) + TCP: [logs-api-tcp-response.zip](samples/logs-api-tcp-response.zip) ****Códigos de respuesta**** + 200: solicitud completada correctamente + 202: solicitud aceptada. Respuesta a una solicitud de suscripción durante las pruebas locales. + 4XX: solicitud errónea + 500: error de servicio Si la solicitud se realiza correctamente, el suscriptor recibe una respuesta correcta HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` Si la solicitud falla, el suscriptor recibe una respuesta de error. Por ejemplo: ``` HTTP/1.1 400 OK { "errorType": "Logs.ValidationError", "errorMessage": URI port is not provided; types should not be empty" } ``` ## Mensajes de registro La API Logs permite que las extensiones se suscriban a tres flujos de registros diferentes: + Función: registros que la función de Lambda genera y escribe en `stdout` o `stderr`. + Extensión: los registros de extensión generados por el código de extensión. + Plataforma: registros de la plataforma generados por la plataforma de tiempo de ejecución, en los que se registran eventos y errores relacionados con invocaciones y extensiones. **Topics** + [ ### Registros de funciones ](#runtimes-logs-api-msg-function) + [ ### Registros de extensión ](#runtimes-logs-api-msg-extension) + [ ### Registros de plataforma ](#runtimes-logs-api-msg-platform) ### Registros de funciones La función de Lambda y las extensiones internas generan registros de funciones y los escriben en `stdout` o `stderr`. En el ejemplo siguiente, se muestra el formato de un mensaje de registro de función. \$1 "time": "2020-08-20T12:31:32.123Z", "type": "function", "record": "ERROR encountered. Stack trace:\$1n\$1my-function (line 10)\$1n" \$1 ### Registros de extensión Las extensiones pueden generar registros de extensión. El formato de registro es el mismo que para un registro de función. ### Registros de plataforma Lambda genera mensajes de registro para eventos de plataforma como `platform.start`, `platform.end` y `platform.fault`. Opcionalmente, puede suscribirse a la versión **2021-03-18** del esquema de la API de registros, que incluye el mensaje de registro `platform.runtimeDone`. #### Ejemplo de mensajes de registros de plataforma: En el siguiente ejemplo, se muestran los registros de inicio y final de registro de la plataforma. Estos registros indican la hora de inicio de la invocación y la hora de finalización de la invocación que especifica el requestId. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.start", "record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56"} } { "time": "2020-08-20T12:31:32.123Z", "type": "platform.end", "record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56"} } ``` El mensaje de registro **Platform.IniRuntimeDone** muestra el estado de la subfase `Runtime init`, que forma parte de [la fase del ciclo de vida de Init](lambda-runtime-environment.md#runtimes-lifecycle-ib). Cuando `Runtime init` tiene éxito, el tiempo de ejecución envía una solicitud de API `/next` en tiempo de ejecución (para los tipos de inicialización `on-demand` y `provisioned-concurrency`) o `restore/next` (para el tipo de inicialización `snap-start`). El siguiente ejemplo muestra un mensaje de registro de **Platform.IniRuntimeDone** correcto para el tipo de inicialización `snap-start`. ``` { "time":"2022-07-17T18:41:57.083Z", "type":"platform.initRuntimeDone", "record":{ "initializationType":"snap-start", "status":"success" } } ``` El mensaje de registro **Platform.initReport** muestra cuánto duró la fase `Init` y cuántos milisegundos se le facturaron durante esta fase. Cuando el tipo de inicialización es `provisioned-concurrency`, Lambda envía este mensaje durante la invocación. Cuando el tipo de inicialización es `snap-start`, Lambda envía este mensaje después de restaurar la imagen instantánea. El siguiente ejemplo muestra un mensaje de registro de **Platform.IniRuntimeDone** para el tipo de inicialización `snap-start`. ``` { "time":"2022-07-17T18:41:57.083Z", "type":"platform.initReport", "record":{ "initializationType":"snap-start", "metrics":{ "durationMs":731.79, "billedDurationMs":732 } } } ``` El registro de informes de plataforma incluye métricas sobre la invocación que especifica el requestId. El campo `initDurationMs` se incluye en el registro solamente si la invocación incluye un inicio en frío. Si el seguimiento AWS X-Ray está activo, el registro incluye metadatos de X-Ray. En el siguiente ejemplo se muestra un registro de informes de plataforma para una invocación que incluyó un inicio en frío. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.report", "record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56", "metrics": {"durationMs": 101.51, "billedDurationMs": 300, "memorySizeMB": 512, "maxMemoryUsedMB": 33, "initDurationMs": 116.67 } } } ``` El registro de la plataforma captura errores de tiempo de ejecución o del entorno de ejecución. En el siguiente ejemplo se muestra un mensaje de registro de errores de la plataforma. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.fault", "record": "RequestId: d783b35e-a91d-4251-af17-035953428a2c Process exited before completing request" } ``` **nota** AWS está implementando cambios en el servicio Lambda. Debido a estos cambios, es posible que vea pequeñas diferencias entre la estructura y el contenido de los mensajes de registro del sistema y los segmentos de rastro emitidos por diferentes funciones de Lambda en su Cuenta de AWS. Uno de los resultados de registro afectados por este cambio es el campo `"record"` de registro de errores de la plataforma. Los siguientes ejemplos muestran campos `"record"` ilustrativos en los formatos antiguo y nuevo. El nuevo estilo de registro de errores contiene un mensaje más conciso Estos cambios se implementarán en las próximas semanas y todas las funciones de todas las Regiones de AWS, excepto en las regiones de China y GovCloud, pasarán a utilizar el nuevo formato de mensajes de registro y segmentos de rastro. **Example registro de errores de la plataforma (estilo antiguo)** ``` "record":"RequestId: ...\tError: Runtime exited with error: exit status 255\nRuntime.ExitError" ``` **Example registro de errores de la plataforma (estilo nuevo)** ``` "record":"RequestId: ... Status: error\tErrorType: Runtime.ExitError" ``` Lambda genera un registro de extensión de plataforma cuando una extensión se registra con la API de extensiones. En el siguiente ejemplo, se muestra un mensaje de registro de errores de la plataforma. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.extension", "record": {"name": "Foo.bar", "state": "Ready", "events": ["INVOKE", "SHUTDOWN"] } } ``` Lambda genera un registro de suscripción de registros de plataforma cuando una extensión se suscribe a la API de registros. En el ejemplo siguiente, se muestra un mensaje de registro de suscripción. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.logsSubscription", "record": {"name": "Foo.bar", "state": "Subscribed", "types": ["function", "platform"], } } ``` Lambda genera un registro de registros eliminados de la plataforma cuando una extensión no puede procesar el número de registros que recibe. En el siguiente ejemplo se muestra un mensaje de registro `platform.logsDropped`. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.logsDropped", "record": {"reason": "Consumer seems to have fallen behind as it has not acknowledged receipt of logs.", "droppedRecords": 123, "droppedBytes" 12345 } } ``` El mensaje de registro **Platform.RestoRestart** muestra la hora en que se inició la fase `Restore` (solo el tipo de inicialización `snap-start`). Ejemplo: ``` { "time":"2022-07-17T18:43:44.782Z", "type":"platform.restoreStart", "record":{} } ``` El mensaje de registro **Platform.initReport** muestra cuánto duró la fase `Restore` y cuántos milisegundos se le facturaron durante esta fase (solo el tipo de inicialización `snap-start`). Ejemplo: ``` { "time":"2022-07-17T18:43:45.936Z", "type":"platform.restoreReport", "record":{ "metrics":{ "durationMs":70.87, "billedDurationMs":13 } } } ``` #### Mensajes `runtimeDone` de la plataforma Si establece la versión del esquema en "2021-03-18" en la solicitud de suscripción, Lambda envía un mensaje `platform.runtimeDone` después de que la invocación de la función se complete correctamente o presente un error. La extensión puede utilizar este mensaje para detener toda la recopilación de telemetría para esta invocación de función. La especificación OpenAPI para el tipo de evento de registro en la versión de esquema **2021-03-18** está disponible aquí: [schema-2021-03-18.zip](samples/schema-2021-03-18.zip) Lambda genera el mensaje de registro `platform.runtimeDone` cuando el tiempo de ejecución envía una solicitud `Next` o `Error` de la API de tiempo de ejecución. El registro `platform.runtimeDone` informa a los consumidores de registros de la API que la invocación de función se completa. Las extensiones pueden utilizar esta información para decidir cuándo enviar toda la telemetría recopilada durante esa invocación. ##### Ejemplos Lambda envía el mensaje `platform.runtimeDone` después de que el tiempo de ejecución envía la solicitud NEXT cuando se completa la invocación de la función. Los ejemplos siguientes muestran mensajes para cada uno de los valores de estado: éxito, error y tiempo de espera agotado. **Example Ejemplo de mensaje de éxito** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "success" } } ``` **Example Ejemplo de mensaje de error** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "failure" } } ``` **Example Ejemplo de mensaje de tiempo de espera agotado** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "timeout" } } ``` **Example Ejemplo de mensaje Platform.RestoreUntimeDone (solo tipo de inicialización `snap-start`)** El mensaje de registro **Platform.RestoreUntimeDone** muestra si la fase se realizó `Restore` correctamente o no. Lambda envía este mensaje cuando el tiempo de ejecución envía una solicitud de API `restore/next` de tiempo de ejecución. Hay tres estados posibles: éxito, error y tiempo de espera agotado. En el ejemplo siguiente se muestra un mensaje de registro de **Platform.RestoreRuntimeDone** correcto. ``` { "time":"2022-07-17T18:43:45.936Z", "type":"platform.restoreRuntimeDone", "record":{ "status":"success" } } ```