

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Log dan pantau fungsi C\$1 Lambda
<a name="csharp-logging"></a>

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, lihat[Mengirim log fungsi Lambda ke Log CloudWatch](monitoring-cloudwatchlogs.md).

**Topics**
+ [Membuat fungsi yang mengembalikan log](#csharp-logging-output)
+ [Menggunakan kontrol logging lanjutan Lambda dengan.NET](#csharp-logging-advanced)
+ [Alat dan pustaka pencatatan tambahan](#csharp-tools-libraries)
+ [Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk logging terstruktur](#dotnet-logging-sam)
+ [Melihat log di konsol Lambda](#csharp-logging-console)
+ [Melihat log di CloudWatch konsol](#csharp-logging-cwconsole)
+ [Melihat log menggunakan AWS Command Line Interface (AWS CLI)](#csharp-logging-cli)
+ [Menghapus log](#csharp-logging-delete)

## Membuat fungsi yang mengembalikan log
<a name="csharp-logging-output"></a>

Untuk mengeluarkan log dari kode fungsi, Anda dapat menggunakan [ILambdaLogger](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) pada objek konteks, metode di [kelas Console](https://docs.microsoft.com/en-us/dotnet/api/system.console), atau pustaka logging apa pun yang menulis ke `stdout` atau`stderr`.

Runtime .NET mencatat baris `START`, `END`, dan `REPORT` untuk setiap invokasi. Baris laporan memberikan perincian berikut.

**Laporkan bidang data baris**
+ **RequestId** – ID permintaan unik untuk invokasi.
+ **Durasi** – Jumlah waktu yang digunakan oleh metode handler fungsi Anda gunakan untuk memproses peristiwa.
+ **Durasi yang Ditagih** – Jumlah waktu yang ditagihkan untuk invokasi.
+ **Ukuran Memori** – Jumlah memori yang dialokasikan untuk fungsi.
+ **Memori Maks yang Digunakan** – Jumlah memori yang digunakan oleh fungsi. Saat pemanggilan berbagi lingkungan eksekusi, Lambda melaporkan memori maksimum yang digunakan di semua pemanggilan. Perilaku ini dapat menghasilkan nilai yang dilaporkan lebih tinggi dari yang diharapkan.
+ **Durasi Init** – Untuk permintaan pertama yang dilayani, lama waktu yang diperlukan runtime untuk memuat fungsi dan menjalankan kode di luar metode handler.
+ **XRAY TraceId** — Untuk permintaan yang dilacak, ID [AWS X-Ray jejak](services-xray.md).
+ **SegmentId** – Untuk permintaan yang dilacak, ID segmen X-Ray.
+ **Diambil Sampel** – Untuk permintaan yang dilacak, hasil pengambilan sampel.

## Menggunakan kontrol logging lanjutan Lambda dengan.NET
<a name="csharp-logging-advanced"></a>

Untuk memberi Anda kontrol lebih besar atas bagaimana log fungsi Anda ditangkap, diproses, dan digunakan, Anda dapat mengonfigurasi opsi logging berikut untuk runtime .NET yang didukung:
+ **Format log** - pilih antara teks biasa dan format JSON terstruktur untuk log fungsi Anda
+ **Tingkat log** - untuk log dalam format JSON, pilih tingkat detail log yang dikirim CloudWatch Lambda, seperti ERROR, DEBUG, atau INFO
+ **Grup log** - pilih grup CloudWatch log yang dikirimkan oleh fungsi Anda

Untuk informasi selengkapnya tentang opsi pencatatan ini, dan petunjuk tentang cara mengonfigurasi fungsi Anda untuk menggunakannya, lihat[Mengkonfigurasi kontrol logging lanjutan untuk fungsi Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

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

### Menggunakan format log JSON terstruktur dengan.NET
<a name="csharp-logging-advanced-JSON"></a>

Jika Anda memilih JSON untuk format log fungsi Anda, Lambda akan mengirim output log [ILambdamenggunakan](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) Logger sebagai JSON terstruktur. Setiap objek log JSON berisi setidaknya lima pasangan nilai kunci dengan kunci berikut:
+ `"timestamp"`- waktu pesan log dihasilkan
+ `"level"`- tingkat log yang ditetapkan untuk pesan
+ `"requestId"`- ID permintaan unik untuk pemanggilan fungsi
+ `"traceId"`- variabel `_X_AMZN_TRACE_ID` lingkungan
+ `"message"`- isi pesan log

`ILambdaLogger`Instance dapat menambahkan pasangan nilai kunci tambahan, misalnya saat mencatat pengecualian. Anda juga dapat menyediakan parameter tambahan Anda sendiri seperti yang dijelaskan di bagian ini[Parameter log yang disediakan pelanggan](#csharp-logging-advanced-JSON-user-supplied).

**catatan**  
Jika kode Anda sudah menggunakan pustaka logging lain untuk menghasilkan log berformat JSON, pastikan format log fungsi Anda disetel ke teks biasa. Menyetel format log ke JSON akan menghasilkan output log Anda dikodekan ganda.

Contoh perintah logging berikut menunjukkan cara menulis pesan log dengan tingkat`INFO`.

**Example Kode logging .NET**  

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

Anda juga dapat menggunakan metode log generik yang mengambil tingkat log sebagai argumen seperti yang ditunjukkan pada contoh berikut.

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

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

**Example Catatan log JSON**  

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

**catatan**  
Jika Anda mengonfigurasi format log fungsi Anda untuk menggunakan teks biasa daripada JSON, maka tingkat log yang ditangkap dalam pesan mengikuti konvensi Microsoft menggunakan label empat karakter. Misalnya, tingkat log `Debug` direpresentasikan dalam pesan sebagai`dbug`.  
Saat Anda mengonfigurasi fungsi Anda untuk menggunakan log berformat JSON, level log yang ditangkap di log menggunakan label lengkap seperti yang ditunjukkan pada contoh catatan log JSON.

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

#### Pengecualian logging di JSON
<a name="csharp-logging-advanced-JSON-exceptions"></a>

Saat menggunakan logging JSON terstruktur`ILambdaLogger`, Anda dapat mencatat pengecualian dalam kode Anda seperti yang ditunjukkan pada contoh berikut.

**Example penggunaan pencatatan pengecualian**  

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

Output format log oleh kode ini ditunjukkan dalam contoh berikut JSON. Perhatikan bahwa `message` properti di JSON diisi menggunakan argumen pesan yang disediakan dalam `LogWarning` panggilan, sedangkan `errorMessage` properti berasal dari `Message` properti pengecualian itu sendiri.

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-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>"]
}
```

Jika format logging fungsi Anda disetel ke JSON, Lambda juga mengeluarkan pesan log berformat JSON saat kode Anda melempar pengecualian yang tidak tertangkap. Contoh cuplikan kode berikut dan pesan log menunjukkan bagaimana pengecualian yang tidak tertangkap dicatat.

**Example kode pengecualian**  

```
throw new ApplicationException("Invalid data");
```

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-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>"]
}
```

#### Parameter log yang disediakan pelanggan
<a name="csharp-logging-advanced-JSON-user-supplied"></a>

Dengan pesan log berformat JSON, Anda dapat menyediakan parameter log tambahan dan memasukkannya ke dalam log. `message` Contoh cuplikan kode berikut menunjukkan perintah untuk menambahkan dua parameter yang disediakan pengguna berlabel dan. `retryAttempt` `uri` Dalam contoh, nilai parameter ini berasal dari `uriDestination` argumen `retryAttempt` dan diteruskan ke perintah logging.

**Example Perintah logging JSON dengan parameter tambahan**  

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

Output pesan log oleh perintah ini ditunjukkan dalam contoh berikut JSON.

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-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/"
}
```

**Tip**  
Anda juga dapat menggunakan properti posisi alih-alih nama saat menentukan parameter tambahan. Misalnya, perintah logging pada contoh sebelumnya juga dapat ditulis sebagai berikut:  

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

Perhatikan bahwa saat Anda menyediakan parameter logging tambahan, Lambda menangkapnya sebagai properti tingkat atas dalam catatan log JSON. Pendekatan ini berbeda dari beberapa pustaka logging .NET populer seperti`Serilog`, yang menangkap parameter tambahan dalam objek anak yang terpisah.

Jika argumen yang Anda berikan untuk parameter tambahan adalah objek yang kompleks, secara default Lambda menggunakan `ToString()` metode untuk memberikan nilai. Untuk menunjukkan bahwa argumen harus JSON serial, gunakan `@` awalan seperti yang ditunjukkan dalam cuplikan kode berikut. Dalam contoh ini, `User` adalah objek dengan `FirstName` dan `LastName` properti.

**Example Perintah logging JSON dengan objek serial JSON**  

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

Output pesan log oleh perintah ini ditunjukkan dalam contoh berikut JSON.

**Example Catatan log JSON**  

```
{
    "timestamp": "2025-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"
    }
}
```

Jika argumen untuk parameter tambahan adalah array atau mengimplementasikan `IList` atau`IDictionary`, maka Lambda menambahkan argumen ke pesan log JSON sebagai array seperti yang ditunjukkan dalam contoh berikut catatan log JSON. Dalam contoh ini, `{users}` mengambil `IList` argumen yang berisi contoh `User` properti dengan format yang sama seperti contoh sebelumnya. Lambda mengubah ini `IList` menjadi array, dengan setiap nilai yang dibuat menggunakan metode. `ToString`

**Example Catatan log JSON dengan argumen `IList`**  

```
{
    "timestamp": "2025-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"       
    ] 
}
```

Anda juga dapat membuat serial JSON daftar dengan menggunakan `@` awalan dalam perintah logging Anda. Dalam contoh catatan log JSON berikut, `users` properti adalah serial JSON.

**Example Catatan log JSON dengan argumen serial JSON `IList`**  

```
{
    "timestamp": "2025-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"
        }        
    ] 
}
```

### Menggunakan penyaringan tingkat log dengan.NET
<a name="csharp-logging-advanced-levels"></a>

Dengan mengonfigurasi penyaringan tingkat log, Anda dapat memilih untuk mengirim hanya log dengan tingkat detail tertentu atau lebih rendah ke Log. CloudWatch Untuk mempelajari cara mengonfigurasi pemfilteran tingkat log untuk fungsi Anda, lihat. [Pemfilteran tingkat log](monitoring-cloudwatchlogs-log-level.md)

 AWS Lambda Untuk memfilter pesan log Anda berdasarkan tingkat log, Anda dapat menggunakan log berformat JSON atau menggunakan `Console` metode.NET untuk menampilkan pesan log. Untuk membuat log berformat JSON, [konfigurasikan jenis log fungsi Anda ke JSON](monitoring-cloudwatchlogs-logformat.md#monitoring-cloudwatchlogs-set-format) dan gunakan instance. `ILambdaLogger`

Dengan log berformat JSON, Lambda memfilter output log Anda menggunakan pasangan nilai kunci “level” di objek JSON yang dijelaskan di. [Menggunakan format log JSON terstruktur dengan.NET](#csharp-logging-advanced-JSON)

Jika Anda menggunakan `Console` metode.NET untuk menulis pesan ke CloudWatch Log, Lambda menerapkan tingkat log ke pesan Anda sebagai berikut:
+ **Konsol. WriteLine **metode - Lambda menerapkan log-level `INFO`
+ **Metode Console.Error -** Lambda menerapkan log-level `ERROR`

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 Perhatikan pemetaan level log yang digunakan oleh Lambda dengan level Microsoft standar yang digunakan oleh.NET. `ILambdaLogger`


| Tingkat log Lambda | Level Microsoft yang setara | Penggunaan standar | 
| --- | --- | --- | 
| TRACE (paling detail) | Jejak | Informasi paling halus yang digunakan untuk melacak jalur eksekusi kode Anda | 
| DEBUG | Debug | Informasi terperinci untuk debugging sistem | 
| INFO | Informasi | Pesan yang merekam operasi normal fungsi Anda | 
| WARN | Peringatan | Pesan tentang potensi kesalahan yang dapat menyebabkan perilaku tak terduga jika tidak ditangani | 
| ERROR | Kesalahan | Pesan tentang masalah yang mencegah kode berfungsi seperti yang diharapkan | 
| FATAL (paling detail) | Kritis | Pesan tentang kesalahan serius yang menyebabkan aplikasi berhenti berfungsi | 

Lambda mengirimkan log dari tingkat detail 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.

## Alat dan pustaka pencatatan tambahan
<a name="csharp-tools-libraries"></a>

[Powertools for AWS Lambda (.NET)](https://docs.aws.amazon.com/powertools/dotnet/) adalah toolkit pengembang untuk mengimplementasikan praktik terbaik Tanpa Server dan meningkatkan kecepatan pengembang. [Utilitas Logging](https://docs.aws.amazon.com/powertools/dotnet/core/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:
+ Tangkap bidang kunci dari konteks Lambda, cold start, dan struktur logging output sebagai JSON
+ Log peristiwa pemanggilan Lambda saat diinstruksikan (dinonaktifkan secara default)
+ Cetak semua log hanya untuk persentase pemanggilan melalui pengambilan sampel log (dinonaktifkan secara default)
+ Tambahkan kunci tambahan ke log terstruktur kapan saja
+ Gunakan pemformat log kustom (Bring Your Own Formatter) untuk mengeluarkan log dalam struktur yang kompatibel dengan RFC Logging organisasi Anda

## Menggunakan Powertools untuk AWS Lambda (.NET) dan AWS SAM untuk logging terstruktur
<a name="dotnet-logging-sam"></a>

Ikuti langkah-langkah di bawah ini untuk mengunduh, membangun, dan menyebarkan contoh aplikasi Hello World C \$1 dengan [Powertools terintegrasi untuk modul AWS Lambda (.NET)](https://docs.powertools.aws.dev/lambda-dotnet) 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.

**Prasyarat**

Untuk menyelesaikan langkah-langkah di bagian ini, Anda harus memiliki hal-hal berikut:
+ .NET 8
+ [AWS CLI versi 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versi 1.75](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) atau yang lebih baru. Jika Anda memiliki versi CLI yang lebih lama, lihat [Memutakhirkan AWS SAM CLI. AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade)

**Menyebarkan aplikasi sampel AWS SAM**

1. Inisialisasi aplikasi menggunakan TypeScript template Hello World.

   ```
   sam init --app-template hello-world-powertools-dotnet --name sam-app --package-type Zip --runtime dotnet6 --no-tracing
   ```

1. Bangun aplikasi.

   ```
   cd sam-app && sam build
   ```

1. Terapkan aplikasi.

   ```
   sam deploy --guided
   ```

1. Ikuti petunjuk di layar. Untuk menerima opsi default yang disediakan dalam pengalaman interaktif, tekan`Enter`.
**catatan**  
Karena **HelloWorldFunction mungkin tidak memiliki otorisasi yang ditentukan, Apakah ini baik-baik saja?** , pastikan untuk masuk`y`.

1. Dapatkan URL aplikasi yang digunakan:

   ```
   aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
   ```

1. Memanggil titik akhir API:

   ```
   curl -X GET <URL_FROM_PREVIOUS_STEP>
   ```

   Jika berhasil, Anda akan melihat tanggapan ini:

   ```
   {"message":"hello world"}
   ```

1. Untuk mendapatkan log untuk fungsi tersebut, jalankan [log sam](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Untuk informasi selengkapnya, lihat [Bekerja dengan log](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) di *Panduan AWS Serverless Application Model Pengembang*.

   ```
   sam logs --stack-name sam-app
   ```

   Output log terlihat seperti ini:

   ```
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:27.988000 INIT_START Runtime Version: dotnet:6.v13        Runtime Version ARN: arn:aws:lambda:ap-southeast-2::runtime:699f346a05dae24c58c45790bc4089f252bf17dae3997e79b17d939a288aa1ec
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:28.229000 START RequestId: bed25b38-d012-42e7-ba28-f272535fb80e Version: $LATEST
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:29.259000 2025-09-20T14:15:29.201Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"_aws":{"Timestamp":1676902528962,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ColdStart","Unit":"Count"}],"Dimensions":[["FunctionName"],["Service"]]}]},"FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","Service":"PowertoolsHelloWorld","ColdStart":1}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.479000 2025-09-20T14:15:30.479Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"ColdStart":true,"XrayTraceId":"1-63f3807f-5dbcb9910c96f50742707542","CorrelationId":"d3d4de7f-4ccc-411a-a549-4d67b2fdc015","FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","FunctionVersion":"$LATEST","FunctionMemorySize":256,"FunctionArn":"arn:aws:lambda:ap-southeast-2:123456789012:function:sam-app-HelloWorldFunction-haKIoVeose2p","FunctionRequestId":"bed25b38-d012-42e7-ba28-f272535fb80e","Timestamp":"2025-09-20T14:15:30.4602970Z","Level":"Information","Service":"PowertoolsHelloWorld","Name":"AWS.Lambda.Powertools.Logging.Logger","Message":"Hello world API - HTTP 200"}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.599000 2025-09-20T14:15:30.599Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"_aws":{"Timestamp":1676902528922,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ApiRequestCount","Unit":"Count"}],"Dimensions":[["Service"]]}]},"Service":"PowertoolsHelloWorld","ApiRequestCount":1}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 END RequestId: bed25b38-d012-42e7-ba28-f272535fb80e
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 REPORT RequestId: bed25b38-d012-42e7-ba28-f272535fb80e  Duration: 2450.99 ms   Billed Duration: 2692 ms Memory Size: 256 MB     Max Memory Used: 74 MB  Init Duration: 240.05 ms
   XRAY TraceId: 1-63f3807f-5dbcb9910c96f50742707542       SegmentId: 16b362cd5f52cba0
   ```

1. Ini adalah titik akhir API publik yang dapat diakses melalui internet. Kami menyarankan Anda menghapus titik akhir setelah pengujian.

   ```
   sam delete
   ```

### Mengelola retensi log
<a name="csharp-log-retention"></a>

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
<a name="csharp-logging-console"></a>

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
<a name="csharp-logging-cwconsole"></a>

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

**Untuk melihat log di CloudWatch konsol**

1. Buka [halaman Grup log](https://console.aws.amazon.com/cloudwatch/home?#logs:) di CloudWatch konsol.

1. Pilih grup log untuk fungsi Anda (**/aws/lambda/ *your-function-name***).

1. Pilih pengaliran log.

Setiap aliran log sesuai dengan [instans fungsi Anda](lambda-runtime-environment.md). Aliran log muncul saat Anda memperbarui fungsi Lambda, dan saat instance tambahan dibuat untuk menangani pemanggilan 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)
<a name="csharp-logging-cli"></a>

 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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) untuk mengambil log untuk invokasi menggunakan opsi perintah `--log-type`. Respons berisi bidang `LogResult` yang memuat hingga 4 KB log berkode base64 dari invokasi.

**Example mengambil ID log**  
Contoh berikut menunjukkan cara mengambil *ID log* dari `LogResult` untuk fungsi bernama `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
Anda akan melihat output berikut:  

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

