Log dan pantau fungsi Java Lambda

AWS Lambda secara otomatis memonitor fungsi Lambda dan mengirimkan 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, lihatMengirim log fungsi Lambda ke CloudWatch Log.

Untuk menampilkan 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. Pustaka aws-lambda-java-core 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: 724 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 lebih banyak kontrol 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 mengirimkan output log menggunakan LambdaLogger kelas sebagai JSON terstruktur. Setiap objek log JSON berisi setidaknya empat pasangan nilai kunci dengan kunci berikut:

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

Untuk menetapkan level untuk log yang Anda buat menggunakan LambdaLogger logger, Anda perlu memberikan LogLevel argumen dalam perintah logging Anda seperti yang ditunjukkan dalam 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 secara otomatis menetapkan level INFO.

Jika kode Anda sudah menggunakan pustaka logging lain untuk menghasilkan log terstruktur JSON, Anda tidak perlu membuat perubahan apa pun. Lambda tidak mengkodekan ulang 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 log mereka, fungsi Anda harus menggunakan log berformat JSON. Anda dapat mencapai ini dengan dua cara:

Saat mengonfigurasi fungsi untuk menggunakan penyaringan 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 output log JSON Anda. Waktu harus ditentukan dalam format stempel waktu RFC 3339 yang valid. Jika Anda tidak memberikan stempel waktu yang valid, Lambda menetapkan log level INFO 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 mengirimkan log yang sesuai dengan level WARN, ERROR, dan FATAL.

Menerapkan logging lanjutan dengan Log4j2 dan SLF4J

Untuk menyesuaikan output log, mendukung logging selama pengujian unit, dan panggilan log AWS SDK, gunakan Apache Log4j2 dengan SLF4J. Log4j adalah pustaka logging untuk program Java yang dapat Anda gunakan untuk mengkonfigurasi level log dan menggunakan pustaka appender. SLF4J adalah pustaka fasad yang dapat Anda gunakan untuk 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 diawali dengan tanggal, waktu, ID permintaan, tingkat log, dan nama kelas. Dalam mode JSON, <JsonTemplateLayout> digunakan dengan konfigurasi yang dikirimkan bersama dengan per aws-lambda-java-log4j2 pustakaan.

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

Dalam kode contoh berikut, kelas handler menggunakan SLF4J 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 SLF4J, 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 dan pustaka logging lainnya

Powertools for AWS Lambda (Java) adalah toolkit pengembang untuk mengimplementasikan praktik terbaik Tanpa Server dan meningkatkan kecepatan pengembang. Utilitas Log ging 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 (Jawa) dan AWS SAM untuk logging terstruktur

Ikuti langkah-langkah di bawah ini untuk mengunduh, membangun, dan menerapkan contoh aplikasi Hello World Java dengan modul Powertools untuk AWS Lambda (Java) terintegrasi menggunakan. 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, mengirimkan log dan metrik menggunakan Format Metrik Tertanam ke CloudWatch, 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 yang setelah CloudWatch itu secara otomatis menghapus log. Untuk mengatur retensi log, tambahkan yang berikut ini ke AWS SAM template 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 yang disematkan, Anda menemukan log dalam hasil eksekusi. Saat Anda menggunakan fitur pengujian konsol untuk memanggil fungsi, Anda 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. Aliran log muncul saat Anda memperbarui fungsi Lambda Anda, dan ketika instance tambahan dibuat untuk menangani pemanggilan bersamaan. Untuk menemukan log untuk pemanggilan tertentu, sebaiknya instrumentasikan fungsi Anda dengan. AWS X-Ray X-Ray merekam detail tentang permintaan dan aliran log di jejak.

Melihat log menggunakan AWS Command Line Interface (AWS CLI)

Ini AWS CLI adalah alat sumber terbuka yang dapat Anda gunakan untuk 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

Re GitHub positori untuk panduan ini mencakup contoh aplikasi yang menunjukkan penggunaan berbagai konfigurasi logging. Setiap contoh aplikasi menyertakan skrip untuk penerapan dan pembersihan yang mudah, AWS SAM template, 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 kustom yang mengimplementasikan LambdaLogger antarmuka dengan Log4j2 logger. Ini menggunakan SLF4J sebagai fasad untuk kompatibilitas dengan SDK. AWS Pustaka log masuk dikecualikan dari output pembuatan untuk menjaga paket deployment tetap kecil.