Enregistrez et surveillez les fonctions Lambda C#

AWS Lambda surveille automatiquement les fonctions Lambda et envoie des entrées de journal à 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 détails sur chaque invocation et d’autres sorties provenant du code de votre fonction au flux de journaux. Pour plus d'informations sur CloudWatch les journaux, consultezUtilisation de CloudWatch Logs avec Lambda.

Création d’une fonction qui renvoie des journaux

Pour générer des journaux à partir de votre code de fonction, vous pouvez utiliser l'objet ILambdaLoggeron the context, les méthodes de la classe Console ou toute bibliothèque de journalisation qui écrit dans stdout oustderr.

Le. NETruntime enregistre les REPORT lignes STARTEND, et pour chaque appel. La ligne de rapport fournit les détails suivants.

Utilisation des commandes de journalisation avancées de Lambda avec. NET

Pour mieux contrôler la manière dont les journaux de vos fonctions sont capturés, traités et consommés, vous pouvez configurer les options de journalisation suivantes pour qu'elles soient prises en charge. NETtemps d'exécution :

Pour plus d’informations sur ces options de journalisation et pour savoir comment configurer votre fonction pour les utiliser, consultez Configuration de contrôles de journalisation avancés pour les fonctions Lambda.

Pour utiliser le format du journal et les options de niveau de journal avec votre. NET Fonctions Lambda, consultez les instructions dans les sections suivantes.

Utilisation d'un format de JSON journal structuré avec. NET

Si vous sélectionnez le JSON format de journal de votre fonction, Lambda enverra les journaux en utilisant ILambdaLoggeras structured. JSON Chaque objet JSON journal contient au moins cinq paires clé-valeur avec les clés suivantes :

L'ILambdaLoggerinstance peut ajouter des paires clé-valeur supplémentaires, par exemple lors de la journalisation des exceptions. Vous pouvez également fournir vos propres paramètres supplémentaires, comme décrit dans la sectionParamètres du journal fournis par le client.

L'exemple de commande de journalisation suivant montre comment écrire un message de journal avec le niveauINFO.

context.Logger.LogInformation("Fetching cart from database");

Vous pouvez également utiliser une méthode de journalisation générique qui prend le niveau de journalisation comme argument, comme indiqué dans l'exemple suivant.

context.Logger.Log(LogLevel.Information, "Fetching cart from database");

La sortie du journal par ces exemples d'extraits de code serait capturée dans CloudWatch Logs comme suit :

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Fetching cart from database"
}

Si vous n'attribuez aucun niveau à la sortie de votre journal, Lambda lui attribuera automatiquement le niveau. INFO

Enregistrement des exceptions dans JSON

Lorsque vous utilisez la JSON journalisation structurée avecILambdaLogger, vous pouvez enregistrer les exceptions dans votre code, comme indiqué dans l'exemple suivant.

try
{
    connection.ExecuteQuery(query);
}
catch(Exception e)
{
    context.Logger.LogWarning(e, "Error executing query");
}

Le format de journal généré par ce code est illustré dans l'exemple suivantJSON. Notez que la message propriété dans le JSON est renseignée à l'aide de l'argument message fourni dans l'LogWarningappel, tandis que la errorMessage propriété provient de la Message propriété de l'exception elle-même.

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Warning",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Error executing query",
    "errorType": "System.Data.SqlClient.SqlException",
    "errorMessage": "Connection closed",
    "stackTrace": ["<call exception.StackTrace>"]
}

Si le format de journalisation de votre fonction est défini surJSON, Lambda produit également des messages de journal JSON formatés lorsque votre code génère une exception non détectée. L'exemple d'extrait de code et de message de journal suivants montre comment les exceptions non détectées sont enregistrées.

throw new ApplicationException("Invalid data");

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Error",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Invalid data",
    "errorType": "System.ApplicationException",
    "errorMessage": "Invalid data",
    "stackTrace": ["<call exception.StackTrace>"]
}

Paramètres du journal fournis par le client

