AWS Lambda Funktionsprotokollierung in Node.js - AWS Lambda
Erstellen einer Funktion, die Protokolle zurückgibtVerwenden von Lambda-Optionen für die erweiterte Protokollierung mit Node.jsVerwenden von Lambda-KonsoleVerwenden der Konsole CloudWatch Verwenden von () AWS Command Line InterfaceAWS CLILöschen von Protokollen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

AWS Lambda Funktionsprotokollierung in Node.js

AWS Lambda überwacht automatisch Lambda-Funktionen in Ihrem Namen und sendet Protokolle an Amazon CloudWatch. Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen finden Sie unter Verwenden von CloudWatch Amazon-Protokollen mit AWS Lambda.

Auf dieser Seite wird beschrieben, wie Sie eine Protokollausgabe aus dem Code Ihrer Lambda-Funktion erstellen oder mit der AWS Command Line Interface Lambda-Konsole oder der CloudWatch Konsole auf Logs zugreifen.

Erstellen einer Funktion, die Protokolle zurückgibt

Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie Methoden auf dem Konsolenobjekt oder eine Protokollierungsbibliothek verwenden, die zu stdout oder stderr schreibt. Das folgende Beispiel protokolliert die Werte der Umgebungsvariablen und des Ereignisobjekts.

Beispiel Datei index.js – Protokollierung
exports.handler = async function(event, context) {
  console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
  console.info("EVENT\n" + JSON.stringify(event, null, 2))
  console.warn("Event not processed.")
  return context.logStreamName
}
Beispiel Protokollformat
START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST
2019-06-07T19:11:20.562Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	ENVIRONMENT VARIABLES
{
  "AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
  "AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
  "AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
  "AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
  "AWS_LAMBDA_FUNCTION_NAME": "my-function",
  "PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
  "NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/node_modules",
  ...
}
2019-06-07T19:11:20.563Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	EVENT
{
  "key": "value"
}
2019-06-07T19:11:20.564Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	WARN	Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac	Duration: 128.83 ms	Billed Duration: 200 ms	Memory Size: 128 MB	Max Memory Used: 74 MB	Init Duration: 166.62 ms	XRAY TraceId: 1-5d9d007f-0a8c7fd02xmpl480aed55ef0	SegmentId: 3d752xmpl1bbe37e	Sampled: true

Die Node.js-Laufzeit protokolliert die Zeilen START, END, und REPORT für jeden Aufruf. Sie fügt jedem von der Funktion protokollierten Eintrag einen Zeitstempel, eine Anforderungs-ID und eine Protokollebene hinzu. Die Berichtszeile enthält die folgenden Details.

Datenfelder für REPORT-Zeilen

  • RequestId— Die eindeutige Anforderungs-ID für den Aufruf.

  • Dauer – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.

  • Fakturierte Dauer – Die für den Aufruf fakturierte Zeit.

  • Speichergröße – Die der Funktion zugewiesene Speichermenge.

  • Max. verwendeter Speicher – Die Speichermenge, die von der Funktion verwendet wird.

  • Initialisierungsdauer – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.

  • XRAY TraceId — Für verfolgte Anfragen die AWS X-Ray Trace-ID.

  • SegmentId— Für verfolgte Anfragen die X-Ray-Segment-ID.

  • Stichprobe – Bei verfolgten Anforderungen das Stichprobenergebnis.

Sie können Protokolle in der Lambda-Konsole, in der CloudWatch Logs-Konsole oder über die Befehlszeile anzeigen.

Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Node.js

Um Ihnen mehr Kontrolle darüber zu geben, wie die Protokolle Ihrer Funktionen erfasst, verarbeitet und verwendet werden, können Sie die folgenden Protokollierungsoptionen für unterstützte Node.js-Laufzeiten konfigurieren:

  • Protokollformat – Wählen Sie zwischen Klartext und einem strukturierten JSON-Format für die Protokolle Ihrer Funktion aus.

  • Protokollebene — für Logs im JSON-Format wählen Sie die Detailebene der Logs, die Lambda an Amazon sendet CloudWatch, wie ERROR, DEBUG oder INFO

  • Protokollgruppe — wählen Sie die CloudWatch Protokollgruppe aus, an die Ihre Funktion Protokolle sendet

