Ruby-Lambda-Funktionen protokollieren und überwachen

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 Senden von Lambda-Funktionsprotokollen an CloudWatch Logs.

Auf dieser Seite wird beschrieben, wie Sie eine Protokollausgabe aus dem Code Ihrer Lambda-Funktion erstellen und mithilfe 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 puts-Anweisungen verwenden oder eine Protokollierungsbibliothek, die zu stdout oder stderr schreibt. Das folgende Beispiel protokolliert die Werte der Umgebungsvariablen und dem Ereignisobjekt.

# lambda_function.rb

def handler(event:, context:)
    puts "## ENVIRONMENT VARIABLES"
    puts ENV.to_a
    puts "## EVENT"
    puts event.to_a
end

START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95  Duration: 15.74 ms  Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1   SegmentId: 07f5xmpl2d1f6f85 Sampled: true   

Die Ruby-Laufzeit protokolliert die Zeilen START, END und REPORT für jeden Aufruf. Die Berichtszeile enthält die folgenden Details.

Für detailliertere Protokolle verwenden Sie die Arbeiten mit der Ruby-Logger-Bibliothek.

Erweiterte Lambda-Logging-Kontrollen mit Ruby verwenden

Um Ihnen mehr Kontrolle darüber zu geben, wie die Logs Ihrer Funktionen erfasst, verarbeitet und genutzt werden, bietet Lambda mit Ruby erweiterte Logging-Kontrollen. Für Laufzeiten von Ruby 4.0 und höher können Sie die folgenden Protokollierungsoptionen konfigurieren:

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

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

Strukturierte JSON-Logs mit Ruby verwenden

Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die von der Logger Ruby-Standardbibliothek ausgegebenen Protokolle CloudWatch als strukturiertes JSON an. Jedes JSON-Protokollobjekt enthält mindestens vier Schlüssel-Wert-Paare mit den folgenden Schlüsseln:

Die Logger Ruby-Bibliothek kann auch zusätzliche Schlüsselwertpaare hinzufügen, z. B. "logger" zu diesem JSON-Objekt.

Die Beispiele in den folgenden Abschnitten zeigen, wie mit der Logger Ruby-Bibliothek generierte Protokollausgaben in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion als JSON konfigurieren.

Beachten Sie, dass Lambda, wenn Sie die puts Methode verwenden, um grundlegende Protokollausgaben zu erzeugenErstellen einer Funktion, die Protokolle zurückgibt, wie unter beschrieben, diese Ausgaben als Klartext erfasst, auch wenn Sie das Logging-Format Ihrer Funktion als JSON konfigurieren.

Standard-JSON-Protokollausgaben mithilfe der Ruby Logger-Bibliothek

Der folgende Beispielcodeausschnitt und die Protokollausgabe zeigen, wie mit der Logger Ruby-Bibliothek generierte Standardprotokollausgaben in CloudWatch Logs erfasst werden, wenn das Protokollformat Ihrer Funktion auf JSON gesetzt ist.

require 'logger'

def lambda_handler(event:, context:)
  logger = Logger.new($stdout)
  logger.info("Inside the handler function")
end

{
    "timestamp": "2025-10-27T19:17:45.586Z",
    "level": "INFO",
    "message": "Inside the handler function",
    "requestId": "79b4f56e-95b1-4643-9700-2807f4e68189"
}

Protokollieren zusätzlicher Parameter in JSON

Wenn das Protokollformat Ihrer Funktion auf JSON gesetzt ist, können Sie auch zusätzliche Parameter mit der Logger Ruby-Bibliothek protokollieren, indem Sie einen Hash mit zusätzlichen Schlüsselwertpaaren an die Protokollausgabe übergeben.

require 'logger'
require 'json'

def lambda_handler(event:, context:)
  logger = Logger.new($stdout)
  extra_params = { "a" => "b", "b" => [3] }
  logger.info({ message: "extra parameters example" }.merge(extra_params).to_json)
end

{
    "timestamp": "2025-11-02T15:26:28Z",
    "level": "INFO",
    "message": "extra parameters example",
    "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
    "a": "b",
    "b": [
        3
    ]
}

Protokollierungsausnahmen in JSON

