# Registro y supervisioón de las funciones de Lambda en Rust
<a name="rust-logging"></a>

AWS Lambda supervisa automáticamente funciones de Lambda en su nombre y envía registros a Amazon CloudWatch. Su función de Lambda viene con un grupo de registros de Registros de CloudWatch y con un flujo de registro para cada instancia de su función. El entorno de tiempo de ejecución de Lambda envía detalles sobre cada invocación al flujo de registro y retransmite los registros y otras salidas desde el código de la función. Para obtener más información, consulte [Envío de registros de funciones de Lambda a Registros de CloudWatch](monitoring-cloudwatchlogs.md). Para obtener información sobre la configuración de los formatos de registro, consulte [Configuración de los formatos de registro JSON y de texto sin formato](monitoring-cloudwatchlogs-logformat.md). Esta página describe cómo producir resultados de registro a partir del código de la función de Lambda.

## Creación de una función que escribe registros
<a name="rust-logging-function"></a>

Para generar registros desde el código de su función, puede utilizar cualquier función de registro que escriba en `stdout` o `stderr`, como el macro `println!`. El siguiente ejemplo utiliza `println!` para imprimir un mensaje cuando se inicia el controlador de funciones y antes de que finalice.

```
use lambda_runtime::{service_fn, LambdaEvent, Error};
use serde_json::{json, Value};
async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
    println!("Rust function invoked");
    let payload = event.payload;
    let first_name = payload["firstName"].as_str().unwrap_or("world");
    println!("Rust function responds to {}", &first_name);
    Ok(json!({ "message": format!("Hello, {first_name}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    lambda_runtime::run(service_fn(handler)).await
}
```

## Implementación del registro avanzado con la caja Tracing
<a name="rust-logging-tracing"></a>

[Tracing](https://crates.io/crates/tracing) es un marco para instrumentar los programas de Rust a fin de recopilar información de diagnóstico estructurada y basada en eventos. Este marco proporciona utilidades para personalizar los niveles y formatos de resultado del registro, como la creación de mensajes de registro JSON estructurados. Para utilizar este marco, debe inicializar un `subscriber` antes de implementar el controlador de funciones. A continuación, puede utilizar macros de rastreo como `debug`, `info` y `error` para especificar el nivel de registro que desea para cada situación.

**Example — Uso de la caja Tracing**  
Tenga en cuenta lo siguiente:  
+ `tracing_subscriber::fmt().json()`: cuando se incluye esta opción, los registros están en formato JSON. Para usar esta opción, debe incluir la función `json` en la dependencia `tracing-subscriber` (por ejemplo, `tracing-subscriber = { version = "0.3.11", features = ["json"] }`).
+ `#[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]`: esta anotación genera un intervalo cada vez que se invoca el controlador. El intervalo agrega el ID de la solicitud a cada línea de registro.
+ `{ %first_name }`: este constructo agrega el campo `first_name` a la línea de registro donde se usa. El valor de este campo corresponde a la variable con el mismo nombre.

```
use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde_json::{json, Value};
#[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]
async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
    tracing::info!("Rust function invoked");
    let payload = event.payload;
    let first_name = payload["firstName"].as_str().unwrap_or("world");
    tracing::info!({ %first_name }, "Rust function responds to event");
    Ok(json!({ "message": format!("Hello, {first_name}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt().json()
        .with_max_level(tracing::Level::INFO)
        // this needs to be set to remove duplicated information in the log.
        .with_current_span(false)
        // this needs to be set to false, otherwise ANSI color codes will
        // show up in a confusing manner in CloudWatch logs.
        .with_ansi(false)
        // disabling time is handy because CloudWatch will add the ingestion time.
        .without_time()
        // remove the name of the function from every log entry
        .with_target(false)
        .init();
    lambda_runtime::run(service_fn(handler)).await
}
```

Cuando se invoca esta función de Rust, imprime dos líneas de registro similares a las siguientes:

```
{"level":"INFO","fields":{"message":"Rust function invoked"},"spans":[{"req_id":"45daaaa7-1a72-470c-9a62-e79860044bb5","name":"handler"}]}
{"level":"INFO","fields":{"message":"Rust function responds to event","first_name":"David"},"spans":[{"req_id":"45daaaa7-1a72-470c-9a62-e79860044bb5","name":"handler"}]}
```