Weitere Informationen zu diesen Protokollierungsoptionen und Anweisungen zur Konfiguration Ihrer Funktion für deren Verwendung finden Sie unter Konfigurieren erweiterter Protokollierungsoptionen für die Lambda-Funktion.

Informationen zur Verwendung der Optionen für das Protokollformat und die Protokollebene mit Ihren Node.js-Lambda-Funktionen finden Sie in den folgenden Abschnitten.

Verwenden strukturierter JSON-Protokolle mit Node.js

Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die Protokollausgabe mit den Konsolenmethodenconsole.trace,,console.debug, console.log console.infoconsole.error, und console.warn an CloudWatch als strukturiertes JSON. Jedes JSON-Protokollobjekt enthält mindestens vier Schlüssel-Wert-Paare mit den folgenden Schlüsseln:

  • "timestamp" – die Uhrzeit, zu der die Protokollmeldung generiert wurde

  • "level" – die der Meldung zugewiesene Protokollebene

  • "message" – der Inhalt der Protokollmeldung

  • "requestId" – die eindeutige Anforderungs-ID für den Funktionsaufruf

Abhängig von der Protokollierungsmethode, die Ihre Funktion verwendet, kann dieses JSON-Objekt auch zusätzliche Schlüsselpaare enthalten. Wenn Ihre Funktion beispielsweise console-Methoden verwendet, um Fehlerobjekte mit mehreren Argumenten zu protokollieren, enthält das JSON-Objekt zusätzliche Schlüssel-Wert-Paare mit den Schlüsseln errorMessage, errorType und stackTrace.

Wenn Ihr Code bereits eine andere Logging-Bibliothek wie Powertools for verwendet AWS Lambda, um strukturierte JSON-Logs zu erstellen, müssen Sie keine Änderungen vornehmen. Lambda codiert Protokolle, die bereits JSON-codiert sind, nicht doppelt, sodass die Anwendungsprotokolle Ihrer Funktion weiterhin wie zuvor erfasst werden.

Weitere Informationen zur Verwendung des Pakets Powertools for AWS Lambda Logging zur Erstellung strukturierter JSON-Logs in der Laufzeit von Node.js finden Sie unter. AWS Lambda Funktion einloggen TypeScript

Beispiel für Protokollausgaben im JSON-Format

Die folgenden Beispiele zeigen, wie verschiedene Protokollausgaben, die mithilfe der console Methoden mit einzelnen und mehreren Argumenten generiert wurden, in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion auf JSON setzen.

Im ersten Beispiel wird die console.error-Methode verwendet, um eine einfache Zeichenfolge auszugeben.

Beispiel Protokollcode für Node.js
export const handler = async (event) => {
  console.error("This is a warning message");
  ...
}
Beispiel JSON-Protokolldatensatz
{
    "timestamp":"2023-11-01T00:21:51.358Z",
    "level":"ERROR",
    "message":"This is a warning message",
    "requestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}

Sie können mit den console-Methoden auch komplexere strukturierte Protokollnachrichten ausgeben, indem Sie entweder einzelne oder mehrere Argumente verwenden. Im nächsten Beispiel verwenden Sie console.log, um zwei Schlüssel-Wert-Paare mit einem einzigen Argument auszugeben. Beachten Sie, dass das "message" Feld im JSON-Objekt, das Lambda an CloudWatch Logs sendet, nicht stringifiziert ist.

Beispiel Protokollcode für Node.js
export const handler = async (event) => {
  console.log({data: 12.3, flag: false});
  ...
}
Beispiel JSON-Protokolldatensatz
{
    "timestamp": "2023-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "data": 12.3,
        "flag": false
    }
}

