Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengakses data telemetri real-time untuk ekstensi menggunakan API Telemetri
API Telemetri memungkinkan ekstensi Anda menerima data telemetri langsung dari Lambda. Selama inisialisasi dan pemanggilan fungsi, Lambda secara otomatis menangkap telemetri, termasuk log, metrik platform, dan jejak platform. API Telemetri memungkinkan ekstensi untuk mengakses data telemetri ini langsung dari Lambda dalam waktu dekat.
Dalam lingkungan eksekusi Lambda, Anda dapat berlangganan ekstensi Lambda Anda ke aliran telemetri. Setelah berlangganan, Lambda secara otomatis mengirimkan semua data telemetri ke ekstensi Anda. Anda kemudian memiliki fleksibilitas untuk memproses, memfilter, dan mengirimkan data ke tujuan pilihan Anda, seperti bucket Amazon Simple Storage Service (Amazon S3) atau penyedia alat observabilitas pihak ketiga.
Diagram berikut menunjukkan bagaimana Extensions API dan Telemetry API menghubungkan ekstensi ke Lambda dari dalam lingkungan eksekusi. Selain itu, Runtime API menghubungkan runtime dan fungsi Anda ke Lambda.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/telemetry-api-concept-diagram.png)
**penting**
API Telemetri Lambda menggantikan API Lambda Logs. **Meskipun API Log tetap berfungsi penuh, kami sarankan hanya menggunakan API Telemetri di masa mendatang.** Anda dapat berlangganan ekstensi Anda ke aliran telemetri menggunakan API Telemetri atau API Log. Setelah berlangganan menggunakan salah satu dari ini APIs, setiap upaya untuk berlangganan menggunakan API lain mengembalikan kesalahan.
**Persyaratan versi skema Instans Terkelola Lambda**
Instans Terkelola Lambda hanya mendukung versi `2025-01-29` skema API Telemetri. Saat berlangganan aliran telemetri untuk fungsi Instans Terkelola, Anda **harus** menggunakannya `"schemaVersion": "2025-01-29"` dalam permintaan langganan. Menggunakan versi skema sebelumnya akan mengakibatkan peristiwa ditolak oleh Lambda.
Versi `2025-01-29` skema kompatibel ke belakang dan dapat digunakan dengan fungsi Lambda Managed Instances dan Lambda (default). Sebaiknya gunakan versi ini untuk semua ekstensi baru guna memastikan kompatibilitas di kedua model penerapan.
Ekstensi dapat menggunakan API Telemetri untuk berlangganan tiga aliran telemetri yang berbeda:
+ **Telemetri platform** — Log, metrik, dan jejak, yang menjelaskan peristiwa dan kesalahan yang terkait dengan siklus hidup runtime lingkungan eksekusi, siklus hidup ekstensi, dan pemanggilan fungsi.
+ **Log fungsi** - Log khusus yang dihasilkan oleh kode fungsi Lambda.
+ **Log ekstensi** - Log khusus yang dihasilkan oleh kode ekstensi Lambda.
**catatan**
Lambda mengirimkan log dan metrik ke CloudWatch, dan melacak ke X-Ray (jika Anda telah mengaktifkan penelusuran), bahkan jika ekstensi berlangganan aliran telemetri.
**Topics**
+ [
## Membuat ekstensi menggunakan API Telemetri
](#telemetry-api-creating-extensions)
+ [
## Mendaftarkan ekstensi Anda
](#telemetry-api-registration)
+ [
## Membuat pendengar telemetri
](#telemetry-api-listener)
+ [
## Menentukan protokol tujuan
](#telemetry-api-destination)
+ [
## Mengkonfigurasi penggunaan memori dan buffering
](#telemetry-api-buffering)
+ [
## Mengirim permintaan berlangganan ke API Telemetri
](#telemetry-api-subscription)
+ [
## Pesan API Telemetri Masuk
](#telemetry-api-messages)
+ [
# Referensi API Telemetri Lambda
](telemetry-api-reference.md)
+ [
# Referensi skema API Telemetri Lambda `Event`
](telemetry-schema-reference.md)
+ [
# Mengonversi objek API `Event` Telemetri Lambda ke Span OpenTelemetry
](telemetry-otel-spans.md)
+ [
# Menggunakan Lambda Logs API
](runtimes-logs-api.md)
## Membuat ekstensi menggunakan API Telemetri
Ekstensi Lambda berjalan sebagai proses independen di lingkungan eksekusi. Ekstensi dapat terus berjalan setelah pemanggilan fungsi selesai. Karena ekstensi adalah proses yang terpisah, Anda dapat menulisnya dalam bahasa yang berbeda dari kode fungsi. Kami merekomendasikan menulis ekstensi menggunakan bahasa yang dikompilasi seperti Golang atau Rust. Dengan cara ini, ekstensi adalah biner mandiri yang dapat kompatibel dengan runtime yang didukung.
Diagram berikut menggambarkan proses empat langkah untuk membuat ekstensi yang menerima dan memproses data telemetri menggunakan API Telemetri.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/telemetry-api-creation-steps.png)
Berikut adalah setiap langkah secara lebih rinci:
1. Daftarkan ekstensi Anda menggunakan[Menggunakan API Ekstensi Lambda untuk membuat ekstensi](runtimes-extensions-api.md). Ini memberi Anda`Lambda-Extension-Identifier`, yang Anda perlukan dalam langkah-langkah berikut. Untuk informasi selengkapnya tentang cara mendaftarkan ekstensi Anda, lihat[Mendaftarkan ekstensi Anda](#telemetry-api-registration).
1. Buat pendengar telemetri. Ini bisa berupa server HTTP atau TCP dasar. Lambda menggunakan URI pendengar telemetri untuk mengirim data telemetri ke ekstensi Anda. Untuk informasi selengkapnya, lihat [Membuat pendengar telemetri](#telemetry-api-listener).
1. Menggunakan Subscribe API di API Telemetri, berlangganan ekstensi Anda ke aliran telemetri yang diinginkan. Anda akan memerlukan URI pendengar telemetri Anda untuk langkah ini. Untuk informasi selengkapnya, lihat [Mengirim permintaan berlangganan ke API Telemetri](#telemetry-api-subscription).
1. Dapatkan data telemetri dari Lambda melalui pendengar telemetri. Anda dapat melakukan pemrosesan kustom data ini, seperti mengirimkan data ke Amazon S3 atau ke layanan observabilitas eksternal.
**catatan**
[Lingkungan eksekusi fungsi Lambda dapat dimulai dan berhenti beberapa kali sebagai bagian dari siklus hidupnya.](runtimes-extensions-api.md#runtimes-extensions-api-lifecycle) Secara umum, kode ekstensi Anda berjalan selama pemanggilan fungsi, dan juga hingga 2 detik selama fase shutdown. Kami merekomendasikan pengelompokan telemetri saat sampai ke pendengar Anda. Kemudian, gunakan peristiwa `Invoke` dan `Shutdown` siklus hidup untuk mengirim setiap batch ke tujuan yang diinginkan.
## Mendaftarkan ekstensi Anda
Sebelum Anda dapat berlangganan data telemetri, Anda harus mendaftarkan ekstensi Lambda Anda. Registrasi terjadi selama [fase inisialisasi ekstensi](runtimes-extensions-api.md#runtimes-extensions-api-reg). Contoh berikut menunjukkan permintaan HTTP untuk mendaftarkan ekstensi.
```
POST http://${AWS_LAMBDA_RUNTIME_API}/2020-01-01/extension/register
Lambda-Extension-Name: lambda_extension_name
{
'events': [ 'INVOKE', 'SHUTDOWN']
}
```
Jika permintaan berhasil, pelanggan akan menerima respons keberhasilan HTTP 200. Header respon berisi file`Lambda-Extension-Identifier`. Badan respons mengandung sifat lain dari fungsi tersebut.
```
HTTP/1.1 200 OK
Lambda-Extension-Identifier: a1b2c3d4-5678-90ab-cdef-EXAMPLE11111
{
"functionName": "lambda_function",
"functionVersion": "$LATEST",
"handler": "lambda_handler",
"accountId": "123456789012"
}
```
Untuk informasi selengkapnya, lihat [Referensi API ekstensi](runtimes-extensions-api.md#runtimes-extensions-registration-api).
## Membuat pendengar telemetri
Ekstensi Lambda Anda harus memiliki listener yang menangani permintaan masuk dari API Telemetri. Kode berikut menunjukkan contoh implementasi pendengar telemetri di Golang:
```
// Starts the server in a goroutine where the log events will be sent
func (s *TelemetryApiListener) Start() (string, error) {
address := listenOnAddress()
l.Info("[listener:Start] Starting on address", address)
s.httpServer = &http.Server{Addr: address}
http.HandleFunc("/", s.http_handler)
go func() {
err := s.httpServer.ListenAndServe()
if err != http.ErrServerClosed {
l.Error("[listener:goroutine] Unexpected stop on Http Server:", err)
s.Shutdown()
} else {
l.Info("[listener:goroutine] Http Server closed:", err)
}
}()
return fmt.Sprintf("http://%s/", address), nil
}
// http_handler handles the requests coming from the Telemetry API.
// Everytime Telemetry API sends log events, this function will read them from the response body
// and put into a synchronous queue to be dispatched later.
// Logging or printing besides the error cases below is not recommended if you have subscribed to
// receive extension logs. Otherwise, logging here will cause Telemetry API to send new logs for
// the printed lines which may create an infinite loop.
func (s *TelemetryApiListener) http_handler(w http.ResponseWriter, r *http.Request) {
body, err := ioutil.ReadAll(r.Body)
if err != nil {
l.Error("[listener:http_handler] Error reading body:", err)
return
}
// Parse and put the log messages into the queue
var slice []interface{}
_ = json.Unmarshal(body, &slice)
for _, el := range slice {
s.LogEventsQueue.Put(el)
}
l.Info("[listener:http_handler] logEvents received:", len(slice), " LogEventsQueue length:", s.LogEventsQueue.Len())
slice = nil
}
```
## Menentukan protokol tujuan
Saat berlangganan untuk menerima telemetri menggunakan API Telemetri, Anda dapat menentukan protokol tujuan selain URI tujuan:
```
{
"destination": {
"protocol": "HTTP",
"URI": "http://sandbox.localdomain:8080"
}
}
```
Lambda menerima dua protokol untuk menerima telemetri:
+ **HTTP (direkomendasikan)** - Lambda mengirimkan telemetri ke titik akhir HTTP lokal (`http://sandbox.localdomain:${PORT}/${PATH}`) sebagai larik catatan dalam format JSON. Parameter `$PATH` bersifat opsional. Lambda hanya mendukung HTTP, bukan HTTPS. Lambda mengirimkan telemetri melalui permintaan POST.
+ **TCP** — Lambda mengirimkan telemetri ke port TCP dalam format JSON (NDJSON) yang dibatasi [Newline](https://github.com/ndjson/ndjson-spec).
**catatan**
Kami sangat menyarankan menggunakan HTTP daripada TCP. Dengan TCP, platform Lambda tidak dapat mengakui kapan mengirimkan telemetri ke lapisan aplikasi. Oleh karena itu, jika ekstensi Anda macet, Anda mungkin kehilangan telemetri. HTTP tidak memiliki batasan ini.
Sebelum berlangganan untuk menerima telemetri, buat pendengar HTTP lokal atau port TCP. Selama penyetelan, perhatikan hal berikut ini:
+ Lambda mengirimkan telemetri hanya ke tujuan yang berada di dalam lingkungan eksekusi.
+ Lambda mencoba lagi untuk mengirim telemetri (dengan backoff) tanpa adanya pendengar, atau jika permintaan POST mengalami kesalahan. Jika pendengar telemetri mogok, ia melanjutkan menerima telemetri setelah Lambda memulai ulang lingkungan eksekusi.
+ Lambda mencadangkan port 9001. Tidak ada pembatasan atau rekomendasi nomor port lainnya.
## Mengkonfigurasi penggunaan memori dan buffering
Penggunaan memori di lingkungan eksekusi tumbuh secara linier dengan jumlah pelanggan. Langganan mengkonsumsi sumber daya memori karena masing-masing membuka buffer memori baru untuk menyimpan data telemetri. Penggunaan memori buffer berkontribusi pada konsumsi memori secara keseluruhan di lingkungan eksekusi.
Saat berlangganan untuk menerima telemetri melalui API Telemetri, Anda memiliki opsi untuk menyangga data telemetri dan mengirimkannya ke pelanggan dalam batch. Untuk mengoptimalkan penggunaan memori, Anda dapat menentukan konfigurasi buffering:
```
{
"buffering": {
"maxBytes": 256*1024,
"maxItems": 1000,
"timeoutMs": 100
}
}
```
| Parameter | Deskripsi | Default dan batas |
| --- | --- | --- |
| `maxBytes` | Volume maksimum telemetri (dalam byte) untuk buffer dalam memori. | standar: 262.144 Minimal: 262.144 Maksimal: 1.048.576 |
| `maxItems` | Jumlah maksimum peristiwa untuk buffer dalam memori. | Default: 10.000 Minimal: 1.000 Maksimum: 10.000. |
| `timeoutMs` | Waktu maksimum (dalam milidetik) untuk buffer batch. | Default: 1.000 Minimal: 25 Maksimal: 30.000 |
Saat menyiapkan buffering, ingatlah poin-poin ini:
+ Jika salah satu aliran input ditutup, Lambda akan menyiram log. Misalnya, ini dapat terjadi jika runtime mogok.
+ Setiap pelanggan dapat menyesuaikan konfigurasi buffering mereka dalam permintaan berlangganan mereka.
+ Saat menentukan ukuran buffer untuk membaca data, antisipasi menerima muatan sebesar`2 * maxBytes + metadataBytes`, di mana `maxBytes` merupakan komponen penyiapan buffering Anda. Untuk mengukur jumlah yang `metadataBytes` perlu dipertimbangkan, tinjau metadata berikut. Lambda menambahkan metadata yang mirip dengan ini ke setiap catatan:
```
{
"time": "2022-08-20T12:31:32.123Z",
"type": "function",
"record": "Hello World"
}
```
+ Jika pelanggan tidak dapat memproses telemetri masuk dengan cukup cepat, atau jika kode fungsi Anda menghasilkan volume log yang sangat tinggi, Lambda mungkin akan menjatuhkan catatan untuk menjaga pemanfaatan memori tetap terbatas. Ketika ini terjadi, Lambda mengirimkan acara. `platform.logsDropped`
## Mengirim permintaan berlangganan ke API Telemetri
Ekstensi Lambda dapat berlangganan untuk menerima data telemetri dengan mengirimkan permintaan berlangganan ke API Telemetri. Permintaan berlangganan harus berisi informasi tentang jenis acara yang Anda inginkan untuk berlangganan ekstensi. Selain itu, permintaan dapat berisi [informasi tujuan pengiriman](#telemetry-api-destination) dan [konfigurasi buffering](#telemetry-api-buffering).
Sebelum mengirim permintaan berlangganan, Anda harus memiliki ID ekstensi (`Lambda-Extension-Identifier`). Saat [mendaftarkan ekstensi dengan Extensions API](#telemetry-api-registration), Anda mendapatkan ID ekstensi dari respons API.
Langganan terjadi selama [fase inisialisasi ekstensi](runtimes-extensions-api.md#runtimes-extensions-api-reg). Contoh berikut menunjukkan permintaan HTTP untuk berlangganan ketiga aliran telemetri: telemetri platform, log fungsi, dan log ekstensi.
```
PUT http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry HTTP/1.1
{
"schemaVersion": "2025-01-29",
"types": [
"platform",
"function",
"extension"
],
"buffering": {
"maxItems": 1000,
"maxBytes": 256*1024,
"timeoutMs": 100
},
"destination": {
"protocol": "HTTP",
"URI": "http://sandbox.localdomain:8080"
}
}
```
Jika permintaan berhasil, maka pelanggan menerima respons sukses HTTP 200.
```
HTTP/1.1 200 OK
"OK"
```
## Pesan API Telemetri Masuk
Setelah berlangganan menggunakan API Telemetri, ekstensi secara otomatis mulai menerima telemetri dari Lambda melalui permintaan POST. Setiap badan permintaan POST berisi array `Event` objek. Masing-masing `Event` memiliki skema berikut:
```
{
time: String,
type: String,
record: Object
}
```
+ `time`Properti menentukan kapan platform Lambda menghasilkan acara. Ini berbeda dengan saat peristiwa itu benar-benar terjadi. Nilai string `time` adalah stempel waktu dalam format ISO 8601.
+ `type`Properti mendefinisikan jenis acara. Tabel berikut menjelaskan semua nilai yang mungkin.
+ `record`Properti mendefinisikan objek JSON yang berisi data telemetri. Skema objek JSON ini tergantung pada. `type`
**Pemesanan acara dengan pemanggilan bersamaan**
Untuk [Instans Terkelola Lambda](lambda-managed-instances.md), beberapa pemanggilan fungsi dapat dijalankan secara bersamaan dalam lingkungan eksekusi yang sama. Dalam hal ini, urutan `platform.start` dan `platform.report` acara tidak dijamin antara pemanggilan bersamaan yang berbeda. Ekstensi harus menangani peristiwa dari beberapa pemanggilan yang berjalan secara paralel dan tidak boleh mengasumsikan urutan berurutan.
Untuk mengaitkan peristiwa dengan benar ke pemanggilan tertentu, ekstensi harus menggunakan `requestId` bidang yang ada dalam acara platform ini. Setiap pemanggilan memiliki ID permintaan unik yang tetap konsisten di semua peristiwa untuk pemanggilan itu, memungkinkan ekstensi untuk menghubungkan peristiwa dengan benar bahkan ketika mereka tiba di luar pesanan.
Tabel berikut merangkum semua jenis `Event` objek, dan menautkan ke [referensi `Event` skema API Telemetri](telemetry-schema-reference.md) untuk setiap jenis peristiwa.
| Kategori | Tipe peristiwa | Deskripsi | Skema catatan acara |
| --- | --- | --- | --- |
| Acara platform | `platform.initStart` | Inisialisasi fungsi dimulai. | [`platform.initStart`](telemetry-schema-reference.md#platform-initStart)skema |
| Acara platform | `platform.initRuntimeDone` | Inisialisasi fungsi selesai. | [`platform.initRuntimeDone`](telemetry-schema-reference.md#platform-initRuntimeDone)skema |
| Acara platform | `platform.initReport` | Laporan inisialisasi fungsi. | [`platform.initReport`](telemetry-schema-reference.md#platform-initReport)skema |
| Acara platform | `platform.start` | Pemanggilan fungsi dimulai. | [`platform.start`](telemetry-schema-reference.md#platform-start)skema |
| Acara platform | `platform.runtimeDone` | Runtime selesai memproses acara dengan keberhasilan atau kegagalan. | [`platform.runtimeDone`](telemetry-schema-reference.md#platform-runtimeDone)skema |
| Acara platform | `platform.report` | Laporan pemanggilan fungsi. | [`platform.report`](telemetry-schema-reference.md#platform-report)skema |
| Acara platform | `platform.restoreStart` | Pemulihan runtime dimulai. | [`platform.restoreStart`](telemetry-schema-reference.md#platform-restoreStart)skema |
| Acara platform | `platform.restoreRuntimeDone` | Pemulihan runtime selesai. | [`platform.restoreRuntimeDone`](telemetry-schema-reference.md#platform-restoreRuntimeDone)skema |
| Acara platform | `platform.restoreReport` | Laporan pemulihan runtime. | [`platform.restoreReport`](telemetry-schema-reference.md#platform-restoreReport)skema |
| Acara platform | `platform.telemetrySubscription` | Ekstensi berlangganan API Telemetri. | [`platform.telemetrySubscription`](telemetry-schema-reference.md#platform-telemetrySubscription)skema |
| Acara platform | `platform.logsDropped` | Lambda menjatuhkan entri log. | [`platform.logsDropped`](telemetry-schema-reference.md#platform-logsDropped)skema |
| Log fungsi | `function` | Sebuah baris log dari kode fungsi. | [`function`](telemetry-schema-reference.md#telemetry-api-function)skema |
| Log ekstensi: | `extension` | Sebuah baris log dari kode ekstensi. | [`extension`](telemetry-schema-reference.md#telemetry-api-extension)skema |
# Referensi API Telemetri Lambda
Gunakan titik akhir API Telemetri Lambda untuk berlangganan ekstensi ke aliran telemetri. Anda dapat mengambil titik akhir API Telemetri dari variabel lingkungan. `AWS_LAMBDA_RUNTIME_API` Untuk mengirim permintaan API, tambahkan versi API (`2022-07-01/`) dan`telemetry/`. Contoh:
```
http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/
```
Untuk definisi OpenAPI Specification (OAS) dari versi respons langganan`2025-01-29`, lihat berikut ini:
+ **HTTP** — [telemetry-api-http-schema.zip](samples/events_http_schema_v2025_01_29.zip)
+ **TCP** [— telemetry-api-tcp-schema .zip](samples/events_tcp_schema_v2025_01_29.zip)
**Topics**
+ [
## Langganan
](#telemetry-subscribe-api)
## Langganan
Untuk berlangganan aliran telemetri, ekstensi Lambda dapat mengirim permintaan API Berlangganan.
+ **Jalur** – `/telemetry`
+ **Metode** - `PUT`
+ **Header**
+ `Content-Type`: `application/json`
+ **Minta parameter tubuh**
+ **SchemaVersion**
+ Wajib: Ya
+ Tipe: String
+ Nilai valid: `"2025-01-29"`, `"2022-12-13"`, atau `"2022-07-01"`
+ **Catatan:** Instans Terkelola Lambda memerlukan. `"2025-01-29"` Versi ini kompatibel dengan fungsi Lambda (default).
+ **tujuan** — Pengaturan konfigurasi yang menentukan tujuan acara telemetri dan protokol untuk pengiriman acara.
+ Wajib: Ya
+ Tipe: Objek
```
{
"protocol": "HTTP",
"URI": "http://sandbox.localdomain:8080"
}
```
+ **Protokol** — Protokol yang digunakan Lambda untuk mengirim data telemetri.
+ Wajib: Ya
+ Tipe: String
+ Nilai yang valid: `"HTTP"` \$1 `"TCP"`
+ **URI** — URI untuk mengirim data telemetri ke.
+ Wajib: Ya
+ Tipe: String
+ Untuk informasi selengkapnya, lihat [Menentukan protokol tujuan](telemetry-api.md#telemetry-api-destination).
+ **jenis** — Jenis telemetri yang Anda inginkan untuk berlangganan ekstensi.
+ Wajib: Ya
+ Tipe: Array string
+ Nilai yang valid: `"platform"` \$1 `"function"` \$1 `"extension"`
+ **buffering** - Pengaturan konfigurasi untuk buffering acara.
+ Wajib: Tidak
+ Tipe: Objek
```
{
"buffering": {
"maxItems": 1000,
"maxBytes": 256*1024,
"timeoutMs": 100
}
}
```
+ **maxItems** – Jumlah maksimum peristiwa untuk buffer dalam memori.
+ Wajib: Tidak
+ Jenis: Integer
+ Default: 1.000
+ Minimal: 1.000
+ Maksimum: 10.000.
+ **MaxBytes** — Volume maksimum telemetri (dalam byte) untuk buffer dalam memori.
+ Wajib: Tidak
+ Jenis: Integer
+ standar: 262.144
+ Minimal: 262.144
+ Maksimal: 1.048.576
+ **timeoutMs** – Waktu maksimum (dalam milidetik) untuk mem-buffer batch.
+ Wajib: Tidak
+ Jenis: Integer
+ Default: 1.000
+ Minimal: 25
+ Maksimal: 30.000
+ Untuk informasi selengkapnya, lihat [Mengkonfigurasi penggunaan memori dan buffering](telemetry-api.md#telemetry-api-buffering).
### Contoh Permintaan API Berlangganan
```
PUT http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry HTTP/1.1
{
"schemaVersion": "2025-01-29",
"types": [
"platform",
"function",
"extension"
],
"buffering": {
"maxItems": 1000,
"maxBytes": 256*1024,
"timeoutMs": 100
},
"destination": {
"protocol": "HTTP",
"URI": "http://sandbox.localdomain:8080"
}
}
```
Jika permintaan Berlangganan berhasil, ekstensi menerima respons sukses HTTP 200:
```
HTTP/1.1 200 OK
"OK"
```
Jika permintaan Berlangganan gagal, ekstensi menerima respons kesalahan. Contoh:
```
HTTP/1.1 400 OK
{
"errorType": "ValidationError",
"errorMessage": "URI port is not provided; types should not be empty"
}
```
Berikut adalah beberapa kode respons tambahan yang dapat diterima ekstensi:
+ 200 – Permintaan berhasil diselesaikan
+ 202 – Permintaan diterima. Respons permintaan berlangganan di lingkungan pengujian lokal
+ 400 — Permintaan buruk
+ 500 – Kesalahan Layanan
# Referensi skema API Telemetri Lambda `Event`
Gunakan titik akhir API Telemetri Lambda untuk berlangganan ekstensi ke aliran telemetri. Anda dapat mengambil titik akhir API Telemetri dari variabel lingkungan. `AWS_LAMBDA_RUNTIME_API` Untuk mengirim permintaan API, tambahkan versi API (`2022-07-01/`) dan`telemetry/`. Contoh:
```
http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/
```
Untuk definisi OpenAPI Specification (OAS) dari versi respons langganan`2025-01-29`, lihat berikut ini:
+ **HTTP** — [telemetry-api-http-schema.zip](samples/events_http_schema_v2025_01_29.zip)
+ **TCP** [— telemetry-api-tcp-schema .zip](samples/events_tcp_schema_v2025_01_29.zip)
Tabel berikut adalah ringkasan dari semua jenis `Event` objek yang didukung oleh API Telemetri.
| Kategori | Tipe peristiwa | Deskripsi | Skema catatan acara |
| --- | --- | --- | --- |
| Acara platform | `platform.initStart` | Inisialisasi fungsi dimulai. | [`platform.initStart`](#platform-initStart)skema |
| Acara platform | `platform.initRuntimeDone` | Inisialisasi fungsi selesai. | [`platform.initRuntimeDone`](#platform-initRuntimeDone)skema |
| Acara platform | `platform.initReport` | Laporan inisialisasi fungsi. | [`platform.initReport`](#platform-initReport)skema |
| Acara platform | `platform.start` | Pemanggilan fungsi dimulai. | [`platform.start`](#platform-start)skema |
| Acara platform | `platform.runtimeDone` | Runtime selesai memproses acara dengan keberhasilan atau kegagalan. | [`platform.runtimeDone`](#platform-runtimeDone)skema |
| Acara platform | `platform.report` | Laporan pemanggilan fungsi. | [`platform.report`](#platform-report)skema |
| Acara platform | `platform.restoreStart` | Pemulihan runtime dimulai. | [`platform.restoreStart`](#platform-restoreStart)skema |
| Acara platform | `platform.restoreRuntimeDone` | Pemulihan runtime selesai. | [`platform.restoreRuntimeDone`](#platform-restoreRuntimeDone)skema |
| Acara platform | `platform.restoreReport` | Laporan pemulihan runtime. | [`platform.restoreReport`](#platform-restoreReport)skema |
| Acara platform | `platform.telemetrySubscription` | Ekstensi berlangganan API Telemetri. | [`platform.telemetrySubscription`](#platform-telemetrySubscription)skema |
| Acara platform | `platform.logsDropped` | Lambda menjatuhkan entri log. | [`platform.logsDropped`](#platform-logsDropped)skema |
| Log fungsi | `function` | Sebuah baris log dari kode fungsi. | [`function`](#telemetry-api-function)skema |
| Log ekstensi: | `extension` | Sebuah baris log dari kode ekstensi. | [`extension`](#telemetry-api-extension)skema |
**Contents**
+ [
## Jenis objek API `Event` telemetri
](#telemetry-api-events)
+ [
### `platform.initStart`
](#platform-initStart)
+ [
### `platform.initRuntimeDone`
](#platform-initRuntimeDone)
+ [
### `platform.initReport`
](#platform-initReport)
+ [
### `platform.start`
](#platform-start)
+ [
### `platform.runtimeDone`
](#platform-runtimeDone)
+ [
### `platform.report`
](#platform-report)
+ [
### `platform.restoreStart`
](#platform-restoreStart)
+ [
### `platform.restoreRuntimeDone`
](#platform-restoreRuntimeDone)
+ [
### `platform.restoreReport`
](#platform-restoreReport)
+ [
### `platform.extension`
](#platform-extension)
+ [
### `platform.telemetrySubscription`
](#platform-telemetrySubscription)
+ [
### `platform.logsDropped`
](#platform-logsDropped)
+ [
### `function`
](#telemetry-api-function)
+ [
### `extension`
](#telemetry-api-extension)
+ [
## Jenis objek bersama
](#telemetry-api-objects)
+ [
### `InitPhase`
](#InitPhase)
+ [
### `InitReportMetrics`
](#InitReportMetrics)
+ [
### `InitType`
](#InitType)
+ [
### `ReportMetrics`
](#ReportMetrics)
+ [
### `RestoreReportMetrics`
](#RestoreReportMetrics)
+ [
### `RuntimeDoneMetrics`
](#RuntimeDoneMetrics)
+ [
### `Span`
](#Span)
+ [
### `Status`
](#Status)
+ [
### `TraceContext`
](#TraceContext)
+ [
### `TracingType`
](#TracingType)
## Jenis objek API `Event` telemetri
Bagian ini merinci jenis `Event` objek yang didukung oleh API Telemetri Lambda. Dalam deskripsi peristiwa, tanda tanya (`?`) menunjukkan bahwa atribut mungkin tidak ada dalam objek.
### `platform.initStart`
Sebuah `platform.initStart` peristiwa menunjukkan bahwa fase inisialisasi fungsi telah dimulai. Sebuah `platform.initStart` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.initStart
- record: PlatformInitStart
```
`PlatformInitStart`Objek memiliki atribut berikut:
+ **FunctionName** - `String`
+ **FunctionVersion** - `String`
+ **InitializationType** - objek ``InitType``
+ **InstanceId?** — `String`
+ **instanceMaxMemory?** – `Integer`
+ **fase** — ``InitPhase`` objek
+ **RuntimeVersion?** — `String`
+ **runtimeVersionArn?** – `String`
Berikut ini adalah contoh `Event` tipe`platform.initStart`:
```
{
"time": "2022-10-12T00:00:15.064Z",
"type": "platform.initStart",
"record": {
"initializationType": "on-demand",
"phase": "init",
"runtimeVersion": "nodejs-14.v3",
"runtimeVersionArn": "arn",
"functionName": "myFunction",
"functionVersion": "$LATEST",
"instanceId": "82561ce0-53dd-47d1-90e0-c8f5e063e62e",
"instanceMaxMemory": 256
}
}
```
### `platform.initRuntimeDone`
Sebuah `platform.initRuntimeDone` peristiwa menunjukkan bahwa fase inisialisasi fungsi telah selesai. Sebuah `platform.initRuntimeDone` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.initRuntimeDone
- record: PlatformInitRuntimeDone
```
`PlatformInitRuntimeDone`Objek memiliki atribut berikut:
+ **InitializationType** - objek ``InitType``
+ **fase** — ``InitPhase`` objek
+ **status** - ``Status`` objek
+ **bentang?** — Daftar ``Span`` objek
Berikut ini adalah contoh `Event` tipe`platform.initRuntimeDone`:
```
{
"time": "2022-10-12T00:01:15.000Z",
"type": "platform.initRuntimeDone",
"record": {
"initializationType": "on-demand"
"status": "success",
"spans": [
{
"name": "someTimeSpan",
"start": "2022-06-02T12:02:33.913Z",
"durationMs": 70.5
}
]
}
}
```
### `platform.initReport`
Sebuah `platform.initReport` peristiwa berisi laporan keseluruhan dari fase inisialisasi fungsi. Sebuah `platform.initReport` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.initReport
- record: PlatformInitReport
```
`PlatformInitReport`Objek memiliki atribut berikut:
+ **ErrorType?** — tali
+ **InitializationType** - objek ``InitType``
+ **fase** — ``InitPhase`` objek
+ **metrik** — objek ``InitReportMetrics``
+ **bentang?** — Daftar ``Span`` objek
+ **status** - ``Status`` objek
Berikut ini adalah contoh `Event` tipe`platform.initReport`:
```
{
"time": "2022-10-12T00:01:15.000Z",
"type": "platform.initReport",
"record": {
"initializationType": "on-demand",
"status": "success",
"phase": "init",
"metrics": {
"durationMs": 125.33
},
"spans": [
{
"name": "someTimeSpan",
"start": "2022-06-02T12:02:33.913Z",
"durationMs": 90.1
}
]
}
}
```
### `platform.start`
Sebuah `platform.start` peristiwa menunjukkan bahwa fase pemanggilan fungsi telah dimulai. Sebuah `platform.start` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.start
- record: PlatformStart
```
`PlatformStart`Objek memiliki atribut berikut:
+ **RequesTid** — `String`
+ **versi?** — `String`
+ **menelusuri?** — ``TraceContext``
Berikut ini adalah contoh `Event` tipe`platform.start`:
```
{
"time": "2022-10-12T00:00:15.064Z",
"type": "platform.start",
"record": {
"requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa",
"version": "$LATEST",
"tracing": {
"spanId": "54565fb41ac79632",
"type": "X-Amzn-Trace-Id",
"value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1"
}
}
}
```
### `platform.runtimeDone`
Sebuah `platform.runtimeDone` peristiwa menunjukkan bahwa fase pemanggilan fungsi telah selesai. Sebuah `platform.runtimeDone` `Event` objek memiliki bentuk sebagai berikut:
**Instans Terkelola Lambda**
`platform.runtimeDone`Acara ini tidak didukung untuk Instans Terkelola Lambda. Ekstensi yang berjalan pada Instans Terkelola tidak akan menerima acara ini karena ekstensi tidak dapat berlangganan `INVOKE` acara di Instans Terkelola. Karena model eksekusi bersamaan di mana beberapa pemanggilan dapat diproses secara bersamaan, ekstensi tidak dapat melakukan pemrosesan pasca-pemanggilan untuk pemanggilan individu seperti yang biasanya dilakukan pada fungsi Lambda (default).
Untuk `responseDuration` Instans Terkelola, rentang `responseLatency` dan yang biasanya disertakan dalam `platform.runtimeDone` acara tersebut `platform.report` tersedia. Lihat [`platform.report`](#platform-report) untuk detail.
```
Event: Object
- time: String
- type: String = platform.runtimeDone
- record: PlatformRuntimeDone
```
`PlatformRuntimeDone`Objek memiliki atribut berikut:
+ **ErrorType?** — `String`
+ **metrik?** — ``RuntimeDoneMetrics`` objek
+ **RequesTid** — `String`
+ **status** - ``Status`` objek
+ **bentang?** — Daftar ``Span`` objek
+ **menelusuri?** — ``TraceContext`` objek
Berikut ini adalah contoh `Event` tipe`platform.runtimeDone`:
```
{
"time": "2022-10-12T00:01:15.000Z",
"type": "platform.runtimeDone",
"record": {
"requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa",
"status": "success",
"tracing": {
"spanId": "54565fb41ac79632",
"type": "X-Amzn-Trace-Id",
"value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1"
},
"spans": [
{
"name": "someTimeSpan",
"start": "2022-08-02T12:01:23:521Z",
"durationMs": 80.0
}
],
"metrics": {
"durationMs": 140.0,
"producedBytes": 16
}
}
}
```
### `platform.report`
Sebuah `platform.report` peristiwa berisi laporan keseluruhan dari fase pemanggilan fungsi. Sebuah `platform.report` `Event` objek memiliki bentuk sebagai berikut:
**Instans Terkelola Lambda**
`platform.report`Acara untuk Instans Terkelola Lambda memiliki metrik dan rentang yang berbeda dibandingkan dengan fungsi Lambda (default). Untuk Instans Terkelola:
**Rentang**: Berisi `responseLatency` dan `responseDuration` bukannya. `extensionOverhead` `extensionOverhead`Rentang tidak tersedia karena ekstensi tidak dapat berlangganan `INVOKE` acara pada Instans Terkelola karena model eksekusi bersamaan.
**Metrik**: Hanya termasuk`durationMs`. Metrik berikut tidak termasuk:`billedDurationMs`,, `initDurationMs``maxMemoryUsedMB`, dan`memorySizeMB`. Metrik per-pemanggilan ini tidak berlaku di lingkungan eksekusi bersamaan. [Untuk metrik pemanfaatan sumber daya, gunakan atau Wawasan [Memantau Instans Terkelola Lambda](lambda-managed-instances-monitoring.md) Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-insights.html)
```
Event: Object
- time: String
- type: String = platform.report
- record: PlatformReport
```
`PlatformReport`Objek memiliki atribut berikut:
+ **metrik** — objek ``ReportMetrics``
+ **RequesTid** — `String`
+ **bentang?** — Daftar ``Span`` objek
+ **status** - ``Status`` objek
+ **menelusuri?** — ``TraceContext`` objek
Berikut ini adalah contoh `Event` tipe`platform.report`:
```
{
"time": "2022-10-12T00:01:15.000Z",
"type": "platform.report",
"record": {
"metrics": {
"billedDurationMs": 694,
"durationMs": 693.92,
"initDurationMs": 397.68,
"maxMemoryUsedMB": 84,
"memorySizeMB": 128
},
"requestId": "6d68ca91-49c9-448d-89b8-7ca3e6dc66aa",
}
}
```
### `platform.restoreStart`
Sebuah `platform.restoreStart` peristiwa menunjukkan bahwa acara restorasi lingkungan fungsi dimulai. Dalam acara restorasi lingkungan, Lambda menciptakan lingkungan dari snapshot yang di-cache daripada menginisialisasi dari awal. Untuk informasi selengkapnya, lihat [Lambda SnapStart](snapstart.md). Sebuah `platform.restoreStart` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.restoreStart
- record: PlatformRestoreStart
```
`PlatformRestoreStart`Objek memiliki atribut berikut:
+ **FunctionName** - `String`
+ **FunctionVersion** - `String`
+ **InstanceId?** — `String`
+ **instanceMaxMemory?** – `String`
+ **RuntimeVersion?** — `String`
+ **runtimeVersionArn?** – `String`
Berikut ini adalah contoh `Event` tipe`platform.restoreStart`:
```
{
"time": "2022-10-12T00:00:15.064Z",
"type": "platform.restoreStart",
"record": {
"runtimeVersion": "nodejs-14.v3",
"runtimeVersionArn": "arn",
"functionName": "myFunction",
"functionVersion": "$LATEST",
"instanceId": "82561ce0-53dd-47d1-90e0-c8f5e063e62e",
"instanceMaxMemory": 256
}
}
```
### `platform.restoreRuntimeDone`
Sebuah `platform.restoreRuntimeDone` peristiwa menunjukkan bahwa acara restorasi lingkungan fungsi selesai. Dalam acara restorasi lingkungan, Lambda menciptakan lingkungan dari snapshot yang di-cache daripada menginisialisasi dari awal. Untuk informasi selengkapnya, lihat [Lambda SnapStart](snapstart.md). Sebuah `platform.restoreRuntimeDone` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.restoreRuntimeDone
- record: PlatformRestoreRuntimeDone
```
`PlatformRestoreRuntimeDone`Objek memiliki atribut berikut:
+ **ErrorType?** — `String`
+ **bentang?** — Daftar ``Span`` objek
+ **status** - ``Status`` objek
Berikut ini adalah contoh `Event` tipe`platform.restoreRuntimeDone`:
```
{
"time": "2022-10-12T00:00:15.064Z",
"type": "platform.restoreRuntimeDone",
"record": {
"status": "success",
"spans": [
{
"name": "someTimeSpan",
"start": "2022-08-02T12:01:23:521Z",
"durationMs": 80.0
}
]
}
}
```
### `platform.restoreReport`
Sebuah `platform.restoreReport` peristiwa berisi laporan keseluruhan dari acara restorasi fungsi. Sebuah `platform.restoreReport` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.restoreReport
- record: PlatformRestoreReport
```
`PlatformRestoreReport`Objek memiliki atribut berikut:
+ **ErrorType?** — tali
+ **metrik?** — ``RestoreReportMetrics`` objek
+ **bentang?** — Daftar ``Span`` objek
+ **status** - ``Status`` objek
Berikut ini adalah contoh `Event` tipe`platform.restoreReport`:
```
{
"time": "2022-10-12T00:00:15.064Z",
"type": "platform.restoreReport",
"record": {
"status": "success",
"metrics": {
"durationMs": 15.19
},
"spans": [
{
"name": "someTimeSpan",
"start": "2022-08-02T12:01:23:521Z",
"durationMs": 30.0
}
]
}
}
```
### `platform.extension`
Sebuah `extension` peristiwa berisi log dari kode ekstensi. Sebuah `extension` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = extension
- record: {}
```
`PlatformExtension`Objek memiliki atribut berikut:
+ **event** — Daftar `String`
+ **nama** — `String`
+ **negara** — `String`
Berikut ini adalah contoh `Event` tipe`platform.extension`:
```
{
"time": "2022-10-12T00:02:15.000Z",
"type": "platform.extension",
"record": {
"events": [ "INVOKE", "SHUTDOWN" ],
"name": "my-telemetry-extension",
"state": "Ready"
}
}
```
### `platform.telemetrySubscription`
`platform.telemetrySubscription`Acara berisi informasi tentang langganan ekstensi. Sebuah `platform.telemetrySubscription` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.telemetrySubscription
- record: PlatformTelemetrySubscription
```
`PlatformTelemetrySubscription`Objek memiliki atribut berikut:
+ **nama** — `String`
+ **negara** — `String`
+ **jenis** — Daftar `String`
Berikut ini adalah contoh `Event` tipe`platform.telemetrySubscription`:
```
{
"time": "2022-10-12T00:02:35.000Z",
"type": "platform.telemetrySubscription",
"record": {
"name": "my-telemetry-extension",
"state": "Subscribed",
"types": [ "platform", "function" ]
}
}
```
### `platform.logsDropped`
Sebuah `platform.logsDropped` acara berisi informasi tentang peristiwa yang dijatuhkan. Lambda memancarkan `platform.logsDropped` peristiwa ketika suatu fungsi mengeluarkan log pada tingkat yang terlalu tinggi bagi Lambda untuk memprosesnya. Ketika Lambda tidak dapat mengirim log ke CloudWatch atau ke ekstensi yang berlangganan Telemetri API dengan kecepatan yang dihasilkan oleh fungsi, itu akan menjatuhkan log untuk mencegah eksekusi fungsi melambat. Sebuah `platform.logsDropped` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = platform.logsDropped
- record: PlatformLogsDropped
```
`PlatformLogsDropped`Objek memiliki atribut berikut:
+ **DroppedBytes** — `Integer`
+ **DroppedRecords** — `Integer`
+ **alasan** — `String`
Berikut ini adalah contoh `Event` tipe`platform.logsDropped`:
```
{
"time": "2022-10-12T00:02:35.000Z",
"type": "platform.logsDropped",
"record": {
"droppedBytes": 12345,
"droppedRecords": 123,
"reason": "Some logs were dropped because the downstream consumer is slower than the logs production rate"
}
}
```
### `function`
Sebuah `function` peristiwa berisi log dari kode fungsi. Sebuah `function` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = function
- record: {}
```
Format `record` bidang tergantung pada apakah log fungsi Anda diformat dalam teks biasa atau format JSON. untuk mempelajari lebih lanjut tentang opsi konfigurasi format log, lihat [Mengkonfigurasi JSON dan format log teks biasa](monitoring-cloudwatchlogs-logformat.md)
Berikut ini adalah contoh `Event` jenis `function` di mana format log adalah teks biasa:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "function",
"record": "[INFO] Hello world, I am a function!"
}
```
Berikut ini adalah contoh `Event` jenis `function` di mana format log adalah JSON:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "function",
"record": {
"timestamp": "2022-10-12T00:03:50.000Z",
"level": "INFO",
"requestId": "79b4f56e-95b1-4643-9700-2807f4e68189",
"message": "Hello world, I am a function!"
}
}
```
**catatan**
Jika versi skema yang Anda gunakan lebih lama dari `2022-12-13` versi, maka versi selalu `"record"` dirender sebagai string bahkan ketika format logging fungsi Anda dikonfigurasi sebagai JSON. Untuk Instans Terkelola Lambda, Anda harus menggunakan versi skema. `2025-01-29`
### `extension`
Sebuah `extension` peristiwa berisi log dari kode ekstensi. Sebuah `extension` `Event` objek memiliki bentuk sebagai berikut:
```
Event: Object
- time: String
- type: String = extension
- record: {}
```
Format `record` bidang tergantung pada apakah log fungsi Anda diformat dalam teks biasa atau format JSON. untuk mempelajari lebih lanjut tentang opsi konfigurasi format log, lihat [Mengkonfigurasi JSON dan format log teks biasa](monitoring-cloudwatchlogs-logformat.md)
Berikut ini adalah contoh `Event` jenis `extension` di mana format log adalah teks biasa:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "extension",
"record": "[INFO] Hello world, I am an extension!"
}
```
Berikut ini adalah contoh `Event` jenis `extension` di mana format log adalah JSON:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "extension",
"record": {
"timestamp": "2022-10-12T00:03:50.000Z",
"level": "INFO",
"requestId": "79b4f56e-95b1-4643-9700-2807f4e68189",
"message": "Hello world, I am an extension!"
}
}
```
**catatan**
Jika versi skema yang Anda gunakan lebih lama dari `2022-12-13` versi, maka versi selalu `"record"` dirender sebagai string bahkan ketika format logging fungsi Anda dikonfigurasi sebagai JSON. Untuk Instans Terkelola Lambda, Anda harus menggunakan versi skema. `2025-01-29`
## Jenis objek bersama
Bagian ini merinci jenis objek bersama yang didukung oleh API Telemetri Lambda.
### `InitPhase`
Sebuah string enum yang menggambarkan fase ketika langkah inisialisasi terjadi. Dalam kebanyakan kasus, Lambda menjalankan kode inisialisasi fungsi selama fase. `init` Namun, dalam beberapa kasus kesalahan, Lambda dapat menjalankan kembali kode inisialisasi fungsi selama fase. `invoke` (Ini disebut *init yang ditekan*.)
+ **Jenis** - `String`
+ **Nilai yang valid** - `init` \$1 `invoke` \$1 `snap-start`
### `InitReportMetrics`
Objek yang berisi metrik tentang fase inisialisasi.
+ **Jenis** - `Object`
Sebuah `InitReportMetrics` objek memiliki bentuk sebagai berikut:
```
InitReportMetrics: Object
- durationMs: Double
```
Berikut ini adalah contoh `InitReportMetrics` objek:
```
{
"durationMs": 247.88
}
```
### `InitType`
Sebuah string enum yang menjelaskan bagaimana Lambda menginisialisasi lingkungan.
+ **Jenis** - `String`
+ **Nilai yang valid** - `on-demand` \$1 `provisioned-concurrency`
### `ReportMetrics`
Objek yang berisi metrik tentang fase selesai.
+ **Jenis** - `Object`
Sebuah `ReportMetrics` objek memiliki bentuk sebagai berikut:
```
ReportMetrics: Object
- billedDurationMs: Integer
- durationMs: Double
- initDurationMs?: Double
- maxMemoryUsedMB: Integer
- memorySizeMB: Integer
- restoreDurationMs?: Double
```
Berikut ini adalah contoh `ReportMetrics` objek:
```
{
"billedDurationMs": 694,
"durationMs": 693.92,
"initDurationMs": 397.68,
"maxMemoryUsedMB": 84,
"memorySizeMB": 128
}
```
### `RestoreReportMetrics`
Objek yang berisi metrik tentang fase restorasi selesai.
+ **Jenis** - `Object`
Sebuah `RestoreReportMetrics` objek memiliki bentuk sebagai berikut:
```
RestoreReportMetrics: Object
- durationMs: Double
```
Berikut ini adalah contoh `RestoreReportMetrics` objek:
```
{
"durationMs": 15.19
}
```
### `RuntimeDoneMetrics`
Objek yang berisi metrik tentang fase pemanggilan.
+ **Jenis** - `Object`
Sebuah `RuntimeDoneMetrics` objek memiliki bentuk sebagai berikut:
```
RuntimeDoneMetrics: Object
- durationMs: Double
- producedBytes?: Integer
```
Berikut ini adalah contoh `RuntimeDoneMetrics` objek:
```
{
"durationMs": 200.0,
"producedBytes": 15
}
```
### `Span`
Objek yang berisi detail tentang rentang. Rentang mewakili unit kerja atau operasi dalam jejak. Untuk informasi selengkapnya tentang [rentang, lihat Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) di halaman **Tracing API** di situs web OpenTelemetry Dokumen.
Lambda mendukung rentang berikut untuk acara tersebut: `platform.RuntimeDone`
+ `responseLatency`Rentang menjelaskan berapa lama waktu yang dibutuhkan fungsi Lambda Anda untuk mulai mengirim respons.
+ `responseDuration`Rentang menjelaskan berapa lama waktu yang dibutuhkan fungsi Lambda Anda untuk menyelesaikan pengiriman seluruh respons.
+ `runtimeOverhead`Rentang menjelaskan berapa lama waktu yang dibutuhkan runtime Lambda untuk memberi sinyal bahwa ia siap untuk memproses pemanggilan fungsi berikutnya. Ini adalah waktu yang dibutuhkan runtime untuk memanggil API [pemanggilan berikutnya](runtimes-api.md#runtimes-api-next) untuk mendapatkan acara berikutnya setelah mengembalikan respons fungsi Anda.
Berikut ini adalah contoh objek `responseLatency` span:
```
{
"name": "responseLatency",
"start": "2022-08-02T12:01:23.521Z",
"durationMs": 23.02
}
```
### `Status`
Objek yang menggambarkan status fase inisialisasi atau pemanggilan. Jika statusnya salah satu `failure` atau`error`, maka `Status` objek juga berisi `errorType` bidang yang menjelaskan kesalahan.
+ **Jenis** - `Object`
+ **Nilai status yang valid** - `success` \$1 `failure` \$1 `error` \$1 `timeout`
### `TraceContext`
Objek yang menggambarkan sifat-sifat jejak.
+ **Jenis** - `Object`
Sebuah `TraceContext` objek memiliki bentuk sebagai berikut:
```
TraceContext: Object
- spanId?: String
- type: TracingType enum
- value: String
```
Berikut ini adalah contoh `TraceContext` objek:
```
{
"spanId": "073a49012f3c312e",
"type": "X-Amzn-Trace-Id",
"value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1"
}
```
### `TracingType`
Sebuah string enum yang menggambarkan jenis tracing dalam suatu ``TraceContext`` objek.
+ **Jenis** - `String`
+ **Nilai yang valid** - `X-Amzn-Trace-Id`
# Mengonversi objek API `Event` Telemetri Lambda ke Span OpenTelemetry
Skema API AWS Lambda Telemetri secara semantik kompatibel dengan (). OpenTelemetry OTel Ini berarti Anda dapat mengonversi `Event` objek API AWS Lambda Telemetri ke OpenTelemetry (OTel) Span. Saat mengonversi, Anda tidak boleh memetakan satu `Event` objek ke satu OTel Span. Sebagai gantinya, Anda harus menyajikan ketiga peristiwa yang terkait dengan fase siklus hidup dalam satu OTel Span. Misalnya, `start``runtimeDone`, dan `runtimeReport` peristiwa mewakili pemanggilan fungsi tunggal. Hadirkan ketiga acara ini sebagai OTel Span tunggal.
Anda dapat mengonversi acara menggunakan Span Events atau Child (nested) Span. Tabel di halaman ini menjelaskan pemetaan antara properti skema API Telemetri dan properti OTel Span untuk kedua pendekatan. Untuk informasi selengkapnya tentang OTel Rentang, lihat [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) di halaman **Tracing API** di situs web OpenTelemetry Dokumen.
**Topics**
+ [
## Peta ke OTel Bentang dengan Acara Span
](#telemetry-otel-span-events)
+ [
## Peta ke OTel Bentang dengan Rentang Anak
](#telemetry-otel-child-spans)
## Peta ke OTel Bentang dengan Acara Span
Dalam tabel berikut, `e` mewakili peristiwa yang berasal dari sumber telemetri.
**Memetakan acara \$1Mulai**
| OpenTelemetry | Skema API Telemetri Lambda |
| --- | --- |
| `Span.Name` | Ekstensi Anda menghasilkan nilai ini berdasarkan `type` bidang. |
| `Span.StartTime` | Gunakan `e.time`. |
| `Span.EndTime` | N/A, karena acara belum selesai. |
| `Span.Kind` | Setel ke`Server`. |
| `Span.Status` | Setel ke`Unset`. |
| `Span.TraceId` | Parse AWS X-Ray header yang ditemukan di`e.tracing.value`, lalu gunakan `TraceId` nilainya. |
| `Span.ParentId` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Parent` nilainya. |
| `Span.SpanId` | Gunakan `e.tracing.spanId` jika tersedia. Jika tidak, buat yang baru`SpanId`. |
| `Span.SpanContext.TraceState` | N/A untuk konteks jejak X-Ray. |
| `Span.SpanContext.TraceFlags` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Sampled` nilainya. |
| `Span.Attributes` | Ekstensi Anda dapat menambahkan nilai kustom apa pun di sini. |
**Memetakan acara\$1 RuntimeDone **
| OpenTelemetry | Skema API Telemetri Lambda |
| --- | --- |
| `Span.Name` | Ekstensi Anda menghasilkan nilai berdasarkan `type` bidang. |
| `Span.StartTime` | Gunakan `e.time` dari `*Start` acara yang cocok. Alternatif lainnya, gunakan `e.time - e.metrics.durationMs`. |
| `Span.EndTime` | N/A, karena acara belum selesai. |
| `Span.Kind` | Setel ke`Server`. |
| `Span.Status` | Jika `e.status` tidak sama`success`, maka atur ke`Error`. Jika tidak, atur ke`Ok`. |
| `Span.Events[]` | Gunakan `e.spans[]`. |
| `Span.Events[i].Name` | Gunakan `e.spans[i].name`. |
| `Span.Events[i].Time` | Gunakan `e.spans[i].start`. |
| `Span.TraceId` | Parse AWS X-Ray header yang ditemukan di`e.tracing.value`, lalu gunakan `TraceId` nilainya. |
| `Span.ParentId` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Parent` nilainya. |
| `Span.SpanId` | Gunakan hal yang sama `SpanId` dari `*Start` acara tersebut. Jika tidak tersedia, maka gunakan`e.tracing.spanId`, atau buat yang baru`SpanId`. |
| `Span.SpanContext.TraceState` | N/A untuk konteks jejak X-Ray. |
| `Span.SpanContext.TraceFlags` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Sampled` nilainya. |
| `Span.Attributes` | Ekstensi Anda dapat menambahkan nilai kustom apa pun di sini. |
**Memetakan \$1Laporkan peristiwa**
| OpenTelemetry | Skema API Telemetri Lambda |
| --- | --- |
| `Span.Name` | Ekstensi Anda menghasilkan nilai berdasarkan `type` bidang. |
| `Span.StartTime` | Gunakan `e.time` dari `*Start` acara yang cocok. Alternatif lainnya, gunakan `e.time - e.metrics.durationMs`. |
| `Span.EndTime` | Gunakan `e.time`. |
| `Span.Kind` | Setel ke`Server`. |
| `Span.Status` | Gunakan nilai yang sama dengan `*RuntimeDone` acara. |
| `Span.TraceId` | Parse AWS X-Ray header yang ditemukan di`e.tracing.value`, lalu gunakan `TraceId` nilainya. |
| `Span.ParentId` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Parent` nilainya. |
| `Span.SpanId` | Gunakan hal yang sama `SpanId` dari `*Start` acara tersebut. Jika tidak tersedia, maka gunakan`e.tracing.spanId`, atau buat yang baru`SpanId`. |
| `Span.SpanContext.TraceState` | N/A untuk konteks jejak X-Ray. |
| `Span.SpanContext.TraceFlags` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Sampled` nilainya. |
| `Span.Attributes` | Ekstensi Anda dapat menambahkan nilai kustom apa pun di sini. |
## Peta ke OTel Bentang dengan Rentang Anak
Tabel berikut menjelaskan cara mengonversi peristiwa API Telemetri Lambda menjadi OTel Rentang dengan Rentang Anak (bersarang) untuk Rentang. `*RuntimeDone` Untuk `*Start` dan `*Report` pemetaan, lihat tabel di[Peta ke OTel Bentang dengan Acara Span](#telemetry-otel-span-events), karena sama untuk Rentang Anak. Dalam tabel ini, `e` mewakili peristiwa yang berasal dari sumber telemetri.
**Memetakan acara\$1 RuntimeDone **
| OpenTelemetry | Skema API Telemetri Lambda |
| --- | --- |
| `Span.Name` | Ekstensi Anda menghasilkan nilai berdasarkan `type` bidang. |
| `Span.StartTime` | Gunakan `e.time` dari `*Start` acara yang cocok. Alternatif lainnya, gunakan `e.time - e.metrics.durationMs`. |
| `Span.EndTime` | N/A, karena acara belum selesai. |
| `Span.Kind` | Setel ke`Server`. |
| `Span.Status` | Jika `e.status` tidak sama`success`, maka atur ke`Error`. Jika tidak, atur ke`Ok`. |
| `Span.TraceId` | Parse AWS X-Ray header yang ditemukan di`e.tracing.value`, lalu gunakan `TraceId` nilainya. |
| `Span.ParentId` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Parent` nilainya. |
| `Span.SpanId` | Gunakan hal yang sama `SpanId` dari `*Start` acara tersebut. Jika tidak tersedia, maka gunakan`e.tracing.spanId`, atau buat yang baru`SpanId`. |
| `Span.SpanContext.TraceState` | N/A untuk konteks jejak X-Ray. |
| `Span.SpanContext.TraceFlags` | Parse header X-Ray yang ditemukan di`e.tracing.value`, lalu gunakan `Sampled` nilainya. |
| `Span.Attributes` | Ekstensi Anda dapat menambahkan nilai kustom apa pun di sini. |
| `ChildSpan[i].Name` | Gunakan `e.spans[i].name`. |
| `ChildSpan[i].StartTime` | Gunakan `e.spans[i].start`. |
| `ChildSpan[i].EndTime` | Gunakan `e.spans[i].start + e.spans[i].durations`. |
| `ChildSpan[i].Kind` | Sama seperti orang tua`Span.Kind`. |
| `ChildSpan[i].Status` | Sama seperti orang tua`Span.Status`. |
| `ChildSpan[i].TraceId` | Sama seperti orang tua`Span.TraceId`. |
| `ChildSpan[i].ParentId` | Gunakan orang tua`Span.SpanId`. |
| `ChildSpan[i].SpanId` | Hasilkan yang baru`SpanId`. |
| `ChildSpan[i].SpanContext.TraceState` | N/A untuk konteks jejak X-Ray. |
| `ChildSpan[i].SpanContext.TraceFlags` | Sama seperti orang tua`Span.SpanContext.TraceFlags`. |
# Menggunakan Lambda Logs API
**penting**
API Telemetri Lambda menggantikan API Lambda Logs. **Meskipun API Log tetap berfungsi penuh, kami sarankan hanya menggunakan API Telemetri ke depannya.** Anda dapat berlangganan ekstensi Anda ke aliran telemetri menggunakan API Telemetri atau API Log. Setelah berlangganan menggunakan salah satu dari ini APIs, setiap upaya untuk berlangganan menggunakan API lain mengembalikan kesalahan.
**Instans Terkelola Lambda tidak mendukung API Log**
Instans Terkelola Lambda tidak mendukung API Log. Jika Anda menggunakan fungsi Instans Terkelola, gunakan [API Telemetri](telemetry-api.md) sebagai gantinya. API Telemetri menyediakan kemampuan yang ditingkatkan untuk mengumpulkan dan memproses data telemetri dari fungsi Lambda Anda.
Lambda secara otomatis menangkap log runtime dan mengalirkannya ke Amazon. CloudWatch Aliran log ini berisi log yang dibuat oleh kode fungsi dan ekstensi Anda, dan juga log yang dibuat oleh Lambda sebagai bagian dari invokasi fungsi.
[Ekstensi Lambda](runtimes-extensions-api.md) dapat menggunakan API Lambda Runtime Logs untuk berlangganan aliran log langsung dari [lingkungan eksekusi](lambda-runtime-environment.md) Lambda. Lambda mengalirkan log ke ekstensi, dan ekstensi kemudian dapat memproses, memfilter, dan mengirim log ke tujuan yang diinginkan.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/logs-api-concept-diagram.png)
API Log memungkinkan ekstensi untuk berlangganan ke tiga aliran log yang berbeda:
+ Log fungsi yang dibuat oleh fungsi Lambda dan ditulis ke `stdout` atau `stderr`.
+ Log ekstensi yang dibuat kode ekstensi.
+ Log platform Lambda, yang mencatat peristiwa dan kesalahan yang terkait dengan invokasi dan ekstensi.
**catatan**
Lambda mengirimkan semua log ke CloudWatch, bahkan ketika ekstensi berlangganan ke satu atau beberapa aliran log.
**Topics**
+ [
## Berlangganan untuk menerima log
](#runtimes-logs-api-subscribing)
+ [
## Penggunaan memori
](#runtimes-logs-api-memory)
+ [
## Protokol tujuan
](#runtimes-logs-api-dest)
+ [
## Konfigurasi buffering
](#runtimes-logs-api-buffering)
+ [
## Contoh berlangganan
](#runtimes-logs-api-subs-example)
+ [
## Kode sampel untuk API Log
](#runtimes-logs-api-samples)
+ [
## Referensi API Log
](#runtimes-logs-api-ref)
+ [
## Log pesan
](#runtimes-logs-api-msg)
## Berlangganan untuk menerima log
Ekstensi Lambda dapat berlangganan untuk menerima log dengan mengirim permintaan langganan ke API Log.
Untuk berlangganan guna menerima log, Anda memerlukan pengidentifikasi ekstensi (`Lambda-Extension-Identifier`). Pertama, [daftarkan ekstensi](runtimes-extensions-api.md#extensions-registration-api-a) untuk menerima pengidentifikasi ekstensi. Kemudian berlangganan API Log selama [inisialisasi](lambda-runtime-environment.md#runtimes-lifecycle-ib). Setelah fase inisialisasi selesai, Lambda tidak memproses permintaan langganan.
**catatan**
Berlangganan Log API adalah idempoten. Permintaan berlangganan duplikat tidak menghasilkan langganan duplikat.
## Penggunaan memori
Penggunaan memori meningkat secara linear seiring bertambahnya jumlah pelanggan. Langganan menghabiskan sumber daya memori karena setiap langganan membuka buffer memori baru untuk menyimpan log. Untuk membantu mengoptimalkan penggunaan memori, Anda dapat menyesuaikan [konfigurasi buffering](#runtimes-logs-api-buffering). Penggunaan memori buffer dihitung untuk konsumsi memori keseluruhan dalam lingkungan eksekusi.
## Protokol tujuan
Anda dapat memilih salah satu protokol berikut untuk menerima log:
1. **HTTP** (disarankan) – Lambda mengirimkan log ke titik akhir HTTP lokal (`http://sandbox.localdomain:${PORT}/${PATH}`) sebagai array catatan dalam format JSON. Parameter `$PATH` bersifat opsional. Perhatikan bahwa hanya HTTP yang didukung, bukan HTTPS. Anda dapat memilih untuk menerima log melalui PUT atau POST.
1. **TCP** – Lambda mengirimkan log ke port TCP dalam [format JSON berbatas baris baru (NDJSON)](https://github.com/ndjson/ndjson-spec).
Kami menyarankan Anda untuk menggunakan HTTP alih-alih TCP. Dengan TCP, platform Lambda tidak dapat mengakui bahwa log dikirimkan ke lapisan aplikasi. Oleh karena itu, Anda mungkin kehilangan log jika ekstensi Anda mengalami crash. HTTP tidak berbagi batasan ini.
Kami juga menyarankan Anda untuk mengatur pendengar HTTP lokal atau port TCP sebelum berlangganan untuk menerima log. Selama penyetelan, perhatikan hal berikut ini:
+ Lambda hanya mengirimkan log ke tujuan yang berada di lingkungan eksekusi.
+ Lambda mengulang upaya untuk mengirim log (dengan pemunduran) jika tidak ada pendengar, atau jika permintaan POST atau PUT mengakibatkan kesalahan. Jika pelanggan log mengalami crahs, pelanggam terus menerima log setelah Lambda memulai ulang lingkungan eksekusi.
+ Lambda mencadangkan port 9001. Tidak ada pembatasan atau rekomendasi nomor port lainnya.
## Konfigurasi buffering
Lambda dapat mem-buffer log dan mengirimkannya kepada pelanggan. Anda dapat mengonfigurasi perilaku ini dalam permintaan langganan dengan menentukan bidang opsional berikut. Perhatikan bahwa Lambda menggunakan nilai default untuk setiap bidang yang tidak Anda tentukan.
+ **timeoutMs** – Waktu maksimum (dalam milidetik) untuk mem-buffer batch. Default: 1.000. Minimum: 25. Maksimum: 30.000.
+ **maxBytes** – Ukuran maksimum (dalam byte) log untuk buffer dalam memori. Default: 262.144. Minimum: 262.144. Maksimum: 1.048.576.
+ **maxItems** – Jumlah maksimum peristiwa untuk buffer dalam memori. Default: 10.000. Minimum: 1.000. Maksimum: 10.000.
Selama konfigurasi buffering, perhatikan poin-poin berikut:
+ Lambda membilas log jika salah satu aliran input tertutup, misalnya, jika waktu pengoperasian macet.
+ Setiap pelanggan dapat menentukan konfigurasi buffering yang berbeda dalam permintaan langganan.
+ Pertimbangkan ukuran buffer yang Anda butuhkan untuk membaca data. Perkirakan penerimaan muatan sebesar `2*maxBytes+metadata`, dengan `maxBytes` dikonfigurasi dalam permintaan berlangganan. Misalnya, Lambda menambahkan byte metadata berikut ke setiap catatan:
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "function",
"record": "Hello World"
}
```
+ Jika pelanggan tidak dapat memproses log masuk dengan cukup cepat, Lambda mungkin akan menanggalkan log untuk menjaga pemanfaatan memori tetap terikat. Untuk menunjukkan jumlah catatan yang dihapus, Lambda mengirimkan log `platform.logsDropped`. Untuk informasi selengkapnya, lihat [Lambda: Tidak semua log fungsi saya muncul](troubleshooting-execution.md#troubleshooting-execution-missinglogs).
## Contoh berlangganan
Contoh berikut menunjukkan permintaan untuk berlangganan ke platform dan log fungsi.
```
PUT http://${AWS_LAMBDA_RUNTIME_API}/2020-08-15/logs HTTP/1.1
{ "schemaVersion": "2020-08-15",
"types": [
"platform",
"function"
],
"buffering": {
"maxItems": 1000,
"maxBytes": 262144,
"timeoutMs": 100
},
"destination": {
"protocol": "HTTP",
"URI": "http://sandbox.localdomain:8080/lambda_logs"
}
}
```
Jika permintaan berhasil, pelanggan akan menerima respons keberhasilan HTTP 200.
```
HTTP/1.1 200 OK
"OK"
```
## Kode sampel untuk API Log
Untuk kode contoh yang menunjukkan cara mengirim log ke tujuan kustom, lihat [Menggunakan AWS Lambda ekstensi untuk mengirim log ke tujuan khusus](https://aws.amazon.com/blogs/compute/using-aws-lambda-extensions-to-send-logs-to-custom-destinations/) di Blog AWS Komputasi.
Untuk contoh kode Python dan Go yang menunjukkan cara mengembangkan ekstensi Lambda dasar dan berlangganan API Log, lihat [AWS Lambda Ekstensi](https://github.com/aws-samples/aws-lambda-extensions) pada repositori Sampel. AWS GitHub Untuk informasi lebih lanjut tentang membangun ekstensi Lambda, lihat [Menggunakan API Ekstensi Lambda untuk membuat ekstensi](runtimes-extensions-api.md).
## Referensi API Log
Anda dapat mengambil titik akhir API Log dari variabel lingkungan `AWS_LAMBDA_RUNTIME_API`. Untuk mengirim permintaan API, gunakan prefiks `2020-08-15/` sebelum jalur API. Contoh:
```
http://${AWS_LAMBDA_RUNTIME_API}/2020-08-15/logs
```
[Spesifikasi OpenAPI untuk Logs API versi **2020-08-15** tersedia di sini: .zip logs-api-request](samples/logs-api-request.zip)
### Langganan
Untuk berlangganan satu atau beberapa aliran log yang tersedia di lingkungan eksekusi Lambda, ekstensi akan mengirim permintaan API Berlangganan.
**Jalur** – `/logs`
**Metode** – **PUT**
**Parameter tubuh**
`destination` – Lihat [Protokol tujuan](#runtimes-logs-api-dest). Wajib: ya. Jenis: string.
`buffering` – Lihat [Konfigurasi buffering](#runtimes-logs-api-buffering). Wajib: tidak. Jenis: string.
`types` – Array jenis log yang akan diterima. Wajib: ya. Jenis: array string. Nilai valid: "platform", "function", "extension".
`schemaVersion` – Wajib: tidak. Nilai default: "2020-08-15". Atur ke "2021-03-18" untuk ekstensi untuk menerima pesan [`platform.runtimeDone`](#runtimes-logs-api-ref-done).
****Parameter respons****
Spesifikasi OpenAPI untuk respons langganan versi **2020-08-15** tersedia untuk protokol HTTP dan TCP:
+ HTTP: [logs-api-http-response.zip](samples/logs-api-http-response.zip)
+ [TCP: logs-api-tcp-response .zip](samples/logs-api-tcp-response.zip)
****Kode respons****
+ 200 – Permintaan berhasil diselesaikan
+ 202 – Permintaan diterima. Respons terhadap permintaan berlangganan selama pengujian lokal.
+ 4XX – Permintaan Buruk
+ 500 – Kesalahan Layanan
Jika permintaan berhasil, pelanggan akan menerima respons keberhasilan HTTP 200.
```
HTTP/1.1 200 OK
"OK"
```
Jika permintaan gagal, pelanggan akan menerima respons kesalahan. Sebagai contoh:
```
HTTP/1.1 400 OK
{
"errorType": "Logs.ValidationError",
"errorMessage": URI port is not provided; types should not be empty"
}
```
## Log pesan
API Log memungkinkan ekstensi untuk berlangganan ke tiga aliran log yang berbeda:
+ Fungsi –Log dibuat oleh fungsi Lambda dan menulis ke `stdout` atau `stderr`.
+ Ekstenso – Log yang dibuat kode ekstensi.
+ Platform –Log yang dibuat platform runtime, yang mencatat peristiwa dan kesalahan yang terkait dengan invokasi dan ekstensi.
**Topics**
+ [
### Log fungsi
](#runtimes-logs-api-msg-function)
+ [
### Log ekstensi:
](#runtimes-logs-api-msg-extension)
+ [
### Log platform
](#runtimes-logs-api-msg-platform)
### Log fungsi
Fungsi Lambda dan ekstensi internal yang menghasilkan log fungsi dan menuliskannya ke `stdout` atau `stderr`.
Contoh berikut menunjukkan format pesan log fungsi. \$1 "time": "2020-08-20T12:31:32.123Z", "type": "function", "record": "ERROR encountered. Stack trace:\$1n\$1my-function (line 10)\$1n" \$1
### Log ekstensi:
Ekstensi dapat menghasilkan log ekstensi. Format log sama seperti untuk log fungsi.
### Log platform
Lambda menghasilkan pesan log untuk peristiwa platform seperti `platform.start`, `platform.end`, dan `platform.fault`.
Atau, Anda dapat berlangganan ke versi **2021-03-18**skema API Log, yang mencakup pesan log `platform.runtimeDone`.
#### Contoh pesan log platform
Contoh berikut menunjukkan log awal platform dan akhir platform. Log ini menunjukkan waktu mulai invokasi dan waktu berakhir invokasi untuk pemanggilan yang ditentukan oleh requestId.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.start",
"record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56"}
}
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.end",
"record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56"}
}
```
**Platform. initRuntimeDone**pesan log menunjukkan status `Runtime init` sub-fase, yang merupakan bagian dari fase [lifecyle Init](lambda-runtime-environment.md#runtimes-lifecycle-ib). `Runtime init`Kapan berhasil, runtime mengirimkan permintaan API `/next` runtime (untuk tipe `on-demand` dan `provisioned-concurrency` inisialisasi) atau `restore/next` (untuk tipe `snap-start` inisialisasi). Contoh berikut menunjukkan **platform yang sukses. initRuntimeDone**pesan log untuk jenis `snap-start` inisialisasi.
```
{
"time":"2022-07-17T18:41:57.083Z",
"type":"platform.initRuntimeDone",
"record":{
"initializationType":"snap-start",
"status":"success"
}
}
```
Pesan log **Platform.initReport** menunjukkan berapa lama `Init` fase berlangsung dan berapa milidetik Anda ditagih selama fase ini. Ketika jenis inisialisasi`provisioned-concurrency`, Lambda mengirimkan pesan ini selama pemanggilan. Saat jenis inisialisasi`snap-start`, Lambda mengirimkan pesan ini setelah memulihkan snapshot. Contoh berikut menunjukkan pesan log **Platform.initReport** untuk jenis inisialisasi. `snap-start`
```
{
"time":"2022-07-17T18:41:57.083Z",
"type":"platform.initReport",
"record":{
"initializationType":"snap-start",
"metrics":{
"durationMs":731.79,
"billedDurationMs":732
}
}
}
```
Log laporan platform menyertakan metrik tentang invokasi yang ditentukan oleh requestId. Bidang `initDurationMs` termasuk dalam log hanya jika invokasi termasuk mulai awal. Jika pelacakan AWS X-Ray aktif, log mencakup metadata X-Ray. Contoh berikut menunjukkan log laporan platform untuk invokasi yang mencakup mulai awal.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.report",
"record": {"requestId": "6f7f0961f83442118a7af6fe80b88d56",
"metrics": {"durationMs": 101.51,
"billedDurationMs": 300,
"memorySizeMB": 512,
"maxMemoryUsedMB": 33,
"initDurationMs": 116.67
}
}
}
```
Log kesalahan platform menangkap waktu pengoperasian atau kesalahan lingkungan eksekusi. Contoh berikut ini menunjukkan pesan log kesalahan platform.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.fault",
"record": "RequestId: d783b35e-a91d-4251-af17-035953428a2c Process exited before completing request"
}
```
**catatan**
AWS saat ini menerapkan perubahan pada layanan Lambda. Karena perubahan ini, Anda mungkin melihat perbedaan kecil antara struktur dan konten pesan log sistem dan segmen jejak yang dipancarkan oleh fungsi Lambda yang berbeda di Anda. Akun AWS
Salah satu output log yang terpengaruh oleh perubahan ini adalah `"record"` bidang log kesalahan platform. Contoh berikut menunjukkan `"record"` bidang ilustrasi dalam format lama dan baru. Gaya baru log kesalahan berisi pesan yang lebih ringkas
Perubahan ini akan diterapkan selama beberapa minggu mendatang, dan semua fungsi di semua Wilayah AWS kecuali China GovCloud dan wilayah akan bertransisi untuk menggunakan pesan log format baru dan segmen pelacakan.
**Example catatan log kesalahan platform (gaya lama)**
```
"record":"RequestId: ...\tError: Runtime exited with error: exit status 255\nRuntime.ExitError"
```
**Example catatan log kesalahan platform (gaya baru)**
```
"record":"RequestId: ... Status: error\tErrorType: Runtime.ExitError"
```
Lambda membuat log ekstensi platform ketika ekstensi mendaftar dengan API ekstensi. Contoh berikut ini menunjukkan pesan ekstensi platform.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.extension",
"record": {"name": "Foo.bar",
"state": "Ready",
"events": ["INVOKE", "SHUTDOWN"]
}
}
```
Lambda menghasilkan log langganan log platform saat ekstensi berlangganan API log. Contoh berikut menunjukkan pesan langganan Log.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.logsSubscription",
"record": {"name": "Foo.bar",
"state": "Subscribed",
"types": ["function", "platform"],
}
}
```
Lambda menghasilkan log yang dihapus log platform ketika ekstensi tidak dapat memproses jumlah log yang diterimanya. Contoh berikut menunjukkan pesan log `platform.logsDropped`.
```
{
"time": "2020-08-20T12:31:32.123Z",
"type": "platform.logsDropped",
"record": {"reason": "Consumer seems to have fallen behind as it has not acknowledged receipt of logs.",
"droppedRecords": 123,
"droppedBytes" 12345
}
}
```
Pesan log **Platform.RestoRestart** menunjukkan waktu `Restore` fase dimulai (`snap-start`hanya jenis inisialisasi). Contoh:
```
{
"time":"2022-07-17T18:43:44.782Z",
"type":"platform.restoreStart",
"record":{}
}
```
Pesan log **Platform.RestoreReport** menunjukkan berapa lama `Restore` fase berlangsung dan berapa milidetik Anda ditagih selama fase ini (hanya jenis inisialisasi). `snap-start` Contoh:
```
{
"time":"2022-07-17T18:43:45.936Z",
"type":"platform.restoreReport",
"record":{
"metrics":{
"durationMs":70.87,
"billedDurationMs":13
}
}
}
```
#### Pesan `runtimeDone` platform
Jika Anda mengatur versi skema ke "2021-03-18" dalam permintaan berlangganan, Lambda mengirimkan pesan `platform.runtimeDone`setelah fungsi invokasi selesai baik berhasil maupun dengan kesalahan. Ekstensi dapat menggunakan pesan ini untuk menghentikan semua kumpulan telemetri untuk fungsi invokasi ini.
Spesifikasi OpenAPI untuk tipe peristiwa Log dalam versi skema **2021-03-18** tersedia di sini: [schema-2021-03-18.zip](samples/schema-2021-03-18.zip)
Lambda menghasilkan pesan log `platform.runtimeDone` ketika runtime mengirimkan permintaan API runtime `Next` atau `Error`. Log `platform.runtimeDone` memberi tahu konsumen API Log bahwa fungsi invokasi selesai. Ekstensi dapat menggunakan informasi ini untuk memutuskan kapan harus mengirim semua telemetri yang dikumpulkan selama invokasi tersebut.
##### Contoh
Lambda mengirimkan pesan `platform.runtimeDone` setelah runtime mengirimkan permintaan NEXT ketika fungsi invokasi selesai. Contoh berikut menunjukkan pesan untuk masing-masing nilai status: sukses, kegagalan, dan waktu habis.
**Example Contoh pesan sukses**
```
{
"time": "2021-02-04T20:00:05.123Z",
"type": "platform.runtimeDone",
"record": {
"requestId":"6f7f0961f83442118a7af6fe80b88",
"status": "success"
}
}
```
**Example Contoh pesan kegagalan**
```
{
"time": "2021-02-04T20:00:05.123Z",
"type": "platform.runtimeDone",
"record": {
"requestId":"6f7f0961f83442118a7af6fe80b88",
"status": "failure"
}
}
```
**Example Contoh pesan waktu habis**
```
{
"time": "2021-02-04T20:00:05.123Z",
"type": "platform.runtimeDone",
"record": {
"requestId":"6f7f0961f83442118a7af6fe80b88",
"status": "timeout"
}
}
```
**Example Contoh platform. restoreRuntimeDone pesan (hanya jenis `snap-start` inisialisasi)**
**Platform. restoreRuntimeDone**pesan log menunjukkan apakah `Restore` fase berhasil atau tidak. Lambda mengirimkan pesan ini saat runtime mengirimkan permintaan API `restore/next` runtime. Ada tiga kemungkinan status: keberhasilan, kegagalan, dan batas waktu. Contoh berikut menunjukkan **platform yang sukses. restoreRuntimeDone**pesan log.
```
{
"time":"2022-07-17T18:43:45.936Z",
"type":"platform.restoreRuntimeDone",
"record":{
"status":"success"
}
}
```