# Acessar dados de telemetria em tempo real para extensões usando a API Telemetria A API de Telemetria permite que as extensões recebam dados de telemetria diretamente do Lambda. Durante a inicialização e a invocação da função, o Lambda captura automaticamente a telemetria, incluindo logs, métricas de plataforma e rastreamentos de plataforma. A API de telemetria permite que as extensões acessem esses dados de telemetria diretamente no Lambda e quase em tempo real. No ambiente de execução do Lambda, você pode inscrever as extensões do Lambda em fluxos de telemetria. Após a inscrição, o Lambda transmite automaticamente todos os dados de telemetria para as extensões. Você então tem a flexibilidade de processar, filtrar e despachar os dados para o destino de sua preferência, como um bucket do Amazon Simple Storage Service (Amazon S3) ou um provedor externo de ferramentas de observabilidade. O diagrama a seguir mostra como a API de extensões e a API de telemetria conectam extensões ao Lambda no ambiente de execução. Além disso, a API de runtime conecta o seu runtime e a função ao Lambda. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/telemetry-api-concept-diagram.png) **Importante** A API de telemetria do Lambda substitui a API de logs do Lambda. **Embora a API de logs permaneça totalmente funcional, recomendamos usar apenas a API de telemetria daqui para frente.** É possível inscrever sua extensão em um fluxo de telemetria usando a API de telemetria ou a API de logs. Após se inscrever usando uma dessas APIs, qualquer tentativa de se inscrever usando a outra API retornará um erro. **Requisito de versão do esquema de instâncias gerenciadas do Lambda** As instâncias gerenciadas do Lambda oferecem suporte somente à versão `2025-01-29` do esquema da API de telemetria. Ao assinar fluxos de telemetria para funções de instância gerenciada, você **deve** usar `"schemaVersion": "2025-01-29"` em sua solicitação de assinatura. O uso de versões anteriores do esquema resultará na rejeição de eventos pelo Lambda. A versão `2025-01-29` do esquema é compatível com versões anteriores e pode ser usada com instâncias gerenciadas do Lambda e funções do Lambda (padrão). Recomendamos usar essa versão para todas as novas extensões para garantir a compatibilidade entre os dois modelos de implantação. As extensões podem usar a API de telemetria para se inscrever em três fluxos de telemetria diferentes: + **Telemetria de plataforma**: logs, métricas e rastreamentos que descrevem eventos e erros relacionados ao ciclo de vida de runtime do ambiente de execução, ao ciclo de vida de extensão e às invocações de função. + **Logs de função**: logs personalizados gerados pelo código da função do Lambda. + **Logs de extensão**: logs personalizados gerados pelo código de extensão do Lambda. **nota** O Lambda enviará logs e métricas para o CloudWatch e rastreará para o X-Ray (se você ativou o rastreamento), mesmo que uma extensão assine fluxos de telemetria. **Topics** + [ ## Criação de extensões usando a API de telemetria ](#telemetry-api-creating-extensions) + [ ## Como registrar sua extensão ](#telemetry-api-registration) + [ ## Como criar um receptor de telemetria ](#telemetry-api-listener) + [ ## Como especificar um protocolo de destino ](#telemetry-api-destination) + [ ## Como configurar o uso de memória e o armazenamento em buffer ](#telemetry-api-buffering) + [ ## Como enviar uma solicitação de assinatura para a API de telemetria ](#telemetry-api-subscription) + [ ## Mensagens da API de telemetria de entrada ](#telemetry-api-messages) + [ # Referência da API de Telemetria do Lambda ](telemetry-api-reference.md) + [ # Referência de esquema para `Event` da API de Telemetria do Lambda ](telemetry-schema-reference.md) + [ # Conversão de objetos `Event` da API de Telemetria do Lambda em spans do OpenTelemetry ](telemetry-otel-spans.md) + [ # Usar a API de logs do Lambda ](runtimes-logs-api.md) ## Criação de extensões usando a API de telemetria As extensões do Lambda são executadas como processos independentes no ambiente de execução. As extensões podem continuar sendo executadas após a conclusão da invocação da função. Como as extensões são processos separados, é possível escrevê-las em uma linguagem diferente do código da função. Recomendamos a gravação de extensões usando uma linguagem compilada, como Golang ou Rust. Dessa forma, a extensão corresponde a um binário independente que pode ser compatível com qualquer runtime com suporte. O diagrama a seguir ilustra um processo de quatro etapas para a criação de uma extensão que recebe e processa dados de telemetria usando a API de telemetria. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/telemetry-api-creation-steps.png) Veja a seguir cada etapa com mais detalhes: 1. Registre sua extensão usando a [Usar a API de extensões do Lambda para criar extensões](runtimes-extensions-api.md). Isso fornece um `Lambda-Extension-Identifier`, que você precisará para as etapas a seguir. Para obter mais informações sobre como registrar sua extensão, consulte [Como registrar sua extensão](#telemetry-api-registration). 1. Crie um receptor de telemetria. Pode ser um servidor HTTP ou TCP comum. O Lambda usa o URI do receptor de telemetria para enviar dados de telemetria para a extensão. Para obter mais informações, consulte [Como criar um receptor de telemetria](#telemetry-api-listener). 1. Use a API de inscrição na API de telemetria para inscrever a extensão nos fluxos de telemetria desejados. Você precisará do URI do receptor de telemetria para esta etapa. Para obter mais informações, consulte [Como enviar uma solicitação de assinatura para a API de telemetria](#telemetry-api-subscription). 1. Obtenha os dados de telemetria do Lambda por meio do receptor de telemetria. É possível fazer qualquer processamento personalizado desses dados, como enviar os dados para o Amazon S3 ou para um serviço de observabilidade externo. **nota** O ambiente de execução de uma função do Lambda pode ser iniciado e interrompido diversas vezes como parte de seu [ciclo de vida](runtimes-extensions-api.md#runtimes-extensions-api-lifecycle). Em geral, o código de extensão é executado durante as invocações de função e também por até dois segundos durante a fase de desligamento. Recomendamos processar a telemetria em lotes à medida que ela chegar ao receptor. Em seguida, use os eventos de ciclo de vida `Invoke` e `Shutdown` para enviar cada lote aos destinos desejados. ## Como registrar sua extensão Antes de se inscrever em dados de telemetria, você deve registrar a extensão do Lambda. O registro ocorre durante a [fase de inicialização da extensão](runtimes-extensions-api.md#runtimes-extensions-api-reg). O exemplo a seguir mostra uma solicitação HTTP para registrar uma extensão. ``` POST http://${AWS_LAMBDA_RUNTIME_API}/2020-01-01/extension/register Lambda-Extension-Name: lambda_extension_name { 'events': [ 'INVOKE', 'SHUTDOWN'] } ``` Se o pedido for bem-sucedido, o assinante receberá uma resposta de êxito HTTP 200. O cabeçalho de resposta contém o `Lambda-Extension-Identifier`. O corpo de resposta contém outras propriedades da função. ``` HTTP/1.1 200 OK Lambda-Extension-Identifier: a1b2c3d4-5678-90ab-cdef-EXAMPLE11111 { "functionName": "lambda_function", "functionVersion": "$LATEST", "handler": "lambda_handler", "accountId": "123456789012" } ``` Para obter mais informações, consulte a [Referência de API de extensões](runtimes-extensions-api.md#runtimes-extensions-registration-api). ## Como criar um receptor de telemetria Sua extensão do Lambda deve ter um receptor que processe as solicitações recebidas da API de telemetria. O código a seguir mostra um exemplo de implementação de receptor de telemetria em 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 } ``` ## Como especificar um protocolo de destino Ao se inscrever para receber telemetria usando a API de telemetria, é possível especificar um protocolo de destino além do URI de destino: ``` { "destination": { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } } ``` O Lambda aceita dois protocolos para o recebimento de telemetria: + **HTTP (recomendado)**: o Lambda fornece telemetria para um endpoint HTTP local (`http://sandbox.localdomain:${PORT}/${PATH}`) como uma matriz de registros no formato JSON. O parâmetro `$PATH` é opcional. O Lambda oferece suporte somente para HTTP, não para HTTPS. O Lambda fornece telemetria por meio de solicitações POST. + **TCP**: o Lambda fornece telemetria para uma porta TCP no [formato Newline delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec). **nota** Recomendamos fortemente o uso de HTTP em vez de TCP. Com o TCP, a plataforma do Lambda não reconhece que a telemetria é entregue à camada da aplicação. Portanto, se sua extensão falhar, você poderá perder a telemetria. O HTTP não tem essa limitação. Antes de se inscrever para receber telemetria, estabeleça o receptor HTTP ou a porta TCP local. Durante a configuração, observe o seguinte: + O Lambda envia telemetria somente para destinos que estão dentro do ambiente de execução. + O Lambda tenta novamente enviar telemetria (com recuo) na ausência de um receptor ou se a solicitação POST encontrar algum erro. Se o receptor de telemetria apresentar falhas, ele continuará a receber telemetria depois que o Lambda reiniciar o ambiente de execução. + Lambda reserva porto 9001. Não há outras restrições ou recomendações de número de porta. ## Como configurar o uso de memória e o armazenamento em buffer O uso de memória em um ambiente de execução cresce linearmente com o número de assinantes. As assinaturas consomem recursos de memória porque cada assinatura abre um novo buffer de memória para armazenar dados de telemetria. O uso da memória buffer contribui para o consumo geral de memória no ambiente de execução. Ao se inscrever para receber telemetria usando a API de telemetria, você tem a opção de armazenar em buffer os dados de telemetria e entregá-los aos assinantes em lotes. Para otimizar o uso da memória, é possível especificar uma configuração de armazenamento em buffer: ``` { "buffering": { "maxBytes": 256*1024, "maxItems": 1000, "timeoutMs": 100 } } ``` | Parameter | Descrição | Padrões e limites | | --- | --- | --- | | `maxBytes` | O volume máximo de telemetria (em bytes) para armazenar em buffer na memória. | Padrão: 262.144 Mínimo: 262.144 Máximo: 1.048.576 | | `maxItems` | O número máximo de eventos para armazenar em buffer na memória. | Padrão: 10.000 Mínimo: 1.000 Máximo: 10.000. | | `timeoutMs` | O tempo máximo (em milissegundos) para armazenar em buffer um lote. | Padrão: 1.000 Mínimo: 25 Máximo: 30.000 | Ao configurar o buffer, lembre-se dos seguintes pontos: + Se algum dos fluxos de entrada estiver fechado, o Lambda liberará os logs. Por exemplo, isso pode acontecer se o runtime apresentar falhas. + Cada assinante pode personalizar a configuração de buffer durante a solicitação de assinatura. + Ao determinar o tamanho do buffer para ler os dados, preveja o recebimento de cargas úteis tão grandes quanto `2 * maxBytes + metadataBytes`, em que `maxBytes` é um componente da configuração de buffer. Para avaliar a quantidade de `metadataBytes` a ser considerada, analise os metadados a seguir. O Lambda anexa metadados semelhantes a este para cada registro: ``` { "time": "2022-08-20T12:31:32.123Z", "type": "function", "record": "Hello World" } ``` + Se o assinante não puder processar a telemetria de entrada com rapidez suficiente ou se o código da sua função gerar um volume de log muito alto, o Lambda poderá descartar registros para manter a utilização da memória limitada. Quando isso ocorre, o Lambda envia um evento `platform.logsDropped`. ## Como enviar uma solicitação de assinatura para a API de telemetria As extensões do Lambda podem se inscrever para receber dados de telemetria enviando uma solicitação de assinatura para a API de telemetria. A solicitação de assinatura deve conter informações sobre os tipos de eventos que você deseja que a extensão assine. Além disso, a solicitação pode conter [informações do destino de entrega](#telemetry-api-destination) e uma [configuração de armazenamento em buffer](#telemetry-api-buffering). Antes de enviar uma solicitação de assinatura, você deve ter um ID de extensão (`Lambda-Extension-Identifier`). Ao [registrar sua extensão na API de extensões](#telemetry-api-registration), você obtém um ID de extensão a partir da resposta da API. A assinatura ocorre durante a [fase de inicialização da extensão](runtimes-extensions-api.md#runtimes-extensions-api-reg). O exemplo a seguir mostra uma solicitação HTTP para assinar todos os três fluxos de telemetria: telemetria de plataforma, logs de função e logs de extensão. ``` 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" } } ``` Se a solicitação tiver êxito, o assinante receberá uma resposta de êxito HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` ## Mensagens da API de telemetria de entrada Depois de se inscrever usando a API de telemetria, uma extensão começa automaticamente a receber telemetria do Lambda por meio de solicitações POST. Cada corpo de solicitação POST contém uma matriz de objetos `Event`. Cada `Event` tem o seguinte esquema: ``` { time: String, type: String, record: Object } ``` + A propriedade `time` define quando a plataforma do Lambda gerou o evento. Isso é diferente de quando o evento realmente ocorreu. O valor da string `time` é um carimbo de data/hora no formato ISO 8601. + A propriedade `type` define o tipo de evento. A tabela a seguir descreve todos os valores possíveis. + A propriedade `record` define um objeto JSON que contém os dados de telemetria. O esquema desse objeto JSON depende do arquivo `type`. **Ordenação de eventos com invocações simultâneas** Em [Instâncias gerenciadas do Lambda](lambda-managed-instances.md), várias invocações de função podem ser executadas simultaneamente no mesmo ambiente de execução. Nesse caso, a ordem dos eventos `platform.start` e `platform.report` não é garantida entre diferentes invocações simultâneas. As extensões devem lidar com eventos de várias invocações executadas em paralelo e não devem assumir uma ordenação sequencial. Para atribuir eventos adequadamente a invocações específicas, as extensões devem usar o campo `requestId` presente nesses eventos da plataforma. Cada invocação tem um ID de solicitação exclusivo que permanece consistente em todos os eventos dessa invocação, permitindo que as extensões correlacionem os eventos corretamente mesmo quando eles chegam fora de ordem. A tabela a seguir resume todos os tipos de objetos `Event` e apresenta links para a [referência de esquema `Event` da API de telemetria](telemetry-schema-reference.md) para cada tipo de evento. | Categoria | Tipo de evento | Descrição | Esquema de registro de evento | | --- | --- | --- | --- | | Evento de plataforma | `platform.initStart` | A inicialização da função foi iniciada. | Esquema [`platform.initStart`](telemetry-schema-reference.md#platform-initStart) | | Evento de plataforma | `platform.initRuntimeDone` | A inicialização da função foi concluída. | Esquema [`platform.initRuntimeDone`](telemetry-schema-reference.md#platform-initRuntimeDone) | | Evento de plataforma | `platform.initReport` | Um relatório sobre a inicialização da função. | Esquema [`platform.initReport`](telemetry-schema-reference.md#platform-initReport) | | Evento de plataforma | `platform.start` | A invocação da função foi iniciada. | Esquema [`platform.start`](telemetry-schema-reference.md#platform-start) | | Evento de plataforma | `platform.runtimeDone` | O runtime concluiu o processamento de um evento com êxito ou com falha. | Esquema [`platform.runtimeDone`](telemetry-schema-reference.md#platform-runtimeDone) | | Evento de plataforma | `platform.report` | Um relatório sobre a invocação de função. | Esquema [`platform.report`](telemetry-schema-reference.md#platform-report) | | Evento de plataforma | `platform.restoreStart` | A restauração do runtime foi iniciada. | Esquema [`platform.restoreStart`](telemetry-schema-reference.md#platform-restoreStart) | | Evento de plataforma | `platform.restoreRuntimeDone` | A restauração do runtime foi concluída. | Esquema [`platform.restoreRuntimeDone`](telemetry-schema-reference.md#platform-restoreRuntimeDone) | | Evento de plataforma | `platform.restoreReport` | Relatório de restauração do runtime. | Esquema [`platform.restoreReport`](telemetry-schema-reference.md#platform-restoreReport) | | Evento de plataforma | `platform.telemetrySubscription` | A extensão foi inscrita na API de telemetria. | Esquema [`platform.telemetrySubscription`](telemetry-schema-reference.md#platform-telemetrySubscription) | | Evento de plataforma | `platform.logsDropped` | O Lambda descartou entradas de log. | Esquema [`platform.logsDropped`](telemetry-schema-reference.md#platform-logsDropped) | | Logs de função | `function` | Uma linha de log do código da função. | Esquema [`function`](telemetry-schema-reference.md#telemetry-api-function) | | Logs de extensões | `extension` | Uma linha de log do código de extensão. | Esquema [`extension`](telemetry-schema-reference.md#telemetry-api-extension) | # Referência da API de Telemetria do Lambda Use o endpoint da API de Telemetria do Lambda para assinar extensões para fluxos de telemetria. É possível recuperar o endpoint da API de telemetria da variável de ambiente `AWS_LAMBDA_RUNTIME_API`. Para enviar uma solicitação de API, vincule a versão da API (`2022-07-01/`) e `telemetry/`. Por exemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/ ``` Para obter a definição da Especificação OpenAPI (OAS) da versão das respostas de assinatura `2025-01-29`, consulte os itens a seguir: + **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** + [ ## Assinar ](#telemetry-subscribe-api) ## Assinar Para assinar um fluxo de telemetria, uma extensão do Lambda pode enviar uma solicitação para a API de assinatura. + **Caminho** – `/telemetry` + **Method** (Método): `PUT` + **Cabeçalhos** + `Content-Type`: `application/json` + **Parâmetros do corpo da solicitação** + **schemaVersion** + Obrigatório: Sim + Tipo: string + Valores válidos: `"2025-01-29"`, `"2022-12-13"` ou `"2022-07-01"` + **Observação:** as instâncias gerenciadas do Lambda exigem `"2025-01-29"`. Esta versão é compatível com versões anteriores das funções do Lambda (padrão). + **destination** (destino): as configurações que definem o destino do evento de telemetria e o protocolo para a entrega do evento. + Obrigatório: sim + Tipo: Objeto ``` { "protocol": "HTTP", "URI": "http://sandbox.localdomain:8080" } ``` + **protocol** (protocolo): o protocolo usado pelo Lambda para enviar dados de telemetria. + Obrigatório: Sim + Tipo: string + Valores válidos: `"HTTP"`\$1`"TCP"` + **URI**: o URI para o qual os dados de telemetria serão enviados. + Obrigatório: Sim + Tipo: string + Para obter mais informações, consulte [Como especificar um protocolo de destino](telemetry-api.md#telemetry-api-destination). + **types** (tipos): os tipos de telemetria que você deseja que a extensão assine. + Obrigatório: sim + Tipo: matriz de strings + Valores válidos: `"platform"`\$1`"function"`\$1`"extension"` + **buffering** (armazenamento em buffer): as configurações definidas para o armazenamento em buffer de eventos. + Obrigatório: não + Tipo: Objeto ``` { "buffering": { "maxItems": 1000, "maxBytes": 256*1024, "timeoutMs": 100 } } ``` + **maxItems**: o número máximo de eventos a serem colocados em buffer na memória. + Obrigatório: não + Tipo: inteiro + Padrão: 1.000 + Mínimo: 1.000 + Máximo: 10.000. + **maxBytes**: o volume máximo de telemetria (em bytes) para armazenar em buffer na memória. + Obrigatório: não + Tipo: inteiro + Padrão: 262.144 + Mínimo: 262.144 + Máximo: 1.048.576 + **timeoutMs**: o tempo máximo (em milissegundos) para colocar um lote em buffer. + Obrigatório: não + Tipo: inteiro + Padrão: 1.000 + Mínimo: 25 + Máximo: 30.000 + Para obter mais informações, consulte [Como configurar o uso de memória e o armazenamento em buffer](telemetry-api.md#telemetry-api-buffering). ### Exemplo de solicitação para a API de assinatura ``` 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" } } ``` Se a solicitação de assinatura obtiver êxito, a extensão receberá uma resposta de êxito HTTP 200: ``` HTTP/1.1 200 OK "OK" ``` Se a solicitação de assinatura falhar, a extensão receberá uma resposta de erro. Por exemplo: ``` HTTP/1.1 400 OK { "errorType": "ValidationError", "errorMessage": "URI port is not provided; types should not be empty" } ``` Veja a seguir alguns códigos de resposta adicionais que a extensão pode receber: + 200: solicitação concluída com êxito + 202: solicitação aceita. Resposta à solicitação de assinatura no ambiente de teste local. + 400: solicitação inválida. + 500: erro do serviço # Referência de esquema para `Event` da API de Telemetria do Lambda Use o endpoint da API de Telemetria do Lambda para assinar extensões para fluxos de telemetria. É possível recuperar o endpoint da API de telemetria da variável de ambiente `AWS_LAMBDA_RUNTIME_API`. Para enviar uma solicitação de API, vincule a versão da API (`2022-07-01/`) e `telemetry/`. Por exemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/ ``` Para obter a definição da Especificação OpenAPI (OAS) da versão das respostas de assinatura `2025-01-29`, consulte os itens a seguir: + **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) A tabela a seguir é um resumo de todos os tipos de objetos `Event` aos quais a API de telemetria oferece suporte. | Categoria | Tipo de evento | Descrição | Esquema de registro de evento | | --- | --- | --- | --- | | Evento de plataforma | `platform.initStart` | A inicialização da função foi iniciada. | Esquema [`platform.initStart`](#platform-initStart) | | Evento de plataforma | `platform.initRuntimeDone` | A inicialização da função foi concluída. | Esquema [`platform.initRuntimeDone`](#platform-initRuntimeDone) | | Evento de plataforma | `platform.initReport` | Um relatório sobre a inicialização da função. | Esquema [`platform.initReport`](#platform-initReport) | | Evento de plataforma | `platform.start` | A invocação da função foi iniciada. | Esquema [`platform.start`](#platform-start) | | Evento de plataforma | `platform.runtimeDone` | O runtime concluiu o processamento de um evento com êxito ou com falha. | Esquema [`platform.runtimeDone`](#platform-runtimeDone) | | Evento de plataforma | `platform.report` | Um relatório sobre a invocação de função. | Esquema [`platform.report`](#platform-report) | | Evento de plataforma | `platform.restoreStart` | A restauração do runtime foi iniciada. | Esquema [`platform.restoreStart`](#platform-restoreStart) | | Evento de plataforma | `platform.restoreRuntimeDone` | A restauração do runtime foi concluída. | Esquema [`platform.restoreRuntimeDone`](#platform-restoreRuntimeDone) | | Evento de plataforma | `platform.restoreReport` | Relatório de restauração do runtime. | Esquema [`platform.restoreReport`](#platform-restoreReport) | | Evento de plataforma | `platform.telemetrySubscription` | A extensão foi inscrita na API de telemetria. | Esquema [`platform.telemetrySubscription`](#platform-telemetrySubscription) | | Evento de plataforma | `platform.logsDropped` | O Lambda descartou entradas de log. | Esquema [`platform.logsDropped`](#platform-logsDropped) | | Logs de função | `function` | Uma linha de log do código da função. | Esquema [`function`](#telemetry-api-function) | | Logs de extensões | `extension` | Uma linha de log do código de extensão. | Esquema [`extension`](#telemetry-api-extension) | **Contents** + [ ## Tipos de objeto `Event` da API de telemetria ](#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 compartilhados ](#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 objeto `Event` da API de telemetria Esta seção detalha os tipos de objetos `Event` aos quais a API de Telemetria do Lambda oferece suporte. Nas descrições dos eventos, um ponto de interrogação (`?`) indica que o atributo pode não estar presente no objeto. ### `platform.initStart` Um evento `platform.initStart` indica que a fase de inicialização da função foi iniciada. Um objeto `Event` `platform.initStart` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.initStart - record: PlatformInitStart ``` O objeto `PlatformInitStart` tem os seguintes atributos: + **functionName** – `String` + **functionVersion**: `String` + **initializationType**: objeto ``InitType`` + **instanceId?**: `String` + **instanceMaxMemory?**: `Integer` + **phase** (fase): objeto ``InitPhase`` + **runtimeVersion?** – `String` + **runtimeVersionArn?** – `String` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.initRuntimeDone` indica que a fase de inicialização da função foi concluída. Um objeto `Event` `platform.initRuntimeDone` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.initRuntimeDone - record: PlatformInitRuntimeDone ``` O objeto `PlatformInitRuntimeDone` tem os seguintes atributos: + **initializationType**: objeto ``InitType`` + **phase** (fase): objeto ``InitPhase`` + **status**: objeto ``Status`` + **spans?** : lista de objetos ``Span`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.initReport` contém um relatório geral da fase de inicialização da função. Um objeto `Event` `platform.initReport` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.initReport - record: PlatformInitReport ``` O objeto `PlatformInitReport` tem os seguintes atributos: + **errorType?**: string + **initializationType**: objeto ``InitType`` + **phase** (fase): objeto ``InitPhase`` + **metrics** (métricas): objeto ``InitReportMetrics`` + **spans?** : lista de objetos ``Span`` + **status**: objeto ``Status`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.start` indica que a fase de invocação da função foi iniciada. Um objeto `Event` `platform.start` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.start - record: PlatformStart ``` O objeto `PlatformStart` tem os seguintes atributos: + **requestId** – `String` + **version?** – `String` + **tracing?** – ``TraceContext`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.runtimeDone` indica que a fase de invocação da função foi concluída. Um objeto `Event` `platform.runtimeDone` tem a forma a seguir: **Instâncias gerenciadas do Lambda** Não há suporte para o evento `platform.runtimeDone` em instâncias gerenciadas do Lambda. As extensões executadas em instâncias gerenciadas não receberão esse evento porque as extensões não podem se inscrever no evento `INVOKE` em instâncias gerenciadas. Devido ao modelo de execução simultânea em que várias invocações podem ser processadas simultaneamente, as extensões não podem realizar o processamento pós-invocação para invocações individuais, como acontece tradicionalmente nas funções do Lambda (padrão). Em instâncias gerenciadas, as extensões `responseLatency` e `responseDuration` que normalmente são incluídas em `platform.runtimeDone` estão disponíveis no evento `platform.report`. Para mais detalhes, consulte [`platform.report`](#platform-report). ``` Event: Object - time: String - type: String = platform.runtimeDone - record: PlatformRuntimeDone ``` O objeto `PlatformRuntimeDone` tem os seguintes atributos: + **errorType?** – `String` + **metrics?**: objeto ``RuntimeDoneMetrics`` + **requestId** – `String` + **status**: objeto ``Status`` + **spans?** : lista de objetos ``Span`` + **tracing?**: objeto ``TraceContext`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.report` contém um relatório geral da fase de invocação da função. Um objeto `Event` `platform.report` tem a forma a seguir: **Instâncias gerenciadas do Lambda** O evento `platform.report` para instâncias gerenciadas do Lambda tem métricas e extensões diferentes em comparação com as funções do Lambda (padrão). Para instâncias gerenciadas **Extensões**: contém `responseLatency` e `responseDuration` em vez de `extensionOverhead`. A extensão `extensionOverhead` não está disponível porque as extensões não podem assinar o evento em `INVOKE` em instâncias gerenciadas devido ao modelo de execução simultânea. **Métricas**: inclui apenas `durationMs`. As métricas a seguir não estão incluídas: `billedDurationMs`, `initDurationMs`, `maxMemoryUsedMB` e `memorySizeMB`. Essas métricas por invocação não são aplicáveis no ambiente de execução simultânea. Para métricas de utilização de recursos, use [Monitoramento de instâncias gerenciadas do Lambda](lambda-managed-instances-monitoring.md) ou o [Lambda Insights](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-insights.html). ``` Event: Object - time: String - type: String = platform.report - record: PlatformReport ``` O objeto `PlatformReport` tem os seguintes atributos: + **metrics** (métricas): objeto ``ReportMetrics`` + **requestId** – `String` + **spans?** : lista de objetos ``Span`` + **status**: objeto ``Status`` + **tracing?**: objeto ``TraceContext`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.restoreStart` indica que um evento de restauração do ambiente de função foi iniciado. Em um evento de restauração do ambiente, o Lambda cria o ambiente de um snapshot armazenado em cache, em vez de inicializá-lo do zero. Para obter mais informações, consulte [Lambda SnapStart](snapstart.md). Um objeto `Event` `platform.restoreStart` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.restoreStart - record: PlatformRestoreStart ``` O objeto `PlatformRestoreStart` tem os seguintes atributos: + **functionName** – `String` + **functionVersion** – `String` + **instanceId?** – `String` + **instanceMaxMemory?** – `String` + **runtimeVersion?** – `String` + **runtimeVersionArn?** – `String` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.restoreRuntimeDone` indica que um evento de restauração do ambiente de função foi concluído. Em um evento de restauração do ambiente, o Lambda cria o ambiente de um snapshot armazenado em cache, em vez de inicializá-lo do zero. Para obter mais informações, consulte [Lambda SnapStart](snapstart.md). Um objeto `Event` `platform.restoreRuntimeDone` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.restoreRuntimeDone - record: PlatformRestoreRuntimeDone ``` O objeto `PlatformRestoreRuntimeDone` tem os seguintes atributos: + **errorType?** – `String` + **spans?** : lista de objetos ``Span`` + **status**: objeto ``Status`` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.restoreReport` contém um relatório geral de um evento de restauração de função. Um objeto `Event` `platform.restoreReport` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.restoreReport - record: PlatformRestoreReport ``` O objeto `PlatformRestoreReport` tem os seguintes atributos: + **errorType?**: string + **metrics?**: objeto ``RestoreReportMetrics`` + **spans?** : lista de objetos ``Span`` + **status**: objeto ``Status`` Veja a seguir um exemplo de `Event` do 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` Um evento `extension` contém logs do código de extensão. Um objeto `Event` `extension` tem a forma a seguir: ``` Event: Object - time: String - type: String = extension - record: {} ``` O objeto `PlatformExtension` tem os seguintes atributos: + **events** (eventos): lista de `String` + **name (nome** – `String` + **state (estado** – `String` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.telemetrySubscription` contém informações sobre uma assinatura de extensão. Um objeto `Event` `platform.telemetrySubscription` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.telemetrySubscription - record: PlatformTelemetrySubscription ``` O objeto `PlatformTelemetrySubscription` tem os seguintes atributos: + **name (nome** – `String` + **state (estado** – `String` + **types** (tipos): lista de `String` Veja a seguir um exemplo de `Event` do 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` Um evento `platform.logsDropped` contém informações sobre eventos descartados. O Lambda emite o evento `platform.logsDropped` quando uma função gera logs em uma taxa muito alta para o Lambda processá-los. Quando o Lambda não consegue enviar logs para o CloudWatch ou para a extensão inscrita na API Telemetry na velocidade em que a função os produz, ele descarta logs para impedir que a execução da função fique mais lenta. Um objeto `Event` `platform.logsDropped` tem a forma a seguir: ``` Event: Object - time: String - type: String = platform.logsDropped - record: PlatformLogsDropped ``` O objeto `PlatformLogsDropped` tem os seguintes atributos: + **droppedBytes** – `Integer` + **droppedRecords** – `Integer` + **reason (razão** – `String` Veja a seguir um exemplo de `Event` do 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` Um evento `function` contém logs do código da função. Um objeto `Event` `function` tem a forma a seguir: ``` Event: Object - time: String - type: String = function - record: {} ``` O formato do campo `record` vai variar dependendo se os logs da função estão em formato de texto simples ou JSON. Para saber mais sobre as opções de configuração de formato de logs, consulte [Configurar logs em formato de texto simples e JSON](monitoring-cloudwatchlogs-logformat.md). Veja abaixo um exemplo de `Event` de tipo `function` em que o log está formatado em texto simples: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "function", "record": "[INFO] Hello world, I am a function!" } ``` Veja abaixo um exemplo de `Event` de tipo `function` em que o log está formatado em 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** Se a versão do esquema que você está usando for mais antiga que a versão `2022-12-13`, o campo `"record"` será sempre renderizado como uma string, mesmo se o formato do log da função estiver configurado como JSON. Para instâncias gerenciadas do Lambda, é necessário usar a versão `2025-01-29` do esquema. ### `extension` Um evento `extension` contém logs do código de extensão. Um objeto `Event` `extension` tem a forma a seguir: ``` Event: Object - time: String - type: String = extension - record: {} ``` O formato do campo `record` vai variar dependendo se os logs da função estão em formato de texto simples ou JSON. Para saber mais sobre as opções de configuração de formato de logs, consulte [Configurar logs em formato de texto simples e JSON](monitoring-cloudwatchlogs-logformat.md). Veja abaixo um exemplo de `Event` de tipo `extension` em que o log está formatado em texto simples: ``` { "time": "2022-10-12T00:03:50.000Z", "type": "extension", "record": "[INFO] Hello world, I am an extension!" } ``` Veja abaixo um exemplo de `Event` de tipo `extension` em que o log está formatado em 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** Se a versão do esquema que você está usando for mais antiga que a versão `2022-12-13`, o campo `"record"` será sempre renderizado como uma string, mesmo se o formato do log da função estiver configurado como JSON. Para instâncias gerenciadas do Lambda, é necessário usar a versão `2025-01-29` do esquema. ## Tipos de objetos compartilhados Esta seção detalha os tipos de objetos compartilhados aos quais a API de Telemetria do Lambda oferece suporte. ### `InitPhase` Uma enumeração da string que descreve a fase em que ocorre a etapa de inicialização. Na maioria dos casos, o Lambda executa o código de inicialização da função durante a fase `init`. No entanto, em alguns casos de erro, o Lambda pode executar novamente o código de inicialização da função durante a fase `invoke`. (Isso é chamado de *suppressed init* [inicialização suprimida]). + **Tipo** – `String` + **Valores válidos** – `init`\$1`invoke`\$1`snap-start` ### `InitReportMetrics` Um objeto que contém as métricas sobre uma fase de inicialização. + **Tipo** – `Object` Um objeto `InitReportMetrics` tem a forma a seguir: ``` InitReportMetrics: Object - durationMs: Double ``` Veja a seguir um exemplo de um objeto `InitReportMetrics`: ``` { "durationMs": 247.88 } ``` ### `InitType` Uma enumeração de string que descreve como o Lambda inicializou o ambiente. + **Tipo** – `String` + **Valores válidos** – `on-demand`\$1`provisioned-concurrency` ### `ReportMetrics` Um objeto que contém métricas sobre uma fase concluída. + **Tipo** – `Object` Um objeto `ReportMetrics` tem a forma a seguir: ``` ReportMetrics: Object - billedDurationMs: Integer - durationMs: Double - initDurationMs?: Double - maxMemoryUsedMB: Integer - memorySizeMB: Integer - restoreDurationMs?: Double ``` Veja a seguir um exemplo de um objeto `ReportMetrics`: ``` { "billedDurationMs": 694, "durationMs": 693.92, "initDurationMs": 397.68, "maxMemoryUsedMB": 84, "memorySizeMB": 128 } ``` ### `RestoreReportMetrics` Um objeto que contém métricas sobre uma fase de restauração concluída. + **Tipo** – `Object` Um objeto `RestoreReportMetrics` tem a forma a seguir: ``` RestoreReportMetrics: Object - durationMs: Double ``` Veja a seguir um exemplo de um objeto `RestoreReportMetrics`: ``` { "durationMs": 15.19 } ``` ### `RuntimeDoneMetrics` Um objeto que contém métricas sobre uma fase de invocação. + **Tipo** – `Object` Um objeto `RuntimeDoneMetrics` tem a forma a seguir: ``` RuntimeDoneMetrics: Object - durationMs: Double - producedBytes?: Integer ``` Veja a seguir um exemplo de um objeto `RuntimeDoneMetrics`: ``` { "durationMs": 200.0, "producedBytes": 15 } ``` ### `Span` Um objeto que contém detalhes sobre um span. Um span representa uma unidade de trabalho ou de operação em um rastreamento. Para obter mais informações sobre os spans, consulte [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) na página **Tracing API** (API de rastreamento) do site OpenTelemetry Docs. O Lambda é compatível com os seguintes spans para o evento `platform.RuntimeDone`: + O span `responseLatency` descreve quanto tempo sua função do Lambda demorou para começar a enviar a resposta. + O span `responseDuration` descreve quanto tempo sua função do Lambda demorou para concluir o envio da resposta completa. + O span `runtimeOverhead` descreve quanto tempo levou para o runtime do Lambda sinalizar que está pronto para processar a próxima invocação da função. Esse é o tempo que o runtime levou para chamar a [próxima API de invocação](runtimes-api.md#runtimes-api-next) para obter o próximo evento após retornar a resposta da função. Veja a seguir um exemplo de um objeto do span `responseLatency`: ``` { "name": "responseLatency", "start": "2022-08-02T12:01:23.521Z", "durationMs": 23.02 } ``` ### `Status` Um objeto que descreve o status de uma fase de inicialização ou invocação. Se o status for `failure` ou`error`, o objeto `Status` também conterá um campo `errorType` com a descrição do erro. + **Tipo** – `Object` + **Valores de status válidos** – `success`\$1`failure`\$1`error`\$1`timeout` ### `TraceContext` Um objeto que descreve as propriedades de um rastreamento. + **Tipo** – `Object` Um objeto `TraceContext` tem a forma a seguir: ``` TraceContext: Object - spanId?: String - type: TracingType enum - value: String ``` Veja a seguir um exemplo de um objeto `TraceContext`: ``` { "spanId": "073a49012f3c312e", "type": "X-Amzn-Trace-Id", "value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1" } ``` ### `TracingType` Uma enumeração de string que descreve o tipo de rastreamento em um objeto ``TraceContext``. + **Tipo** – `String` + **Valores válidos** – `X-Amzn-Trace-Id` # Conversão de objetos `Event` da API de Telemetria do Lambda em spans do OpenTelemetry O esquema da API de telemetria do AWS Lambda é semanticamente compatível com o OpenTelemetry (OTel). Isso significa que é possível converter os objetos `Event` da API de telemetria do AWS Lambda em spans do OpenTelemetry (OTel). Ao converter, você não deve mapear um único objeto `Event` para um único span do OTel. Em vez disso, você deve apresentar todos os três eventos relacionados a uma fase do ciclo de vida em um único span do OTel. Por exemplo, os eventos `start`, `runtimeDone` e `runtimeReport` representam uma única invocação de função. Apresente todos esses três eventos como um único span do OTel. É possível converter seus eventos usando “Span Events” (Eventos de span) ou “Child Spans” (aninhado) (Spans secundários). As tabelas nesta página descrevem os mapeamentos entre as propriedades do esquema da API de telemetria e as propriedades do span do OTel para ambas as abordagens. Para obter mais informações sobre os spans do OTel, consulte [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) na página **Tracing API** (API de rastreamento) do site OpenTelemetry Docs. **Topics** + [ ## Mapeamento para spans do OTel com “Span Events” (Eventos de span) ](#telemetry-otel-span-events) + [ ## Mapeamento para spans do OTel com “Child Spans” (Spans secundários) ](#telemetry-otel-child-spans) ## Mapeamento para spans do OTel com “Span Events” (Eventos de span) Nas tabelas a seguir, `e` representa o evento proveniente da fonte de telemetria. **Mapeando os eventos \$1Start** | OpenTelemetry | Esquema da API de Telemetria do Lambda | | --- | --- | | `Span.Name` | Sua extensão gera esse valor com base no campo `type`. | | `Span.StartTime` | Use `e.time`. | | `Span.EndTime` | N/A, porque o evento ainda não foi concluído. | | `Span.Kind` | Definir como `Server`. | | `Span.Status` | Definir como `Unset`. | | `Span.TraceId` | Analise o cabeçalho do AWS X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `TraceId`. | | `Span.ParentId` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Parent`. | | `Span.SpanId` | Use `e.tracing.spanId`, se disponível. Caso contrário, gere um novo `SpanId`. | | `Span.SpanContext.TraceState` | N/A para um contexto de rastreamento do X-Ray. | | `Span.SpanContext.TraceFlags` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Sampled`. | | `Span.Attributes` | Sua extensão pode adicionar quaisquer valores personalizados aqui. | **Mapeando os eventos \$1RuntimeDone** | OpenTelemetry | Esquema da API de Telemetria do Lambda | | --- | --- | | `Span.Name` | Sua extensão gera o valor com base no campo `type`. | | `Span.StartTime` | Use `e.time` a partir do evento `*Start` correspondente. Como alternativa, use `e.time - e.metrics.durationMs`. | | `Span.EndTime` | N/A, porque o evento ainda não foi concluído. | | `Span.Kind` | Definir como `Server`. | | `Span.Status` | Se `e.status` não for igual a `success`, defina como `Error`. Caso contrário, defina como `Ok`. | | `Span.Events[]` | Use `e.spans[]`. | | `Span.Events[i].Name` | Use `e.spans[i].name`. | | `Span.Events[i].Time` | Use `e.spans[i].start`. | | `Span.TraceId` | Analise o cabeçalho do AWS X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `TraceId`. | | `Span.ParentId` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Parent`. | | `Span.SpanId` | Use o mesmo `SpanId` do evento `*Start`. Se não estiver disponível, use `e.tracing.spanId` ou gere um novo `SpanId`. | | `Span.SpanContext.TraceState` | N/A para um contexto de rastreamento do X-Ray. | | `Span.SpanContext.TraceFlags` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Sampled`. | | `Span.Attributes` | Sua extensão pode adicionar quaisquer valores personalizados aqui. | **Mapeando os eventos \$1Report events** | OpenTelemetry | Esquema da API de Telemetria do Lambda | | --- | --- | | `Span.Name` | Sua extensão gera o valor com base no campo `type`. | | `Span.StartTime` | Use `e.time` a partir do evento `*Start` correspondente. Como alternativa, use `e.time - e.metrics.durationMs`. | | `Span.EndTime` | Use `e.time`. | | `Span.Kind` | Definir como `Server`. | | `Span.Status` | Use o mesmo valor do evento `*RuntimeDone`. | | `Span.TraceId` | Analise o cabeçalho do AWS X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `TraceId`. | | `Span.ParentId` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Parent`. | | `Span.SpanId` | Use o mesmo `SpanId` do evento `*Start`. Se não estiver disponível, use `e.tracing.spanId` ou gere um novo `SpanId`. | | `Span.SpanContext.TraceState` | N/A para um contexto de rastreamento do X-Ray. | | `Span.SpanContext.TraceFlags` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Sampled`. | | `Span.Attributes` | Sua extensão pode adicionar quaisquer valores personalizados aqui. | ## Mapeamento para spans do OTel com “Child Spans” (Spans secundários) A tabela a seguir descreve como converter eventos da API de Telemetria do Lambda em spans do OTel com “Child Spans” (aninhado) (Spans secundários) para spans `*RuntimeDone`. Para mapeamentos `*Start` e `*Report`, consulte as tabelas em [Mapeamento para spans do OTel com “Span Events” (Eventos de span)](#telemetry-otel-span-events), pois elas são semelhantes para “Child Spans” (Spans secundários). Nesta tabela, `e` representa o evento proveniente da fonte de telemetria. **Mapeando os eventos \$1RuntimeDone** | OpenTelemetry | Esquema da API de Telemetria do Lambda | | --- | --- | | `Span.Name` | Sua extensão gera o valor com base no campo `type`. | | `Span.StartTime` | Use `e.time` a partir do evento `*Start` correspondente. Como alternativa, use `e.time - e.metrics.durationMs`. | | `Span.EndTime` | N/A, porque o evento ainda não foi concluído. | | `Span.Kind` | Definir como `Server`. | | `Span.Status` | Se `e.status` não for igual a `success`, defina como `Error`. Caso contrário, defina como `Ok`. | | `Span.TraceId` | Analise o cabeçalho do AWS X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `TraceId`. | | `Span.ParentId` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Parent`. | | `Span.SpanId` | Use o mesmo `SpanId` do evento `*Start`. Se não estiver disponível, use `e.tracing.spanId` ou gere um novo `SpanId`. | | `Span.SpanContext.TraceState` | N/A para um contexto de rastreamento do X-Ray. | | `Span.SpanContext.TraceFlags` | Analise o cabeçalho do X-Ray encontrado em `e.tracing.value` e, em seguida, use o valor `Sampled`. | | `Span.Attributes` | Sua extensão pode adicionar quaisquer valores personalizados aqui. | | `ChildSpan[i].Name` | Use `e.spans[i].name`. | | `ChildSpan[i].StartTime` | Use `e.spans[i].start`. | | `ChildSpan[i].EndTime` | Use `e.spans[i].start + e.spans[i].durations`. | | `ChildSpan[i].Kind` | Semelhante ao principal `Span.Kind`. | | `ChildSpan[i].Status` | Semelhante ao principal `Span.Status`. | | `ChildSpan[i].TraceId` | Semelhante ao principal `Span.TraceId`. | | `ChildSpan[i].ParentId` | Use o principal `Span.SpanId`. | | `ChildSpan[i].SpanId` | Gere um novo `SpanId`. | | `ChildSpan[i].SpanContext.TraceState` | N/A para um contexto de rastreamento do X-Ray. | | `ChildSpan[i].SpanContext.TraceFlags` | Semelhante ao principal `Span.SpanContext.TraceFlags`. | # Usar a API de logs do Lambda **Importante** A API de telemetria do Lambda substitui a API de logs do Lambda. **Embora a API de logs permaneça totalmente funcional, recomendamos usar apenas a API de telemetria daqui para frente.** É possível inscrever sua extensão em um fluxo de telemetria usando a API de telemetria ou a API de logs. Após se inscrever usando uma dessas APIs, qualquer tentativa de se inscrever usando a outra API retornará um erro. **As instâncias gerenciadas do Lambda não oferecem suporte à API de logs** As instâncias gerenciadas do Lambda não oferecem suporte à API de logs. Se você estiver usando funções de instância gerenciada, use a [API de telemetria](telemetry-api.md) em vez disso. A API de telemetria fornece recursos aprimorados para coletar e processar dados de telemetria de suas funções do Lambda. O Lambda captura automaticamente os logs de tempo de execução e os transmite para o Amazon CloudWatch. Essa transmissão de log contém os logs que seu código de função e extensões geram, e também os gerados pelo Lambda como parte da chamada de função. [Extensões do Lambda](runtimes-extensions-api.md)pode usar a API RLambda time Logs para assinar fluxos de log diretamente do Lambda[ambiente de execução](lambda-runtime-environment.md). O Lambda transmite os logs para a extensão e a extensão pode processar, filtrar e enviar os logs para qualquer destino preferido. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/logs-api-concept-diagram.png) A API Logs permite que as extensões se inscrevam em três fluxos de logs diferentes: + Logs de função que a função do Lambda gera e grava em `stdout` ou `stderr`. + Registros de extensão que o código de extensão gera. + Logs da plataforma do Lambda que registram eventos e erros relacionados a invocações e extensões. **nota** O Lambda envia todos os logs para o CloudWatch, mesmo quando uma extensão se inscreve em uma ou mais transmissões de log. **Topics** + [ ## Assinando para receber registros ](#runtimes-logs-api-subscribing) + [ ## Uso de memória ](#runtimes-logs-api-memory) + [ ## protocolos de destino ](#runtimes-logs-api-dest) + [ ## Configuração de buffer ](#runtimes-logs-api-buffering) + [ ## Exemplo de assinatura ](#runtimes-logs-api-subs-example) + [ ## Código de exemplo para Logs API ](#runtimes-logs-api-samples) + [ ## Referência da API Logs ](#runtimes-logs-api-ref) + [ ## Mensagens de log ](#runtimes-logs-api-msg) ## Assinando para receber registros Uma extensão do Lambda pode se inscrever para receber registros enviando uma solicitação de assinatura para a API Logs. Para se inscrever para receber registros, você precisa do identificador de extensão (`Lambda-Extension-Identifier`). Primeiro [registre a extensão](runtimes-extensions-api.md#extensions-registration-api-a) para receber o identificador de extensão. Em seguida, inscreva-se na API Logs durante a [inicialização](lambda-runtime-environment.md#runtimes-lifecycle-ib). Após a conclusão da fase de inicialização, o Lambda não processa solicitações de assinatura. **nota** A assinatura da API de registros é idempotente. As solicitações de assinatura duplicadas não resultam em assinaturas duplicadas. ## Uso de memória O uso da memória aumenta linearmente à medida que o número de assinantes aumenta. As assinaturas consomem recursos de memória porque cada assinatura abre um novo buffer de memória para armazenar os logs. Para ajudar a otimizar o uso da memória, você pode ajustar a [configuração de buffer](#runtimes-logs-api-buffering). O uso da memória buffer conta para o consumo geral de memória no ambiente de execução. ## protocolos de destino É possível escolher um dos seguintes protocolos para receber os logs: 1. **HTTP** (recomendado): o Lambda entrega os logs a um endpoint HTTP local (`http://sandbox.localdomain:${PORT}/${PATH}`) como uma matriz de registros no formato JSON. O parâmetro `$PATH` é opcional. Observe que somente HTTP é suportado, não HTTPS. É possível optar por receber logs através PUT ou POST. 1. **TCP**: o Lambda entrega logs a uma porta TCP no formato [JSON delimitado por nova linha (NDJSON)](https://github.com/ndjson/ndjson-spec). Recomendamos usar HTTP em vez de TCP. Com o TCP, a plataforma do Lambda não reconhece que os logs são entregues à camada da aplicação. Portanto, você poderá perder os logs se a extensão falhar. O HTTP não compartilha essa limitação. Também recomendamos configurar o ouvinte HTTP local ou a porta TCP antes de se inscrever para receber logs. Durante a configuração, observe o seguinte: + O Lambda envia logs somente para destinos que estão dentro do ambiente de execução. + O Lambda tenta novamente enviar os logs (com recuo) se não houver listener ou se a solicitação POST ou PUT resultar em erro. Se o assinante do log falhar, ele continuará a receber logs depois que o Lambda reiniciar o ambiente de execução. + Lambda reserva porto 9001. Não há outras restrições ou recomendações de número de porta. ## Configuração de buffer O Lambda pode armazenar logs de buffer e entregá-los ao assinante. É possível configurar esse comportamento na solicitação de assinatura especificando os campos opcionais a seguir. Observe que o Lambda usa o valor padrão para qualquer campo que você não especificar. + **timeoutMs**: o tempo máximo (em milissegundos) para colocar um lote em buffer. Padrão: 1.000. Mínimo: 25. Máximo: 30.000. + **maxBytes**: o tamanho máximo (em bytes) dos logs para colocar em buffer na memória. Padrão: 262.144. Mínimo: 262.144. Máximo: 1.048.576. + **maxItems**: o número máximo de eventos a serem colocados em buffer na memória. Padrão: 10.000. Mínimo: 1.000. Máximo: 10.000. Durante a configuração de buffer, observe os seguintes pontos: + O Lambda libera os logs se alguma das transmissões de entrada estiver fechada, por exemplo, se o tempo de execução falhar. + Cada assinante pode especificar uma configuração de buffer diferente durante a solicitação de assinatura. + Considere o tamanho do buffer que você precisa para ler os dados. Espere receber cargas úteis tão grandes quanto `2*maxBytes+metadata`, onde `maxBytes` é configurado na solicitação de assinatura. Por exemplo, o Lambda adiciona os seguintes bytes de metadados a cada registro: ``` { "time": "2020-08-20T12:31:32.123Z", "type": "function", "record": "Hello World" } ``` + Se o assinante não puder processar logs de entrada com rapidez suficiente, o Lambda pode descartar logs para manter a utilização da memória limitada. Para indicar o número de registros descartados, o Lambda envia um log `platform.logsDropped`. Para obter mais informações, consulte [Lambda: nem todos os logs da função aparecem](troubleshooting-execution.md#troubleshooting-execution-missinglogs). ## Exemplo de assinatura O exemplo a seguir mostra uma solicitação para se inscrever na plataforma e logs de funções. ``` 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" } } ``` Se o pedido for bem-sucedido, o assinante receberá uma resposta de êxito HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` ## Código de exemplo para Logs API Para obter exemplos de código mostrando como enviar logs para um destino personalizado, consulte [Using AWS Lambda extensions to send logs to custom destinations](https://aws.amazon.com/blogs/compute/using-aws-lambda-extensions-to-send-logs-to-custom-destinations/) no AWS Compute Blog. Para exemplos de código Python e Go que mostram como desenvolver uma extensão básica do Lambda e assinar a API Logs, consulte [Extensões do AWS Lambda](https://github.com/aws-samples/aws-lambda-extensions) no repositório de exemplos da AWS no GitHub. Para obter mais informações sobre a criação de uma extensão do Lambda, consulte [Usar a API de extensões do Lambda para criar extensões](runtimes-extensions-api.md). ## Referência da API Logs É possível recuperar o endpoint da API Logs da variável de ambiente `AWS_LAMBDA_RUNTIME_API`. Para enviar uma solicitação de API, use o prefixo `2020-08-15/` antes do caminho da API. Por exemplo: ``` http://${AWS_LAMBDA_RUNTIME_API}/2020-08-15/logs ``` A especificação OpenAPI para a versão da API de logs, **2020-08-15**, está disponível aqui: [logs-api-request.zip](samples/logs-api-request.zip) ### Assinar Para se inscrever em um ou mais transmissões de log disponíveis no ambiente de execução do Lambda, as extensões enviam uma solicitação de assinatura da API. **Caminho** – `/logs` **Método** – **PUT** **Body parameters (Parâmetros do corpo** `destination` – consulte [protocolos de destino](#runtimes-logs-api-dest). Obrigatório: sim. Tipo: strings. `buffering` – consulte [Configuração de buffer](#runtimes-logs-api-buffering). Obrigatório: não Tipo: strings. `types`: uma matriz dos tipos de logs a serem recebidos. Obrigatório: sim. Tipo: matriz de strings. Valores válidos: “plataforma”, “função”, “extensão”. `schemaVersion`: obrigatório: não Valor padrão: “2020-08-15”. Defina como “2021-03-18” para que a extensão receba [`platform.runtimeDone`](#runtimes-logs-api-ref-done) mensagens. ****Parâmetros de resposta**** As especificações OpenAPI para as respostas de assinatura, versão **2020-08-15**, estão disponíveis para HTTP e 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 resposta**** + 200: solicitação concluída com êxito + 202: solicitação aceita. Resposta a uma solicitação de assinatura durante testes locais. + 4XX: solicitação inválida + 500: erro do serviço Se o pedido for bem-sucedido, o assinante receberá uma resposta de êxito HTTP 200. ``` HTTP/1.1 200 OK "OK" ``` Se a solicitação falhar, o assinante receberá uma resposta de erro. Por exemplo: ``` HTTP/1.1 400 OK { "errorType": "Logs.ValidationError", "errorMessage": URI port is not provided; types should not be empty" } ``` ## Mensagens de log A API Logs permite que as extensões se inscrevam em três fluxos de logs diferentes: + Função: logs que a função do Lambda gera e grava em `stdout` ou `stderr`. + Extensão: logs gerados pelo código da extensão. + Plataforma: logs gerados pela plataforma de tempo de execução, que registram eventos e erros relacionados a invocações e extensões. **Topics** + [ ### Logs de função ](#runtimes-logs-api-msg-function) + [ ### Logs de extensões ](#runtimes-logs-api-msg-extension) + [ ### Logs de plataformas ](#runtimes-logs-api-msg-platform) ### Logs de função A função e as extensões internas do Lambda geram logs de funções e os gravam em `stdout` ou `stderr`. O exemplo a seguir mostra o formato de uma mensagem de log de função. \$1 "time": "2020-08-20T12:31:32.123Z", "type": "function", "record": "ERROR encountered. Rastreamento da pilha:\$1n\$1my-function (line 10)\$1n" \$1 ### Logs de extensões As extensões podem gerar logs de extensões. O formato do log é o mesmo que para um log de funções. ### Logs de plataformas O Lambda gera mensagens de log para eventos de plataforma como `platform.end`, `platform.start` e `platform.fault`. Opcionalmente, você pode se inscrever na versão **2021-03-18** do esquema da API de logs, que inclui a mensagem de log `platform.runtimeDone`. #### Exemplo de mensagens de log da plataforma O exemplo a seguir mostra o início da plataforma e os logs finais da plataforma. Esses logs indicam a hora de início da invocação e o horário de término para a invocação que o requestID especifica. ``` { "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"} } ``` A mensagem de log **platform.initRuntimeDone** mostra o status da subfase `Runtime init`, que faz parte da [fase de inicialização do ciclo de vida](lambda-runtime-environment.md#runtimes-lifecycle-ib). Quando o `Runtime init` ocorre com êxito, o tempo de execução envia uma solicitação de API de tempo de execução `/next` (para os tipos `provisioned-concurrency` e de inicialização `on-demand`) ou `restore/next` (para o tipo de inicialização `snap-start`). O exemplo a seguir mostra uma mensagem de log **platform.initRuntimeDone** com êxito para o tipo de inicialização `snap-start`. ``` { "time":"2022-07-17T18:41:57.083Z", "type":"platform.initRuntimeDone", "record":{ "initializationType":"snap-start", "status":"success" } } ``` A mensagem de log **Platform.initReport** mostra quanto tempo durou a fase `Init` e por quantos milissegundos você foi cobrado durante essa fase. Quando o tipo de inicialização é `provisioned-concurrency`, o Lambda envia essa mensagem durante a invocação. Quando o tipo de inicialização é `snap-start`, o Lambda envia essa mensagem após restaurar o snapshot. O exemplo a seguir mostra uma mensagem de log **platform.initReport** para o tipo de inicialização `snap-start`. ``` { "time":"2022-07-17T18:41:57.083Z", "type":"platform.initReport", "record":{ "initializationType":"snap-start", "metrics":{ "durationMs":731.79, "billedDurationMs":732 } } } ``` O log de relatório da plataforma inclui métricas sobre a invocação que o requestID especifica. O campo `initDurationMs` é incluído no log somente se a invocação incluir uma partida a frio. Se o rastreamento do AWS X-Ray estiver ativo, o log incluirá metadados do X-Ray. O exemplo a seguir mostra um log de relatório de plataforma para uma invocação que incluiu uma partida a frio. ``` { "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 } } } ``` O log da plataforma captura erros de ambiente de execução ou tempo de execução. O exemplo a seguir mostra uma mensagem de log de falha da plataforma. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.fault", "record": "RequestId: d783b35e-a91d-4251-af17-035953428a2c Process exited before completing request" } ``` **nota** A AWS atualmente está implementando alterações no serviço Lambda. Devido a essas alterações, você pode ver pequenas diferenças entre a estrutura e o conteúdo das mensagens de log do sistema e os segmentos de rastreamento emitidos por diferentes funções do Lambda na sua Conta da AWS. Uma das saídas de log afetadas por essa alteração é o campo `"record"` do log de falhas da plataforma. Os exemplos a seguir mostram campos `"record"` ilustrativos no formato antigo e no formato novo. O novo estilo de log de falhas contém uma mensagem mais concisa Essas alterações serão implementadas durante as próximas semanas, e todas as funções em todas as Regiões da AWS, exceto nas regiões China e GovCloud, passarão a usar o novo formato de mensagens de log e segmentos de rastreamento. **Example registro do log de falhas da plataforma (estilo antigo)** ``` "record":"RequestId: ...\tError: Runtime exited with error: exit status 255\nRuntime.ExitError" ``` **Example registro do log de falhas da plataforma (estilo novo)** ``` "record":"RequestId: ... Status: error\tErrorType: Runtime.ExitError" ``` O Lambda gera um log de extensão de plataforma quando uma extensão se registra com a API Extensions. O exemplo a seguir mostra uma mensagem de extensão da plataforma. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.extension", "record": {"name": "Foo.bar", "state": "Ready", "events": ["INVOKE", "SHUTDOWN"] } } ``` O Lambda gera um log de assinatura de logs de plataforma quando uma extensão se inscreve na API Logs. O exemplo a seguir mostra uma mensagem de assinatura de logs. ``` { "time": "2020-08-20T12:31:32.123Z", "type": "platform.logsSubscription", "record": {"name": "Foo.bar", "state": "Subscribed", "types": ["function", "platform"], } } ``` O Lambda gera um log descartado de logs de plataforma quando uma extensão não é capaz de processar o número de logs que está recebendo. O exemplo a seguir mostra uma mensagem de log `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 } } ``` A mensagem de log **platform.restoRestoRestart** mostra o horário em que a fase `Restore` começou (somente para o tipo de inicialização `snap-start`). Exemplo: ``` { "time":"2022-07-17T18:43:44.782Z", "type":"platform.restoreStart", "record":{} } ``` A mensagem de log **platform.restoreReport** mostra quanto tempo durou a fase `Restore` e por quantos milissegundos você foi cobrado durante essa fase (somente para o tipo de inicialização`snap-start` ). Exemplo: ``` { "time":"2022-07-17T18:43:45.936Z", "type":"platform.restoreReport", "record":{ "metrics":{ "durationMs":70.87, "billedDurationMs":13 } } } ``` #### Mensagens `runtimeDone` da plataforma Se você definir a versão do esquema como “2021-03-18” na solicitação de assinatura, o Lambda enviará uma mensagem `platform.runtimeDone` após a conclusão da invocação da função com êxito ou com um erro. A extensão pode usar esta mensagem para interromper toda a coleção de telemetria para esta invocação de função. A especificação OpenAPI para o tipo de evento do log no esquema versão **2021-03-18** está disponível aqui: [schema-2021-03-18.zip](samples/schema-2021-03-18.zip) O Lambda gera a mensagem de log `Next` quando o tempo de execução envia uma solicitação de API do tempo de execução `platform.runtimeDone` ou `Error`. O `platform.runtimeDone` log informa os consumidores da API Logs que a invocação de função foi concluída. As extensões podem usar essas informações para decidir quando enviar toda a telemetria coletada durante essa invocação. ##### Exemplos O Lambda envia a mensagem `platform.runtimeDone` depois que o tempo de execução envia a solicitação NEXT, quando a invocação da função for concluída. Os exemplos a seguir mostram mensagens para cada um dos valores de status: êxito, falha e tempo limite. **Example Exemplo de mensagem de êxito** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "success" } } ``` **Example Exemplo de mensagem de falha** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "failure" } } ``` **Example Exemplo de mensagem de tempo limite** ``` { "time": "2021-02-04T20:00:05.123Z", "type": "platform.runtimeDone", "record": { "requestId":"6f7f0961f83442118a7af6fe80b88", "status": "timeout" } } ``` **Example Exemplo de mensagem “platform.RestoreRuntimeDone” (somente para o tipo de inicialização `snap-start`)** A mensagem de log **platform.RestoreRuntimeDone** mostra se a fase `Restore` ocorreu, ou não, com êxito. O Lambda envia essa mensagem quando o tempo de execução envia uma solicitação de API de tempo de execução `restore/next`. Existem três status possíveis: com êxito, com falha e tempo limite. O exemplo a seguir mostra uma mensagem de log **platform.restoreRuntimeDone** com êxito. ``` { "time":"2022-07-17T18:43:45.936Z", "type":"platform.restoreRuntimeDone", "record":{ "status":"success" } } ```