Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Referenz zum `Event`-Schema der Lambda-Telemetrie-API
Verwenden Sie den Lambda-Telemetrie-API-Endpunkt, um Erweiterungen für Telemetrie-Streams zu abonnieren. Sie können den Telemtrie-API-Endpunkts aus der `AWS_LAMBDA_RUNTIME_API`-Umgebungsvariable abrufen. Um eine API-Anfrage zu senden, fügen Sie die API-Version (`2022-07-01/`) und `telemetry/` an. Beispiel:
```
http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/
```
Die Definition der OpenAPI-Spezifikation (OAS) der Abonnementantwortversion `2025-01-29` finden Sie unter:
+ **HTTP** — [telemetry-api-http-schema.zip](samples/events_http_schema_v2025_01_29.zip)
+ **[TCP — .zip telemetry-api-tcp-schema](samples/events_tcp_schema_v2025_01_29.zip)**
Die folgende Tabelle enthält eine Zusammenfassung aller `Event`-Objekttypen, die die Telemetrie-API unterstützt.
| Kategorie | Ereignistyp | Description | Schema der Ereignisaufzeichnung |
| --- | --- | --- | --- |
| Plattform-Ereignis | `platform.initStart` | Die Funktionsinitialisierung wurde gestartet. | [`platform.initStart`](#platform-initStart)-Schema |
| Plattform-Ereignis | `platform.initRuntimeDone` | Die Funktionsinitialisierung ist abgeschlossen. | [`platform.initRuntimeDone`](#platform-initRuntimeDone)-Schema |
| Plattform-Ereignis | `platform.initReport` | Ein Bericht über die Funktionsinitialisierung. | [`platform.initReport`](#platform-initReport)-Schema |
| Plattform-Ereignis | `platform.start` | Der Funktionsaufruf wurde gestartet. | [`platform.start`](#platform-start)-Schema |
| Plattform-Ereignis | `platform.runtimeDone` | Die Laufzeit hat die Verarbeitung eines Ereignisses erfolgreich oder mit einem Fehler abgeschlossen. | [`platform.runtimeDone`](#platform-runtimeDone)-Schema |
| Plattform-Ereignis | `platform.report` | Ein Bericht über den Funktionsaufruf. | [`platform.report`](#platform-report)-Schema |
| Plattform-Ereignis | `platform.restoreStart` | Die Laufzeitwiederherstellung wurde gestartet. | [`platform.restoreStart`](#platform-restoreStart)-Schema |
| Plattform-Ereignis | `platform.restoreRuntimeDone` | Die Laufzeitwiederherstellung wurde abgeschlossen. | [`platform.restoreRuntimeDone`](#platform-restoreRuntimeDone)-Schema |
| Plattform-Ereignis | `platform.restoreReport` | Bericht über die Laufzeitwiederherstellung. | [`platform.restoreReport`](#platform-restoreReport)-Schema |
| Plattform-Ereignis | `platform.telemetrySubscription` | Die Erweiterung hat die Telemetrie-API abonniert. | [`platform.telemetrySubscription`](#platform-telemetrySubscription)-Schema |
| Plattform-Ereignis | `platform.logsDropped` | Lambda hat die Protokolleinträge gelöscht. | [`platform.logsDropped`](#platform-logsDropped)-Schema |
| Funktionsprotokolle | `function` | Eine Protokollzeile aus dem Funktionscode. | [`function`](#telemetry-api-function)-Schema |
| Erweiterungsprotokolle | `extension` | Eine Protokollzeile aus dem Erweiterungscode. | [`extension`](#telemetry-api-extension)-Schema |
**Contents**
+ [Telemetrie-API `Event`-Objekttypen](#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)
+ [Freigegebene Objekttypen](#telemetry-api-objects)
+ [`InitPhase`](#InitPhase)
+ [`InitReportMetrics`](#InitReportMetrics)
+ [`InitType`](#InitType)
+ [`ReportMetrics`](#ReportMetrics)
+ [`RestoreReportMetrics`](#RestoreReportMetrics)
+ [`RuntimeDoneMetrics`](#RuntimeDoneMetrics)
+ [`Span`](#Span)
+ [`Status`](#Status)
+ [`TraceContext`](#TraceContext)
+ [`TracingType`](#TracingType)
## Telemetrie-API `Event`-Objekttypen
Dieser Abschnitt beschreibt die Arten der `Event`-Objekte, die die Lambda-Telemetrie-API unterstützt. In den Ereignisbeschreibungen weist ein Fragezeichen (`?`) darauf hin, dass das Attribut möglicherweise nicht in diesem Objekt vorhanden ist.
### `platform.initStart`
Ein `platform.initStart`-Ereignis zeigt an, dass die Initialisierungsphase der Funktion begonnen hat. Ein `platform.initStart` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.initStart
- record: PlatformInitStart
```
Dieses `PlatformInitStart`-Objekt hat die folgenden Attribute:
+ **functionName** – `String`
+ **functionVersion** – `String`
+ **initializationType** – ``InitType``-Objekt
+ **instanceId?** – `String`
+ **instanceMaxMemory?** – `Integer`
+ **phase** – ``InitPhase``-Objekt
+ **runtimeVersion?** – `String`
+ **runtimeVersionArn?** – `String`
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.initRuntimeDone`-Ereignis zeigt an, dass die Initialisierungsphase der Funktion abgeschlossen wurde. Ein `platform.initRuntimeDone` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.initRuntimeDone
- record: PlatformInitRuntimeDone
```
Dieses `PlatformInitRuntimeDone`-Objekt hat die folgenden Attribute:
+ **initializationType** – ``InitType``-Objekt
+ **phase** – ``InitPhase``-Objekt
+ **status** – ``Status``-Objekt
+ **spans?** – Liste von ``Span``-Objekten
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.initReport`-Ereignis enthält einen Gesamtbericht über die Initialisierungsphase der Funktion. Ein `platform.initReport` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.initReport
- record: PlatformInitReport
```
Dieses `PlatformInitReport`-Objekt hat die folgenden Attribute:
+ **errorType?** – Zeichenfolge
+ **initializationType** – ``InitType``-Objekt
+ **phase** – ``InitPhase``-Objekt
+ **metrics** – ``InitReportMetrics``-Objekt
+ **spans?** – Liste von ``Span``-Objekten
+ **status** – ``Status``-Objekt
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.start`-Ereignis zeigt an, dass die Funktionsaufrufphase begonnen hat. Ein `platform.start` `Event` Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.start
- record: PlatformStart
```
Dieses `PlatformStart`-Objekt hat die folgenden Attribute:
+ **requestId** – `String`
+ **version?** – `String`
+ **tracing?** – ``TraceContext``
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.runtimeDone`-Ereignis zeigt an, dass die Funktionsaufrufphase abgeschlossen ist. Ein `platform.runtimeDone` `Event`-Objekt hat die folgende Form:
**Von Lambda verwaltete Instanzen**
Das `platform.runtimeDone` Ereignis wird für Lambda Managed Instances nicht unterstützt. Erweiterungen, die auf verwalteten Instanzen ausgeführt werden, erhalten dieses Ereignis nicht, da Erweiterungen das `INVOKE` Ereignis auf verwalteten Instanzen nicht abonnieren können. Aufgrund des Modells der gleichzeitigen Ausführung, bei dem mehrere Aufrufe gleichzeitig verarbeitet werden können, können Erweiterungen keine Verarbeitung nach dem Aufrufen für einzelne Aufrufe durchführen, wie dies üblicherweise bei Lambda-Funktionen (Standard) der Fall ist.
Bei verwalteten Instanzen sind die Bereiche `responseLatency` und, die normalerweise `responseDuration` enthalten sind, stattdessen im Ereignis verfügbar. `platform.runtimeDone` `platform.report` Details dazu finden Sie unter [`platform.report`](#platform-report).
```
Event: Object
- time: String
- type: String = platform.runtimeDone
- record: PlatformRuntimeDone
```
Dieses `PlatformRuntimeDone`-Objekt hat die folgenden Attribute:
+ **errorType? ** – `String`
+ **metrics?** – ``RuntimeDoneMetrics`` Objekt
+ **requestId** – `String`
+ **status** – ``Status``-Objekt
+ **spans?** – Liste von ``Span``-Objekten
+ **tracing?** – ``TraceContext``-Objekt
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.report`-Ereignis enthält einen Gesamtbericht über die Phase des Funktionsaufrufs. Ein `platform.report` `Event`-Objekt hat die folgende Form:
**Von Lambda verwaltete Instanzen**
Das `platform.report` Ereignis für Lambda Managed Instances hat im Vergleich zu Lambda-Funktionen (Standard) andere Metriken und Spannweiten. Für verwaltete Instanzen:
**Spans**: Enthält `responseLatency` und `responseDuration` statt. `extensionOverhead` Die `extensionOverhead` Spanne ist nicht verfügbar, da Erweiterungen das `INVOKE` Ereignis auf verwalteten Instanzen aufgrund des parallelen Ausführungsmodells nicht abonnieren können.
**Metriken**: Beinhaltet `durationMs` nur. Die folgenden Metriken sind nicht enthalten: `billedDurationMs``initDurationMs`,`maxMemoryUsedMB`, und`memorySizeMB`. Diese Metriken pro Aufruf sind in der Umgebung für die gleichzeitige Ausführung nicht anwendbar. Verwenden [Überwachung von Lambda-verwalteten Instanzen](lambda-managed-instances-monitoring.md) Sie [Lambda Insights](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-insights.html) für Kennzahlen zur Ressourcennutzung.
```
Event: Object
- time: String
- type: String = platform.report
- record: PlatformReport
```
Dieses `PlatformReport`-Objekt hat die folgenden Attribute:
+ **metrics** – ``ReportMetrics``-Objekt
+ **requestId** – `String`
+ **spans?** – Liste von ``Span``-Objekten
+ **Status** – ``Status``-Objekt
+ **Nachverfolgung? ** – ``TraceContext``-Objekt
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.restoreStart`-Ereignis zeigt an, dass ein Ereignis zur Wiederherstellung der Funktionsumgebung gestartet wurde. Bei einem Wiederherstellungsereignis einer Umgebung erstellt Lambda die Umgebung aus einem im Cache gespeicherten Snapshot, anstatt diese von Grund auf neu zu initialisieren. Weitere Informationen finden Sie unter [Lambda SnapStart](snapstart.md). Ein `platform.restoreStart` `Event` Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.restoreStart
- record: PlatformRestoreStart
```
Dieses `PlatformRestoreStart`-Objekt hat die folgenden Attribute:
+ **functionName** – `String`
+ **functionVersion** – `String`
+ **instanceId?** – `String`
+ **instanceMaxMemory?** – `String`
+ **runtimeVersion?** – `String`
+ **runtimeVersionArn?** – `String`
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.restoreRuntimeDone`-Ereignis weist darauf hin, dass ein Wiederherstellungsereignis der Funktionsumgebung abgeschlossen wurde. Bei einem Wiederherstellungsereignis einer Umgebung erstellt Lambda die Umgebung aus einem im Cache gespeicherten Snapshot, anstatt diese von Grund auf neu zu initialisieren. Weitere Informationen finden Sie unter [Lambda SnapStart](snapstart.md). Ein `platform.restoreRuntimeDone` `Event` Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.restoreRuntimeDone
- record: PlatformRestoreRuntimeDone
```
Dieses `PlatformRestoreRuntimeDone`-Objekt hat die folgenden Attribute:
+ **errorType? ** – `String`
+ **spans?** – Liste von ``Span``-Objekten
+ **status** – ``Status``-Objekt
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `platform.restoreReport`-Ereignis enthält einen Gesamtbericht über ein Ereignis zur Funktionswiederherstellung. Ein `platform.restoreReport` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.restoreReport
- record: PlatformRestoreReport
```
Dieses `PlatformRestoreReport`-Objekt hat die folgenden Attribute:
+ **errorType?** – Zeichenfolge
+ **metrics?** – ``RestoreReportMetrics`` Objekt
+ **spans?** – Liste von ``Span``-Objekten
+ **status** – ``Status``-Objekt
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `extension`-Ereignis enthält Protokolle aus dem Erweiterungscode. Ein `extension` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = extension
- record: {}
```
Dieses `PlatformExtension`-Objekt hat die folgenden Attribute:
+ **events** – Liste von `String`
+ **name** – `String`
+ **status** – `String`
Es folgt ein Beispiel für `Event` des Typs `platform.extension`:
```
{
"time": "2022-10-12T00:02:15.000Z",
"type": "platform.extension",
"record": {
"events": [ "INVOKE", "SHUTDOWN" ],
"name": "my-telemetry-extension",
"state": "Ready"
}
}
```
### `platform.telemetrySubscription`
Ein `platform.telemetrySubscription`-Ereignis enthält Informationen zu einem Erweiterungsabonnement. Ein `platform.telemetrySubscription` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.telemetrySubscription
- record: PlatformTelemetrySubscription
```
Dieses `PlatformTelemetrySubscription`-Objekt hat die folgenden Attribute:
+ **name** – `String`
+ **status** – `String`
+ **types** – Liste von `String`
Es folgt ein Beispiel für `Event` des Typs `platform.telemetrySubscription`:
```
{
"time": "2022-10-12T00:02:35.000Z",
"type": "platform.telemetrySubscription",
"record": {
"name": "my-telemetry-extension",
"state": "Subscribed",
"types": [ "platform", "function" ]
}
}
```
### `platform.logsDropped`
Ein `platform.logsDropped`-Ereignis enthält Informationen über gelöschte Ereignisse. Lambda gibt das `platform.logsDropped`-Ereignis aus, wenn eine Funktion Protokolle schneller ausgibt, als Lambda sie verarbeiten kann. Wenn Lambda Protokolle nicht mit der Geschwindigkeit an CloudWatch oder an die Erweiterung senden kann, die die Telemetrie-API abonniert hat, werden Protokolle gelöscht, um zu verhindern, dass die Ausführung der Funktion verlangsamt wird. Ein `platform.logsDropped` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = platform.logsDropped
- record: PlatformLogsDropped
```
Dieses `PlatformLogsDropped`-Objekt hat die folgenden Attribute:
+ **droppedBytes** – `Integer`
+ **droppedRecords** – `Integer`
+ **reason** – `String`
Es folgt ein Beispiel für `Event` des Typs `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`
Ein `function`-Ereignis enthält Protokolle aus dem Funktionscode. Ein `function` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = function
- record: {}
```
Das Format des Felds `record` hängt davon ab, ob die Protokolle Ihrer Funktion im Klartext- oder JSON-Format formatiert sind. Weitere Informationen zu den Konfigurationsoptionen für das Protokollformat finden Sie unter [Konfiguration der JSON- und Klartext-Protokollformate](monitoring-cloudwatchlogs-logformat.md).
Im Folgenden finden Sie ein Beispiel für `Event` vom Typ `function`, bei dem das Protokollformat Klartext ist:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "function",
"record": "[INFO] Hello world, I am a function!"
}
```
Im Folgenden finden Sie ein Beispiel für `Event` vom Typ `function`, bei dem das Protokollformat JSON ist:
```
{
"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!"
}
}
```
**Anmerkung**
Wenn die von Ihnen verwendete Schemaversion älter als die `2022-12-13`-Version ist, wird `"record"` immer als Zeichenfolge gerendert, auch wenn das Protokollierungsformat Ihrer Funktion als JSON konfiguriert ist. Für Lambda Managed Instances müssen Sie die Schemaversion `2025-01-29` verwenden.
### `extension`
Ein `extension`-Ereignis enthält Protokolle aus dem Erweiterungscode. Ein `extension` `Event`-Objekt hat die folgende Form:
```
Event: Object
- time: String
- type: String = extension
- record: {}
```
Das Format des Felds `record` hängt davon ab, ob die Protokolle Ihrer Funktion im Klartext- oder JSON-Format formatiert sind. Weitere Informationen zu den Konfigurationsoptionen für das Protokollformat finden Sie unter [Konfiguration der JSON- und Klartext-Protokollformate](monitoring-cloudwatchlogs-logformat.md).
Im Folgenden finden Sie ein Beispiel für `Event` vom Typ `extension`, bei dem das Protokollformat Klartext ist:
```
{
"time": "2022-10-12T00:03:50.000Z",
"type": "extension",
"record": "[INFO] Hello world, I am an extension!"
}
```
Im Folgenden finden Sie ein Beispiel für `Event` vom Typ `extension`, bei dem das Protokollformat JSON ist:
```
{
"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!"
}
}
```
**Anmerkung**
Wenn die von Ihnen verwendete Schemaversion älter als die `2022-12-13`-Version ist, wird `"record"` immer als Zeichenfolge gerendert, auch wenn das Protokollierungsformat Ihrer Funktion als JSON konfiguriert ist. Für Lambda Managed Instances müssen Sie die Schemaversion `2025-01-29` verwenden.
## Freigegebene Objekttypen
Dieser Abschnitt beschreibt die Arten von freigegebenen Objekten, die die Lambda-Telemetrie-API unterstützt.
### `InitPhase`
Eine Zeichenfolgenaufzählung, die die Phase beschreibt, in der der Initialisierungsschritt auftritt. In den meisten Fällen führt Lambda den Funktionsinitialisierungscode während der `init`-Phase aus. In einigen Fehlerfällen kann Lambda jedoch den Funktionsinitialisierungscode während der `invoke`-Phase erneut ausführen. (Dies wird als *suppressed init* bezeichnet.)
+ **Typ:** – `String`
+ **Gültige Werte** – `init`\$1`invoke`\$1`snap-start`
### `InitReportMetrics`
Ein Objekt, das Metriken zu einer Initialisierungsphase enthält.
+ **Typ:** – `Object`
Ein `InitReportMetrics`-Objekt hat die folgende Form:
```
InitReportMetrics: Object
- durationMs: Double
```
Es folgt ein Beispiel für ein `InitReportMetrics`-Objekt:
```
{
"durationMs": 247.88
}
```
### `InitType`
Eine Zeichenfolgenaufzählung, die beschreibt, wie Lambda die Umgebung initialisiert hat.
+ **Typ:** – `String`
+ **Gültige Werte** – `on-demand`\$1`provisioned-concurrency`
### `ReportMetrics`
Ein Objekt, das Details zu einer abgeschlossenen Phase enthält.
+ **Typ:** – `Object`
Ein `ReportMetrics`-Objekt hat die folgende Form:
```
ReportMetrics: Object
- billedDurationMs: Integer
- durationMs: Double
- initDurationMs?: Double
- maxMemoryUsedMB: Integer
- memorySizeMB: Integer
- restoreDurationMs?: Double
```
Es folgt ein Beispiel für ein `ReportMetrics`-Objekt:
```
{
"billedDurationMs": 694,
"durationMs": 693.92,
"initDurationMs": 397.68,
"maxMemoryUsedMB": 84,
"memorySizeMB": 128
}
```
### `RestoreReportMetrics`
Ein Objekt, das Metriken über eine abgeschlossene Wiederherstellungsphase enthält.
+ **Typ:** – `Object`
Ein `RestoreReportMetrics`-Objekt hat die folgende Form:
```
RestoreReportMetrics: Object
- durationMs: Double
```
Es folgt ein Beispiel für ein `RestoreReportMetrics`-Objekt:
```
{
"durationMs": 15.19
}
```
### `RuntimeDoneMetrics`
Ein Objekt, das Metriken über eine Aufrufphase enthält.
+ **Typ:** – `Object`
Ein `RuntimeDoneMetrics`-Objekt hat die folgende Form:
```
RuntimeDoneMetrics: Object
- durationMs: Double
- producedBytes?: Integer
```
Es folgt ein Beispiel für ein `RuntimeDoneMetrics`-Objekt:
```
{
"durationMs": 200.0,
"producedBytes": 15
}
```
### `Span`
Ein Objekt, das Details einem Span enthält. Ein Span stellt eine Arbeitseinheit oder einen Vorgang in einer Ablaufverfolgung dar. Weitere Informationen zu Spans finden Sie unter [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span) auf der **Tracing-API-Seite der OpenTelemetry Docs-Website**.
Lambda unterstützt die folgenden zwei Bereiche für das `platform.RuntimeDone`-Ereignis:
+ Der `responseLatency`-Span beschreibt, wie lange es gedauert hat, bis Ihre Lambda-Funktion mit dem Senden der Antwort begonnen hat.
+ Der `responseDuration`-Spanbeschreibt, wie lange es gedauert hat, bis Ihre Lambda-Funktion das Senden der Antwort abgeschlossen hat.
+ Die `runtimeOverhead`-Spanne beschreibt, wie lange es gedauert hat, bis die Lambda-Laufzeit signalisiert hat, dass sie für die Verarbeitung des nächsten Funktionsaufrufs bereit ist. Dies ist die Zeit, die die Laufzeit benötigt hat, um die [nächste Aufruf](runtimes-api.md#runtimes-api-next)-API aufzurufen, um das nächste Ereignis nach der Rückgabe Ihrer Funktionsantwort zu erhalten.
Es folgt ein Beispiel für ein Objekt des `responseLatency`-Spans:
```
{
"name": "responseLatency",
"start": "2022-08-02T12:01:23.521Z",
"durationMs": 23.02
}
```
### `Status`
Ein Objekt, das den Status einer Initialisierungs- oder Aufrufphase beschreibt. Wenn der Status entweder `failure` oder `error` ist, dann enthält das `Status`-Objekt auch ein `errorType`-Feld, das den Fehler beschreibt.
+ **Typ:** – `Object`
+ **Gültige Statuswerte** – `success`\$1`failure`\$1`error`\$1`timeout`
### `TraceContext`
Ein Objekt, das die Eigenschaften einer Ablaufverfolgung beschreibt.
+ **Typ:** – `Object`
Ein `TraceContext`-Objekt hat die folgende Form:
```
TraceContext: Object
- spanId?: String
- type: TracingType enum
- value: String
```
Es folgt ein Beispiel für ein `TraceContext`-Objekt:
```
{
"spanId": "073a49012f3c312e",
"type": "X-Amzn-Trace-Id",
"value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1"
}
```
### `TracingType`
Eine Zeichenfolgenaufzählung, die den Ablaufverfolgungstyp in einem ``TraceContext``-Objekt beschreibt.
+ **Typ:** – `String`
+ **Gültige Werte** – `X-Amzn-Trace-Id`