Log dan pantau fungsi Java Lambda

AWS Lambda secara otomatis memonitor fungsi Lambda dan mengirim entri log ke Amazon. CloudWatch Fungsi Lambda Anda dilengkapi dengan grup CloudWatch log Log dan aliran log untuk setiap instance fungsi Anda. Lingkungan runtime Lambda mengirimkan detail tentang setiap pemanggilan dan output lainnya dari kode fungsi Anda ke aliran log. Untuk informasi selengkapnya tentang CloudWatch Log, lihatMenggunakan CloudWatch Log dengan Lambda.

Untuk mengeluarkan log dari kode fungsi Anda, Anda dapat menggunakan metode di java.lang.System, atau modul logging apa pun yang menulis ke stdout atau stderr.

Membuat fungsi yang mengembalikan log

Untuk menghasilkan log dari kode fungsi, Anda dapat menggunakan metode di java.lang.System, atau modul pencatatan apa pun yang menulis ke stdout atau stderr. aws-lambda-java-corePustaka menyediakan kelas logger bernama LambdaLogger yang dapat Anda akses dari objek konteks. Kelas logger mendukung log beberapa baris.

Contoh berikut menggunakan logger LambdaLogger yang disediakan oleh objek konteks.

// Handler value: example.Handler
public class Handler implements RequestHandler<Object, String>{
  Gson gson = new GsonBuilder().setPrettyPrinting().create();
  @Override
  public String handleRequest(Object event, Context context)
  {
    LambdaLogger logger = context.getLogger();
    String response = new String("SUCCESS");
    // log execution details
    logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
    logger.log("CONTEXT: " + gson.toJson(context));
    // process event
    logger.log("EVENT: " + gson.toJson(event));
    return response;
  }
}