Avec les messages de journal JSON au format -formaté, vous pouvez fournir des paramètres de journal supplémentaires et les inclure dans le journal. message L'exemple d'extrait de code suivant montre une commande permettant d'ajouter deux paramètres fournis par l'utilisateur et étiquetés et. retryAttempt uri Dans l'exemple, la valeur de ces paramètres provient des uriDestination arguments retryAttempt et transmis à la commande de journalisation.

context.Logger.LogInformation("Starting retry {retryAttempt} to make GET request to {uri}", retryAttempt, uriDestination);

Le message de journal généré par cette commande est illustré dans l'exemple suivantJSON.

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Starting retry 1 to make GET request to http://example.com/",
    "retryAttempt": 1,
    "uri": "http://example.com/"
}

context.Logger.LogInformation("Starting retry {0} to make GET request to {1}", retryAttempt, uriDestination);

Notez que lorsque vous fournissez des paramètres de journalisation supplémentaires, Lambda les capture en tant que propriétés de premier niveau dans l'enregistrement du JSON journal. Cette approche diffère de certaines approches populaires. NETdes bibliothèques de journalisation telles que Serilog celles qui capturent des paramètres supplémentaires dans un objet enfant distinct.

Si l'argument que vous fournissez pour un paramètre supplémentaire est un objet complexe, Lambda utilise par défaut la ToString() méthode pour fournir la valeur. Pour indiquer qu'un argument doit être JSON sérialisé, utilisez le @ préfixe comme indiqué dans l'extrait de code suivant. Dans cet exemple, User il s'agit d'un objet doté de LastName propriétés FirstName et.

context.Logger.LogInformation("User {@user} logged in", User);

Le message de journal généré par cette commande est illustré dans l'exemple suivantJSON.

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "User {@user} logged in",
    "user": 
    {
        "FirstName": "John",
        "LastName": "Doe"
    }
}

Si l'argument d'un paramètre supplémentaire est un tableau ou implémente IList ouIDictionary, alors Lambda ajoute l'argument au message de JSON journal sous forme de tableau, comme indiqué dans l'exemple d'enregistrement de JSON journal suivant. Dans cet exemple, {users} prend un IList argument contenant des instances de la User propriété au même format que dans l'exemple précédent. Lambda le IList convertit en tableau, chaque valeur étant créée à l'aide de la ToString méthode.

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "{users} have joined the group",
    "users": 
    [
        "Rosalez, Alejandro",
        "Stiles, John"       
    ] 
}

Vous pouvez également JSON sérialiser la liste en utilisant le @ préfixe dans votre commande de journalisation. Dans l'exemple d'enregistrement de JSON journal suivant, la users propriété est JSON sérialisée.

{
    "timestamp": "2023-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "{@users} have joined the group",
    "users": 
    [
        {
            "FirstName": "Alejandro",
            "LastName": "Rosalez"
        },
        {
            "FirstName": "John",
            "LastName": "Stiles"
        }        
    ] 
}

Utilisation du filtrage au niveau du journal avec. NET

En configurant le filtrage au niveau des journaux, vous pouvez choisir de n'envoyer que les journaux d'un certain niveau de détail ou inférieur à CloudWatch Logs. Pour savoir comment configurer le filtrage de niveau journal de votre fonction, consultez Filtrage au niveau du journal.

AWS Lambda Pour filtrer vos messages de journal par niveau de journal, vous pouvez utiliser des journaux JSON formatés ou utiliser le. NETConsoleméthodes pour générer des messages de journal. Pour créer des journaux JSON formatés, configurez le type de journal de votre fonction en fonction de l'ILambdaLoggerinstance JSON et utilisez-la.

Avec les journaux JSON au format -formaté, Lambda filtre les sorties de vos journaux en utilisant la paire clé-valeur « niveau » contenue dans l'JSONobjet décrit dans. Utilisation d'un format de JSON journal structuré avec. NET

Si vous utilisez le. NETConsoleméthodes pour écrire des messages dans CloudWatch Logs, Lambda applique les niveaux de journalisation à vos messages comme suit :

Lorsque vous configurez votre fonction pour utiliser le filtrage au niveau des journaux, vous devez sélectionner parmi les options suivantes le niveau de journaux que Lambda doit envoyer à Logs. CloudWatch Notez le mappage des niveaux de journalisation utilisés par Lambda avec les niveaux Microsoft standard utilisés par le. NETILambdaLogger.