Im nächsten Beispiel verwenden Sie erneut die console.log-Methode, um eine Protokollausgabe zu erstellen. Diesmal verwendet die Methode zwei Argumente, eine Map mit zwei Schlüssel-Wert-Paaren und eine identifizierende Zeichenfolge. Beachten Sie, dass Lambda in diesem Fall das Feld "message" in eine Zeichenfolge umwandelt, da Sie zwei Argumente angegeben haben.

Beispiel Protokollcode für Node.js
export const handler = async (event) => {
  console.log('Some object - ', {data: 12.3, flag: false});
  ...
}
Beispiel JSON-Protokolldatensatz
{
    "timestamp": "2023-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "Some object -  { data: 12.3, flag: false }"
}

Lambda weist Ausgaben, die mit console.log generiert wurden, der Protokollebene INFO zu.

Das letzte Beispiel zeigt, wie Fehlerobjekte mithilfe der Methoden in CloudWatch Logs ausgegeben werden können. console Beachten Sie, dass Lambda die Felder errorMessage, errorType und stackTrace zur Protokollausgabe hinzufügt, wenn Sie Fehlerobjekte mit mehreren Argumenten protokollieren.

Beispiel Protokollcode für Node.js
export const handler = async (event) => {
  let e1 = new ReferenceError("some reference error");
  let e2 = new SyntaxError("some syntax error");
  console.log(e1);
  console.log("errors logged - ", e1, e2);
};
Beispiel JSON-Protokolldatensatz
{
    "timestamp": "2023-12-08T23:21:04.632Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "errorType": "ReferenceError",
        "errorMessage": "some reference error",
        "stackTrace": [
            "ReferenceError: some reference error",
            "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
            "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
        ]
    }
}