Der folgende Codeausschnitt zeigt, wie Ruby-Ausnahmen in der Protokollausgabe Ihrer Funktion erfasst werden, wenn Sie das Protokollformat als JSON konfigurieren. Beachten Sie, dass Protokollausgaben, die logger.error mit einer Ausnahme generiert wurden, der Log-Level ERROR zugewiesen wird.

require 'logger'

def lambda_handler(event:, context:)
  logger = Logger.new($stdout)
  begin
    raise "exception"
  rescue => e
    logger.error(e)
  end
end

{
    "timestamp": "2025-11-02T16:18:57Z",
    "level": "ERROR",
    "message": "exception",
    "stackTrace": [
        "  /var/task/lambda_function.rb:4:in `lambda_handler'"
    ],
    "errorType": "RuntimeError",
    "errorMessage": "exception",
    "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
    "location": "/var/task/lambda_function.rb:lambda_handler:6"
}

Verwendung der Filterung auf Protokollebene mit Ruby

Durch die Konfiguration der Filterung auf Protokollebene können Sie festlegen, dass nur Protokolle mit einer bestimmten Protokollebene oder niedriger an Logs gesendet werden. CloudWatch Informationen zur Konfiguration der Filterung auf Protokollebene für Ihre Funktion finden Sie unter Log-level filtern.

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:

Sie können auch eine puts Anweisung verwenden, um ein JSON-Objekt auszugeben, das eine Kennung auf Protokollebene enthält. Die folgende puts Anweisung erzeugt eine Ausgabe im JSON-Format, bei der die Protokollebene auf INFO gesetzt ist. AWS Lambda sendet das JSON-Objekt an CloudWatch Logs, wenn die Protokollierungsebene Ihrer Funktion auf INFO, DEBUG oder TRACE gesetzt ist.

puts '{"msg":"My log message", "level":"info"}'

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.

Verwenden Sie eine alternative Logging-Bibliothek

Wenn Sie eine benutzerdefinierte Version der logger Bibliothek verwenden müssen, können Sie sie in Ihr Bereitstellungspaket oder in eine Lambda-Schicht aufnehmen und die RUBYLIB Umgebungsvariable auf das lib Verzeichnis der Bibliothek setzen. Die Lambda-Laufzeit lädt Ihre Version anstelle der gebündelten.

Wenn Ihr Code bereits eine andere Logging-Bibliothek verwendet, um strukturierte JSON-Logs zu erstellen, müssen Sie keine Änderungen vornehmen. AWS Lambda codiert keine Logs doppelt, die bereits JSON-kodiert sind. Selbst wenn Sie Ihre Funktion so konfigurieren, dass sie das JSON-Protokollformat verwendet, erscheinen Ihre Logging-Ausgaben CloudWatch in der von Ihnen definierten JSON-Struktur.

Anzeigen von Protokollen in der 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.

Logs in der CloudWatch Konsole anzeigen

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

Jeder Protokoll-Stream entspricht einer Instance Ihrer Funktion. Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instanzen für gleichzeitige Aufrufe erstellt werden. Um Logs für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray zeichnet Details über die Anfrage und den Protokollstream im Trace auf.

Logs mit der AWS Command Line Interface (AWS CLI) anzeigen

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 AWS CLI Version 2.

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.

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

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.

Arbeiten mit der Ruby-Logger-Bibliothek

Die Ruby-Logger-Bibliothek gibt optimierte Protokolle zurück, die leicht zu lesen sind. Verwenden Sie das Logger-Serviceprogramm, um detaillierte Informationen, Meldungen und Fehlercodes im Zusammenhang mit Ihrer Funktion auszugeben.

# lambda_function.rb

require 'logger'

def handler(event:, context:) 
  logger = Logger.new($stdout)
  logger.info('## ENVIRONMENT VARIABLES')
  logger.info(ENV.to_a)
  logger.info('## EVENT')
  logger.info(event)
  event.to_a
end

Die Ausgabe aus logger umfasst die Protokollebene, den Zeitstempel und die Anforderungs-ID.

START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO]  2020-01-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## ENVIRONMENT VARIABLES

[INFO]  2020-01-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function', 'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d', 'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})

[INFO]  2020-01-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## EVENT

[INFO]  2020-01-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    {'key': 'value'}

END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125  Duration: 2.75 ms   Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370   SegmentId: 073cxmpl3e442861 Sampled: true