Journalisation des fonctions lambda dans Rust

Note

Le client d’exécution Rust est un package expérimental. Il est susceptible d’être modifié et n’est destiné qu’à des fins d’évaluation.

AWS Lambdasurveille automatiquement les fonctions Lambda en votre nom et envoie les journaux à Amazon. CloudWatch Votre fonction Lambda est fournie avec un groupe de CloudWatch journaux Logs et un flux de journaux pour chaque instance de votre fonction. L’environnement d’exécution Lambda envoie des informations sur chaque invocation au flux de journaux et transmet les journaux et autres sorties provenant du code de votre fonction. Pour plus d’informations, consultez Utilisation d'Amazon CloudWatch Logs avec AWS Lambda. Cette page décrit comment produire des journaux à partir du code de votre fonction Lambda.

Création d'une fonction qui écrit des journaux

Pour produire des journaux à partir du code de votre fonction, vous pouvez utiliser n'importe quelle fonction de journalisation qui écrit dans stdout ou stderr, comme la macro println!. L'exemple suivant utilise println! pour imprimer un message lorsque le gestionnaire de fonction démarre et avant qu'il ne se termine.

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
}

Journalisation avancée avec la caisse Tracing

Tracing est un cadre permettant d'instrumenter les programmes Rust afin de collecter des informations de diagnostic structurées et basées sur des événements. Ce cadre fournit des utilitaires pour personnaliser les niveaux et les formats de sortie des journaux, comme la création de messages de journal JSON structurés. Pour utiliser ce cadre, vous devez initialiser un subscriber avant de mettre en œuvre le gestionnaire de fonction. Ensuite, vous pouvez utiliser des macros de traçage comme debug, info et error pour spécifier le niveau de journal que vous voulez pour chaque scénario.

Exemple – Utilisation de la caisse Tracing

Notez ce qui suit :

• tracing_subscriber::fmt().json() : lorsque cette option est incluse, les journaux sont formatés en JSON. Pour utiliser cette option, vous devez inclure la fonction json dans la dépendance tracing-subscriber (par exemple, tracing-subscriber = { version = "0.3.11", features = ["json"] }).

• #[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))] : cette annotation génère une étendue à chaque fois que le gestionnaire est invoqué. L'étendue ajoute l'identifiant de la demande à chaque ligne de journal.

• { %first_name } : cette construction ajoute le champ first_name à la ligne de journal où il est utilisé. La valeur de ce champ correspond à la variable du même nom.

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
}

Lorsque cette fonction Rust est invoquée, elle imprime deux lignes de journal similaires à ce qui suit :

{"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"}]}