START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
ENVIRONMENT VARIABLES: 
{
    "_HANDLER": "example.Handler",
    "AWS_EXECUTION_ENV": "AWS_Lambda_java8",
    "AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
    ...
}
CONTEXT: 
{
    "memoryLimit": 512,
    "awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
    "functionName": "java-console",
    ...
}
EVENT:
{
  "records": [
    {
      "messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!",
       ...
    }
  ]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0	Duration: 198.50 ms	Billed Duration: 200 ms	Memory Size: 512 MB	Max Memory Used: 90 MB	Init Duration: 524.75 ms

Runtime Java mencatat baris START, END, dan REPORT untuk setiap invokasi. Baris laporan memberikan detail berikut:

Menggunakan kontrol logging lanjutan Lambda dengan Java

Untuk memberi Anda kontrol lebih besar atas bagaimana log fungsi Anda ditangkap, diproses, dan dikonsumsi, Anda dapat mengonfigurasi opsi logging berikut untuk runtime Java yang didukung:

Untuk informasi selengkapnya tentang opsi pencatatan ini, dan petunjuk tentang cara mengonfigurasi fungsi Anda untuk menggunakannya, lihatMengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda.

Untuk menggunakan format log dan opsi tingkat log dengan fungsi Java Lambda Anda, lihat panduan di bagian berikut.

Menggunakan format log JSON terstruktur dengan Java

Jika Anda memilih JSON untuk format log fungsi Anda, Lambda akan mengirim output log menggunakan kelas sebagai JSON LambdaLogger terstruktur. Setiap objek log JSON berisi setidaknya empat pasangan nilai kunci dengan kunci berikut:

Bergantung pada metode logging yang Anda gunakan, output log dari fungsi Anda yang ditangkap dalam format JSON juga dapat berisi pasangan nilai kunci tambahan.

Untuk menetapkan level ke log yang Anda buat menggunakan LambdaLogger logger, Anda perlu memberikan LogLevel argumen dalam perintah logging Anda seperti yang ditunjukkan pada contoh berikut.

LambdaLogger logger = context.getLogger();
logger.log("This is a debug log", LogLevel.DEBUG);

Output log ini dengan kode contoh ini akan ditangkap di CloudWatch Log sebagai berikut:

{
    "timestamp":"2023-11-01T00:21:51.358Z",
    "level":"DEBUG",
    "message":"This is a debug log",
    "AWSrequestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}

Jika Anda tidak menetapkan level ke output log Anda, Lambda akan secara otomatis menetapkannya INFO level.

Jika kode Anda sudah menggunakan pustaka logging lain untuk menghasilkan log terstruktur JSON, Anda tidak perlu membuat perubahan apa pun. Lambda tidak menyandikan dua kali log apa pun yang sudah dikodekan JSON. Bahkan jika Anda mengonfigurasi fungsi Anda untuk menggunakan format log JSON, output logging Anda muncul CloudWatch dalam struktur JSON yang Anda tentukan.

Menggunakan penyaringan tingkat log dengan Java

AWS Lambda Untuk memfilter log aplikasi Anda sesuai dengan tingkat lognya, fungsi Anda harus menggunakan log berformat JSON. Anda dapat mencapai ini dengan dua cara:

Ketika Anda mengonfigurasi fungsi Anda untuk menggunakan pemfilteran tingkat log, Anda harus memilih dari opsi berikut untuk tingkat log yang ingin Lambda kirim ke Log: CloudWatch

Agar Lambda dapat memfilter log fungsi Anda, Anda juga harus menyertakan pasangan nilai "timestamp" kunci dalam keluaran log JSON Anda. Waktu harus ditentukan dalam format stempel waktu RFC 3339 yang valid. Jika Anda tidak menyediakan stempel waktu yang valid, Lambda akan menetapkan log INFO level dan menambahkan stempel waktu untuk Anda.

Lambda mengirimkan log dari level yang dipilih dan lebih rendah ke. CloudWatch Misalnya, jika Anda mengonfigurasi level log WARN, Lambda akan mengirim log yang sesuai dengan level WARN, ERROR, dan FATAL.

Menerapkan logging lanjutan dengan Log4j2 dan J SLF4

Untuk menyesuaikan output log, mendukung pencatatan selama pengujian unit, dan log panggilan AWS SDK, gunakan Apache Log4j2 dengan J SLF4. Log4j adalah pustaka logging untuk program Java yang memungkinkan Anda mengonfigurasi level log dan menggunakan pustaka appender. SLF4J adalah pustaka fasad yang memungkinkan Anda mengubah pustaka mana yang Anda gunakan tanpa mengubah kode fungsi Anda.

Untuk menambahkan ID permintaan ke log fungsi Anda, gunakan appender di pustaka aws-lambda-java-log4j2.

<Configuration>
  <Appenders>
    <Lambda name="Lambda" format="${env:AWS_LAMBDA_LOG_FORMAT:-TEXT}">
       <LambdaTextFormat>
         <PatternLayout>
             <pattern>%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n </pattern>
         </PatternLayout>
       </LambdaTextFormat>
       <LambdaJSONFormat>
         <JsonTemplateLayout eventTemplateUri="classpath:LambdaLayout.json" />
       </LambdaJSONFormat>
     </Lambda>
   </Appenders>
   <Loggers>
     <Root level="${env:AWS_LAMBDA_LOG_LEVEL:-INFO}">
       <AppenderRef ref="Lambda"/>
     </Root>
     <Logger name="software.amazon.awssdk" level="WARN" />
     <Logger name="software.amazon.awssdk.request" level="DEBUG" />
   </Loggers>
 </Configuration>

Anda dapat memutuskan bagaimana log Log4j2 Anda dikonfigurasi untuk teks biasa atau output JSON dengan menentukan tata letak di bawah tag dan. <LambdaTextFormat> <LambdaJSONFormat>

Dalam contoh ini, dalam mode teks, setiap baris ditambahkan dengan tanggal, waktu, ID permintaan, tingkat log, dan nama kelas. Dalam mode JSON, <JsonTemplateLayout> digunakan dengan konfigurasi yang dikirimkan bersama dengan aws-lambda-java-log4j2 perpustakaan.

SLF4J adalah pustaka fasad untuk login dalam kode Java. Dalam kode fungsi Anda, Anda menggunakan pabrik SLF4 J logger untuk mengambil logger dengan metode untuk tingkat log seperti dan. info() warn() Dalam konfigurasi build, Anda menyertakan library logging dan adaptor SLF4 J di classpath. Dengan mengubah pustaka dalam konfigurasi build, Anda dapat mengubah jenis logger tanpa mengubah kode fungsi. SLF4J diperlukan untuk menangkap log dari SDK for Java.

Dalam contoh kode berikut, kelas handler menggunakan SLF4 J untuk mengambil logger.

package example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;

import static org.apache.logging.log4j.CloseableThreadContext.put;


public class HandlerS3 implements RequestHandler<S3Event, String>{
    private static final Logger logger = LoggerFactory.getLogger(HandlerS3.class);

    @Override
    public String handleRequest(S3Event event, Context context) {
        for(var record : event.getRecords()) {
            try (var loggingCtx = put("awsRegion", record.getAwsRegion())) {
                loggingCtx.put("eventName", record.getEventName());
                loggingCtx.put("bucket", record.getS3().getBucket().getName());
                loggingCtx.put("key", record.getS3().getObject().getKey());

                logger.info("Handling s3 event");
            }
        }

        return "Ok";
    }
}

Kode ini menghasilkan output log seperti berikut:

{
    "timestamp": "2023-11-15T16:56:00.815Z",
    "level": "INFO",
    "message": "Handling s3 event",
    "logger": "example.HandlerS3",
    "AWSRequestId": "0bced576-3936-4e5a-9dcd-db9477b77f97",
    "awsRegion": "eu-south-1",
    "bucket": "java-logging-test-input-bucket",
    "eventName": "ObjectCreated:Put",
    "key": "test-folder/"
}

Konfigurasi build mengambil dependensi runtime pada appender Lambda dan adaptor SLF4 J, dan dependensi implementasi pada Log4j2.

dependencies {
    ...
    'com.amazonaws:aws-lambda-java-log4j2:[1.6.0,)',
    'com.amazonaws:aws-lambda-java-events:[3.11.3,)',
    'org.apache.logging.log4j:log4j-layout-template-json:[2.17.1,)',
    'org.apache.logging.log4j:log4j-slf4j2-impl:[2.19.0,)',
    ...
}

Saat Anda menjalankan kode Anda secara lokal untuk pengujian, objek konteks dengan logger Lambda tidak tersedia, dan tidak ada ID permintaan untuk appender Lambda untuk digunakan. Misalnya konfigurasi uji, lihat aplikasi sampel di bagian berikutnya.

Menggunakan alat logging dan pustaka lainnya

Powertools for AWS Lambda (Java) adalah toolkit pengembang untuk mengimplementasikan praktik terbaik Tanpa Server dan meningkatkan kecepatan pengembang. Utilitas Logging menyediakan logger yang dioptimalkan Lambda yang mencakup informasi tambahan tentang konteks fungsi di semua fungsi Anda dengan output terstruktur sebagai JSON. Gunakan utilitas ini untuk melakukan hal berikut:

Menggunakan Powertools untuk AWS Lambda (Java) dan AWS SAM untuk logging terstruktur

Ikuti langkah-langkah di bawah ini untuk mengunduh, membangun, dan menyebarkan contoh aplikasi Hello World Java dengan Powertools terintegrasi untuk AWS Lambda (Java) ~ modul menggunakan modul. AWS SAM Aplikasi ini mengimplementasikan backend API dasar dan menggunakan Powertools untuk memancarkan log, metrik, dan jejak. Ini terdiri dari titik akhir Amazon API Gateway dan fungsi Lambda. Saat Anda mengirim permintaan GET ke titik akhir API Gateway, fungsi Lambda memanggil, mengirim log dan metrik menggunakan Format Metrik Tertanam CloudWatch ke, dan mengirimkan jejak ke. AWS X-Ray Fungsi mengembalikan hello world pesan.

Mengelola retensi log

Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log tanpa batas waktu, hapus grup log, atau konfigurasikan periode retensi setelah itu secara CloudWatch otomatis menghapus log. Untuk mengatur penyimpanan log, tambahkan yang berikut ini ke AWS SAM templat Anda:

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

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

Melihat log di konsol Lambda

Anda dapat menggunakan konsol Lambda untuk melihat output log setelah Anda memanggil fungsi Lambda.

Jika kode Anda dapat diuji dari editor Kode tertanam, Anda akan menemukan log dalam hasil eksekusi. Saat Anda menggunakan fitur pengujian konsol untuk menjalankan fungsi, Anda akan menemukan Keluaran Log di bagian Detail.

Melihat log di CloudWatch konsol

Anda dapat menggunakan CloudWatch konsol Amazon untuk melihat log untuk semua pemanggilan fungsi Lambda.

Setiap aliran log sesuai dengan instans fungsi Anda. Pengaliran log muncul saat Anda memperbarui fungsi Lambda dan saat instans tambahan dibuat untuk menangani beberapa invokasi bersamaan. Untuk menemukan log untuk pemanggilan tertentu, kami sarankan untuk menginstrumentasi fungsi Anda dengan. AWS X-Ray X-Ray mencatat detail tentang permintaan dan pengaliran log di jejak.

Melihat log menggunakan AWS Command Line Interface (AWS CLI)

AWS CLI Ini adalah alat sumber terbuka yang memungkinkan Anda berinteraksi dengan AWS layanan menggunakan perintah di shell baris perintah Anda. Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki AWS CLI versi 2.

Anda dapat menggunakan AWS CLI untuk mengambil log untuk invokasi menggunakan opsi perintah --log-type. Respons berisi bidang LogResult yang memuat hingga 4 KB log berkode base64 dari invokasi.

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

Menghapus log

Grup log tidak terhapus secara otomatis ketika Anda menghapus suatu fungsi. Untuk menghindari penyimpanan log secara tidak terbatas, hapus kelompok log, atau lakukan konfigurasi periode penyimpanan, yang setelahnya log akan dihapus secara otomatis.

Kode pencatatan sampel

GitHub Repositori untuk panduan ini mencakup contoh aplikasi yang menunjukkan penggunaan berbagai konfigurasi logging. Setiap contoh aplikasi menyertakan skrip untuk penyebaran dan pembersihan yang mudah, AWS SAM templat, dan sumber daya pendukung.

Aplikasi sampel java-basic menunjukkan konfigurasi pencatatan minimal yang mendukung uji pencatatan. Kode handler menggunakan logger LambdaLogger yang disediakan oleh objek konteks. Untuk pengujian, aplikasi menggunakan TestLogger kelas khusus yang mengimplementasikan LambdaLogger antarmuka dengan logger Log4j2. Ini menggunakan SLF4 J sebagai fasad untuk kompatibilitas dengan AWS SDK. Pustaka log masuk dikecualikan dari output pembuatan untuk menjaga paket deployment tetap kecil.