{
    "timestamp": "2023-12-08T23:21:04.646Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "errors logged -  ReferenceError: some reference error\n    at Runtime.handler (file:///var/task/index.mjs:3:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29) SyntaxError: some syntax error\n    at Runtime.handler (file:///var/task/index.mjs:4:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29)",
    "errorType": "ReferenceError",
    "errorMessage": "some reference error",
    "stackTrace": [
        "ReferenceError: some reference error",
        "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
        "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
    ]
}

Bei der Protokollierung mehrerer Fehlertypen werden die zusätzlichen Felder errorMessage, errorType und stackTrace aus dem ersten Fehlertyp extrahiert, der an die console-Methode übergeben wurde.

Verwenden von Clientbibliotheken im Embedded Metric Format (EMF) mit strukturierten JSON-Protokollen

AWS stellt Open-Source-Clientbibliotheken für Node.js bereit, mit denen Sie Logs im Embedded Metric Format (EMF) erstellen können. Wenn Sie bereits über Funktionen verfügen, die diese Bibliotheken verwenden, und Sie das Protokollformat Ihrer Funktion in JSON ändern, werden die von Ihrem Code ausgegebenen Metriken CloudWatch möglicherweise nicht mehr erkannt.

Wenn Ihr Code derzeit EMF-Protokolle direkt mit console.log oder mithilfe von Powertools for AWS Lambda (TypeScript) ausgibt, können CloudWatch Sie diese auch nicht analysieren, wenn Sie das Protokollformat Ihrer Funktion in JSON ändern.

Wichtig

Um sicherzustellen, dass die EMF-Protokolle Ihrer Funktionen weiterhin ordnungsgemäß analysiert werden, aktualisieren Sie Ihre EMF- und Powertools for CloudWatch -Bibliotheken auf die neuesten Versionen. AWS Lambda Wenn Sie zum JSON-Protokollformat wechseln, empfehlen wir Ihnen zudem, Tests durchzuführen, um die Kompatibilität mit den eingebetteten Metriken Ihrer Funktion sicherzustellen. Wenn Ihr Code EMF-Protokolle direkt mit console.log ausgibt, ändern Sie Ihren Code so, dass diese Metriken direkt in stdout ausgegeben werden, wie im folgenden Codebeispiel gezeigt.

Beispiel Code, der eingebettete Metriken in stdout ausgibt
process.stdout.write(JSON.stringify(
    {
        "_aws": {
            "Timestamp": Date.now(),
            "CloudWatchMetrics": [{
                "Namespace": "lambda-function-metrics",
                "Dimensions": [["functionVersion"]],
                "Metrics": [{
                    "Name": "time",
                    "Unit": "Milliseconds",
                    "StorageResolution": 60
                }]
            }]
        },
        "functionVersion": "$LATEST",
        "time": 100,
        "requestId": context.awsRequestId
    }
) + "\n")

Verwenden der Filterung auf Protokollebene mit Node.js

AWS Lambda Um Ihre Anwendungsprotokolle nach ihrer Protokollebene zu filtern, muss Ihre Funktion Protokolle im JSON-Format verwenden. Sie können dies auf zwei Arten erreichen:

  • Erstellen Sie Protokollausgaben mit den Standardmethoden der Konsole und konfigurieren Sie Ihre Funktion so, dass sie die JSON-Protokollformatierung verwendet. AWS Lambda filtert dann Ihre Protokollausgaben mithilfe des Schlüsselwertpaars „Level“ im JSON-Objekt, wie unter beschriebenVerwenden strukturierter JSON-Protokolle mit Node.js. Informationen zur Konfiguration des Protokollformats Ihrer Funktion finden Sie unter Konfigurieren erweiterter Protokollierungsoptionen für die Lambda-Funktion.

  • Verwenden Sie eine andere Protokollierungsbibliothek oder Methode, um strukturierte JSON-Protokolle in Ihrem Code zu erstellen, die ein „level“-Schlüssel-Wert-Paar enthalten, das die Ebene der Protokollausgabe definiert. Sie können Powertools zum Beispiel verwenden, AWS Lambda um strukturierte JSON-Protokollausgaben aus Ihrem Code zu generieren. Weitere Informationen zur Verwendung von Powertools mit der Laufzeit Node.js finden Sie unter AWS Lambda Funktion einloggen TypeScript.

    Damit Lambda die Protokolle Ihrer Funktion filtern kann, müssen Sie auch ein "timestamp"-Schlüssel-Wert-Paar in Ihre JSON-Protokollausgabe aufnehmen. Die Uhrzeit muss im gültigen RFC 3339-Zeitstempelformat angegeben werden. Wenn Sie keinen gültigen Zeitstempel angeben, weist Lambda dem Protokoll die Stufe INFO zu und fügt einen Zeitstempel für Sie hinzu.

Wenn Sie Ihre Funktion für die Filterung auf Protokollebene konfigurieren, wählen Sie aus den folgenden Optionen die Ebene der CloudWatch Protokolle aus AWS Lambda , die Sie an Logs senden möchten:

Protokollebene Standardnutzung
TRACE (am detailliertesten) Die detailliertesten Informationen, die verwendet werden, um den Ausführungspfad Ihres Codes nachzuverfolgen
DEBUG Detaillierte Informationen für das System-Debugging
INFO Meldungen, die den normalen Betrieb Ihrer Funktion erfassen
WARN Meldungen über mögliche Fehler, die zu unerwartetem Verhalten führen können, wenn sie nicht behoben werden
ERROR Meldungen über Probleme, die verhindern, dass der Code wie erwartet funktioniert
FATAL (am wenigsten Details) Meldungen über schwerwiegende Fehler, die dazu führen, dass die Anwendung nicht mehr funktioniert

Lambda sendet Protokolle der ausgewählten Stufe und niedriger bis CloudWatch. Wenn Sie beispielsweise die Protokollebene WARN konfigurieren, sendet Lambda Protokolle, die den Stufen WARN, ERROR und FATAL entsprechen.

Verwenden von Lambda-Konsole

Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.

Wenn Ihr Code über den eingebetteten Code-Editor getestet werden kann, finden Sie Protokolle in den Ausführungsergebnissen. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die Protokollausgabe im Abschnitt Details.

Verwenden der Konsole CloudWatch

Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufe anzuzeigen.

Um Protokolle auf der Konsole anzuzeigen CloudWatch

  1. Öffnen Sie die Seite Protokollgruppen auf der CloudWatch Konsole.

  2. Wählen Sie die Protokollgruppe Ihrer Funktion aus (/aws/lambda/your-function-name).

  3. Wählen Sie eine Protokollstream aus.

Jeder Protokoll-Stream entspricht einer Instance Ihrer Funktion. Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren, und wenn zusätzliche Instances zum Umgang mit mehreren gleichzeitigen Aufrufen erstellt werden. Um Protokolle für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.

Verwenden von () AWS Command Line InterfaceAWS CLI

Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

Sie können die AWS CLI verwenden, um Protokolle für einen Aufruf mit der --log-type-Befehlsoption abzurufen. Die Antwort enthält das Feld LogResult, das bis zu 4 KB base64-verschlüsselte Protokolle aus dem Aufruf enthält.

Beispiel eine Log-ID abrufen

Das folgende Beispiel zeigt, wie eine Protokoll-ID aus dem LogResult-Feld für eine Funktion namens my-function abgerufen wird.

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

Die Ausgabe sollte folgendermaßen aussehen:

{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
Beispiel entschlüsseln der Protokolle

Verwenden Sie in derselben Eingabeaufforderung das base64-Dienstprogramm, um die Protokolle zu entschlüsseln. Das folgende Beispiel zeigt, wie Base64-codierte Logs für abgerufen werde my-function.

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

Die cli-binary-format Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter Von AWS CLI unterstützte globale Befehlszeilenoptionen im AWS Command Line Interface -Benutzerhandbuch für Version 2.

Die Ausgabe sollte folgendermaßen aussehen:

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

Das base64-Dienstprogramm ist unter Linux, macOS und Ubuntu auf Windowsverfügbar. macOS-Benutzer müssen möglicherweise base64 -D verwenden.

Beispiel get-logs.sh-Skript

Verwenden Sie in derselben Eingabeaufforderung das folgende Skript, um die letzten fünf Protokollereignisse herunterzuladen. Das Skript verwendet sed zum Entfernen von Anführungszeichen aus der Ausgabedatei und wechselt 15 Sekunden lang in den Ruhezustand, um Zeit einzuräumen, damit Protokolle verfügbar werden können. Die Ausgabe enthält die Antwort von Lambda und die get-log-eventsAusgabe des Befehls.

Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es in Ihrem Lambda-Projektverzeichnis unter get-logs.sh.

Die cli-binary-format Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter Von AWS CLI unterstützte globale Befehlszeilenoptionen im AWS Command Line Interface -Benutzerhandbuch für Version 2.

#!/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
Beispiel macOS und Linux (nur diese Systeme)

In derselben Eingabeaufforderung müssen macOS- und Linux-Benutzer möglicherweise den folgenden Befehl ausführen, um sicherzustellen, dass das Skript ausführbar ist.

chmod -R 755 get-logs.sh
Beispiel die letzten fünf Protokollereignisse abrufen

Führen Sie an derselben Eingabeaufforderung das folgende Skript aus, um die letzten fünf Protokollereignisse abzurufen.

./get-logs.sh

Die Ausgabe sollte folgendermaßen aussehen:

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

Löschen von Protokollen

Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um das unbegrenzte Speichern von Protokollen zu vermeiden, löschen Sie die Protokollgruppe oder konfigurieren Sie eine Aufbewahrungszeitraum nach dem Protokolle automatisch gelöscht werden.