Lambda envoie des journaux correspondant au niveau de détail sélectionné et inférieur à. CloudWatch Par exemple, si vous configurez un niveau de journalisation deWARN, Lambda enverra des journaux correspondant aux niveaux WARNERROR, etFATAL.

Outils de journalisation et bibliothèques supplémentaires

Outils électriques pour AWS Lambda (. NET) est une boîte à outils destinée aux développeurs qui permet de mettre en œuvre les meilleures pratiques sans serveur et d'accroître la rapidité des développeurs. L'utilitaire Logging fournit un enregistreur optimisé pour Lambda qui inclut des informations supplémentaires sur le contexte des fonctions dans toutes vos fonctions avec une sortie structurée comme suit. JSON Utilisez cet utilitaire pour effectuer les opérations suivantes :

Utilisation de Powertools pour AWS Lambda (. NET) et AWS SAM pour la journalisation structurée

Suivez les étapes ci-dessous pour télécharger, créer et déployer un exemple d'application Hello World C# avec Powertools intégrés pour AWS Lambda (. NET) modules utilisant le AWS SAM. Cette application implémente un API backend de base et utilise Powertools pour émettre des journaux, des métriques et des traces. Il se compose d'un point de terminaison Amazon API Gateway et d'une fonction Lambda. Lorsque vous envoyez une GET demande au point de terminaison API Gateway, la fonction Lambda appelle, envoie des journaux et des métriques au format métrique intégré à CloudWatch, et envoie des traces à. AWS X-Ray La fonction renvoie un message hello world.

Gestion de la conservation des journaux

Les groupes de journaux ne sont pas supprimés automatiquement quand vous supprimez une fonction. Pour éviter de stocker les journaux indéfiniment, supprimez le groupe de journaux ou configurez une période de conservation après laquelle les journaux CloudWatch sont automatiquement supprimés. Pour configurer la conservation des journaux, ajoutez ce qui suit à votre AWS SAM modèle :

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7

Afficher les journaux dans la console Lambda

Vous pouvez utiliser la console Lambda pour afficher la sortie du journal après avoir invoqué une fonction Lambda.

Si votre code peut être testé à partir de l’éditeur Code intégré, vous trouverez les journaux dans les résultats d’exécution. Lorsque vous utilisez la fonctionnalité de test de console pour invoquer une fonction, vous trouverez Sortie du journal dans la section Détails.

Afficher les journaux dans la CloudWatch console

Vous pouvez utiliser la CloudWatch console Amazon pour consulter les journaux de toutes les invocations de fonctions Lambda.

Chaque flux de journal correspond à une instance de votre fonction. Un flux de journaux apparaît lorsque vous mettez à jour votre fonction Lambda et lorsque des instances supplémentaires sont créées pour traiter plusieurs invocations simultanées. Pour trouver les journaux d'un appel spécifique, nous vous recommandons d'instrumenter votre fonction avec. AWS X-Ray X-Ray enregistre des détails sur la demande et le flux de journaux dans le suivi.

Afficher les journaux à l'aide de AWS Command Line Interface (AWS CLI)

AWS CLI Il s'agit d'un outil open source qui vous permet d'interagir avec les AWS services à l'aide de commandes dans votre interface de ligne de commande. Pour effectuer les étapes décrites dans cette section, vous devez disposer de la AWS CLI version 2.

Vous pouvez utiliser AWS CLI pour récupérer les journaux d’une invocation à l’aide de l’option de commande --log-type. La réponse inclut un champ LogResult qui contient jusqu’à 4 Ko de journaux codés en base64 provenant de l’invocation.

aws lambda invoke --function-name my-function out --log-type Tail

{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}

aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode

START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB

#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5

chmod -R 755 get-logs.sh

./get-logs.sh

{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Suppression de journaux

Les groupes de journaux ne sont pas supprimés automatiquement quand vous supprimez une fonction. Pour éviter de stocker des journaux indéfiniment, supprimez le groupe de journaux ou configurez une période de conservation à l’issue de laquelle les journaux sont supprimés automatiquement.