**Example mendekode log**  
Pada prompt perintah yang sama, gunakan utilitas `base64` untuk mendekodekan log. Contoh berikut menunjukkan cara mengambil log berkode base64 untuk `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
```
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 2*.  
Anda akan melihat output berikut:  

```
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
```
Utilitas `base64` tersedia di Linux, macOS, dan [Ubuntu pada Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Pengguna macOS mungkin harus menggunakan `base64 -D`.

**Example Skrip get-logs.sh**  
Pada prompt perintah yang sama, gunakan script berikut untuk mengunduh lima peristiwa log terakhir. Skrip menggunakan `sed` untuk menghapus kutipan dari file output, dan akan tidur selama 15 detik untuk memberikan waktu agar log tersedia. Output mencakup respons dari Lambda dan output dari perintah `get-log-events`.   
Salin konten dari contoh kode berikut dan simpan dalam direktori proyek Lambda Anda sebagai `get-logs.sh`.  
**cli-binary-format**Opsi ini diperlukan jika Anda menggunakan AWS CLI versi 2. Untuk menjadikan ini pengaturan default, jalankan`aws configure set cli-binary-format raw-in-base64-out`. Untuk informasi selengkapnya, lihat [opsi baris perintah global yang AWS CLI didukung](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) di *Panduan AWS Command Line Interface Pengguna untuk Versi 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
```

**Example macOS dan Linux (khusus)**  
Pada prompt perintah yang sama, pengguna macOS dan Linux mungkin perlu menjalankan perintah berikut untuk memastikan skrip dapat dijalankan.  

```
chmod -R 755 get-logs.sh
```

**Example mengambil lima log acara terakhir**  
Pada prompt perintah yang sama, gunakan skrip berikut untuk mendapatkan lima log acara terakhir.  

```
./get-logs.sh
```
Anda akan melihat output berikut:  

```
{
    "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
<a name="csharp-logging-delete"></a>

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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention), yang setelahnya log akan dihapus secara otomatis.