

# Lambda 遥测 API `Event` 架构参考
<a name="telemetry-schema-reference"></a>

使用 Lambda 遥测 API 端点订阅遥测流的扩展。您可以从 `AWS_LAMBDA_RUNTIME_API` 环境变量中检索遥测 API 端点。若要发送 API 请求，请附加 API 版本（`2022-07-01/`）和 `telemetry/`。例如：

```
http://${AWS_LAMBDA_RUNTIME_API}/2022-07-01/telemetry/
```

有关订阅响应版本 `2025-01-29` 的 OpenAPI 规范（OAS）定义，请参阅以下内容：
+ **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)

下表汇总了遥测 API 支持的所有 `Event` 对象类型。


| 类别 | Event type | 说明 | 事件记录架构 | 
| --- | --- | --- | --- | 
|  平台事件  |  `platform.initStart`  |  函数初始化已启动。  |  [`platform.initStart`](#platform-initStart) 架构  | 
|  平台事件  |  `platform.initRuntimeDone`  |  函数初始化已完成。  |  [`platform.initRuntimeDone`](#platform-initRuntimeDone) 架构  | 
|  平台事件  |  `platform.initReport`  |  函数初始化的报告。  |  [`platform.initReport`](#platform-initReport) 架构  | 
|  平台事件  |  `platform.start`  |  函数调用已启动。  |  [`platform.start`](#platform-start) 架构  | 
|  平台事件  |  `platform.runtimeDone`  |  运行时通过成功或失败的方式完成对事件的处理。  |  [`platform.runtimeDone`](#platform-runtimeDone) 架构  | 
|  平台事件  |  `platform.report`  |  函数调用的报告。  |  [`platform.report`](#platform-report) 架构  | 
|  平台事件  |  `platform.restoreStart`  |  运行时恢复已开始。  |  [`platform.restoreStart`](#platform-restoreStart) 架构  | 
|  平台事件  |  `platform.restoreRuntimeDone`  |  运行时恢复已完成。  |  [`platform.restoreRuntimeDone`](#platform-restoreRuntimeDone) 架构  | 
|  平台事件  |  `platform.restoreReport`  |  运行时恢复报告。  |  [`platform.restoreReport`](#platform-restoreReport) 架构  | 
|  平台事件  |  `platform.telemetrySubscription`  |  扩展订阅了遥测 API。  |  [`platform.telemetrySubscription`](#platform-telemetrySubscription) 架构  | 
|  平台事件  |  `platform.logsDropped`  |  Lambda 删除了日志条目。  |  [`platform.logsDropped`](#platform-logsDropped) 架构  | 
|  函数日志  |  `function`  |  来自函数代码的日志行。  |  [`function`](#telemetry-api-function) 架构  | 
|  扩展日志  |  `extension`  |  来自扩展代码的日志行。  |  [`extension`](#telemetry-api-extension) 架构  | 

**Contents**
+ [遥测 API `Event` 对象类型](#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)
+ [共享对象类型](#telemetry-api-objects)
  + [`InitPhase`](#InitPhase)
  + [`InitReportMetrics`](#InitReportMetrics)
  + [`InitType`](#InitType)
  + [`ReportMetrics`](#ReportMetrics)
  + [`RestoreReportMetrics`](#RestoreReportMetrics)
  + [`RuntimeDoneMetrics`](#RuntimeDoneMetrics)
  + [`Span`](#Span)
  + [`Status`](#Status)
  + [`TraceContext`](#TraceContext)
  + [`TracingType`](#TracingType)

## 遥测 API `Event` 对象类型
<a name="telemetry-api-events"></a>

本节详细介绍 Lambda 遥测 API 支持的 `Event` 对象类型。在事件描述中，问号（`?`）表示该属性可能不存在于对象中。

### `platform.initStart`
<a name="platform-initStart"></a>

`platform.initStart` 事件表示函数初始化阶段已开始。`platform.initStart` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.initStart
- record: PlatformInitStart
```

`PlatformInitStart` 对象具有以下属性：
+ **functionName** – `String`
+ **functionVersion** – `String`
+ **initializationType** – ``InitType`` 对象
+ **instanceId?** – `String`
+ **instanceMaxMemory?** – `Integer`
+ **phase** – ``InitPhase`` 对象
+ **runtimeVersion?** – `String`
+ **runtimeVersionArn?** – `String`

以下是 `platform.initStart` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-initRuntimeDone"></a>

`platform.initRuntimeDone` 事件表示函数初始化阶段已完成。`platform.initRuntimeDone` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.initRuntimeDone
- record: PlatformInitRuntimeDone
```

`PlatformInitRuntimeDone` 对象具有以下属性：
+ **initializationType** – ``InitType`` 对象
+ **phase** – ``InitPhase`` 对象
+ **status** – ``Status`` 对象
+ **spans?** – ``Span`` 对象的列表。

以下是 `platform.initRuntimeDone` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-initReport"></a>

`platform.initReport` 事件包含函数初始化阶段的总体报告。`platform.initReport` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.initReport
- record: PlatformInitReport
```

`PlatformInitReport` 对象具有以下属性：
+ **errorType?** – 字符串
+ **initializationType** – ``InitType`` 对象
+ **phase** – ``InitPhase`` 对象
+ **metrics** – ``InitReportMetrics`` 对象
+ **spans?** – ``Span`` 对象的列表。
+ **status** – ``Status`` 对象

以下是 `platform.initReport` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-start"></a>

`platform.start` 事件表示函数调用阶段已开始。`platform.start` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.start
- record: PlatformStart
```

`PlatformStart` 对象具有以下属性：
+ **requestId** – `String`
+ **version?** – `String`
+ **tracing?** – ``TraceContext``

以下是 `platform.start` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-runtimeDone"></a>

`platform.runtimeDone` 事件表示函数调用阶段已完成。`platform.runtimeDone` `Event` 对象具有以下形状：

**Lambda 托管实例**  
Lambda 托管实例不支持 `platform.runtimeDone` 事件。在托管实例上运行的扩展程序将不会收到此事件，因为扩展程序无法在托管实例上订阅 `INVOKE` 事件。由于并发执行模型可以同时处理多个调用，因此扩展程序无法像传统上在 Lambda（默认）函数上那样对单个调用执行调用后处理。  
对于托管实例，通常包含在 `platform.runtimeDone` 中的 `responseLatency` 和 `responseDuration` 跨度在 `platform.report` 事件中可用。有关详细信息，请参阅 [`platform.report`](#platform-report)。

```
Event: Object
- time: String
- type: String = platform.runtimeDone
- record: PlatformRuntimeDone
```

`PlatformRuntimeDone` 对象具有以下属性：
+ **errorType?** – `String`
+ **metrics?** – ``RuntimeDoneMetrics`` 对象
+ **requestId** – `String`
+ **status** – ``Status`` 对象
+ **spans?** – ``Span`` 对象的列表。
+ **tracing?** – ``TraceContext`` 对象

以下是 `platform.runtimeDone` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-report"></a>

`platform.report` 事件包含函数调用阶段的总体报告。`platform.report` `Event` 对象具有以下形状：

**Lambda 托管实例**  
与 Lambda（默认）函数相比，Lambda 托管实例的 `platform.report` 事件具有不同的指标和跨度。对于托管实例：  
**跨度**：包含 `responseLatency` 和 `responseDuration`，而不是 `extensionOverhead`。`extensionOverhead` 跨度不可用，由于并发执行模式，扩展程序无法在托管实例上订阅 `INVOKE` 事件。
**指标**：仅包含 `durationMs`。不包含以下指标：`billedDurationMs`、`initDurationMs`、`maxMemoryUsedMB` 和 `memorySizeMB`。这些基于每次调用的指标在并发执行环境中并不适用。有关资源利用率指标，请使用 [监控 Lambda 托管实例](lambda-managed-instances-monitoring.md) 或 [Lambda Insights](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-insights.html)。

```
Event: Object
- time: String
- type: String = platform.report
- record: PlatformReport
```

`PlatformReport` 对象具有以下属性：
+ **metrics** – ``ReportMetrics`` 对象
+ **requestId** – `String`
+ **spans?** – ``Span`` 对象的列表。
+ **status** – ``Status`` 对象
+ **tracing?** – ``TraceContext`` 对象

以下是 `platform.report` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-restoreStart"></a>

`platform.restoreStart` 事件表示函数环境还原事件已启动。在环境还原事件中，Lambda 会从缓存的快照创建环境，而不是从头开始初始化该环境。有关更多信息，请参阅 [Lambda SnapStart](snapstart.md)。`platform.restoreStart` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.restoreStart
- record: PlatformRestoreStart
```

`PlatformRestoreStart` 对象具有以下属性：
+ **functionName** – `String`
+ **functionVersion** – `String`
+ **instanceId?** – `String`
+ **instanceMaxMemory?** – `String`
+ **runtimeVersion?** – `String`
+ **runtimeVersionArn?** – `String`

以下是 `platform.restoreStart` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-restoreRuntimeDone"></a>

`platform.restoreRuntimeDone` 事件表示函数环境还原事件已完成。在环境还原事件中，Lambda 会从缓存的快照创建环境，而不是从头开始初始化该环境。有关更多信息，请参阅 [Lambda SnapStart](snapstart.md)。`platform.restoreRuntimeDone` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.restoreRuntimeDone
- record: PlatformRestoreRuntimeDone
```

`PlatformRestoreRuntimeDone` 对象具有以下属性：
+ **errorType?** – `String`
+ **spans?** – ``Span`` 对象的列表。
+ **status** – ``Status`` 对象

以下是 `platform.restoreRuntimeDone` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-restoreReport"></a>

`platform.restoreReport` 事件包含函数还原事件的总体报告。`platform.restoreReport` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.restoreReport
- record: PlatformRestoreReport
```

`PlatformRestoreReport` 对象具有以下属性：
+ **errorType?** – 字符串
+ **metrics?** – ``RestoreReportMetrics`` 对象
+ **spans?** – ``Span`` 对象的列表。
+ **status** – ``Status`` 对象

以下是 `platform.restoreReport` 类型的示例 `Event`：

```
{
    "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`
<a name="platform-extension"></a>

`extension` 事件包含来自扩展代码的日志。`extension` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = extension
- record: {}
```

`PlatformExtension` 对象具有以下属性：
+ **events** – `String` 列表
+ **name** – `String`
+ **state** – `String`

以下是 `platform.extension` 类型的示例 `Event`：

```
{
    "time": "2022-10-12T00:02:15.000Z",
    "type": "platform.extension",
    "record": {
        "events": [ "INVOKE", "SHUTDOWN" ],
        "name": "my-telemetry-extension",
        "state": "Ready"
    }
}
```

### `platform.telemetrySubscription`
<a name="platform-telemetrySubscription"></a>

`platform.telemetrySubscription` 事件包含有关扩展订阅的信息。`platform.telemetrySubscription` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.telemetrySubscription
- record: PlatformTelemetrySubscription
```

`PlatformTelemetrySubscription` 对象具有以下属性：
+ **name** – `String`
+ **state** – `String`
+ **types** – `String` 列表

以下是 `platform.telemetrySubscription` 类型的示例 `Event`：

```
{
    "time": "2022-10-12T00:02:35.000Z",
    "type": "platform.telemetrySubscription",
    "record": {
        "name": "my-telemetry-extension",
        "state": "Subscribed",
        "types": [ "platform", "function" ]
    }
}
```

### `platform.logsDropped`
<a name="platform-logsDropped"></a>

`platform.logsDropped` 事件包含有关已丢弃事件的信息。函数输出日志的速度过快，超过 Lambda 的处理能力时，Lambda 会发出 `platform.logsDropped` 事件。当 Lambda 无法按照函数生成日志的速度将日志发送给 CloudWatch 或订阅到遥测 API 的扩展时，它会丢弃日志以防止函数的执行速度变慢。`platform.logsDropped` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = platform.logsDropped
- record: PlatformLogsDropped
```

`PlatformLogsDropped` 对象具有以下属性：
+ **droppedBytes** – `Integer`
+ **droppedRecords** – `Integer`
+ **reason** – `String`

以下是 `platform.logsDropped` 类型的示例 `Event`：

```
{
    "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`
<a name="telemetry-api-function"></a>

`function` 事件包含来自函数代码的日志。`function` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = function
- record: {}
```

`record` 字段的格式取决于函数的日志格式为纯文本还是 JSON 格式。要了解有关日志格式配置选项的更多信息，请参阅 [配置 JSON 和纯文本日志格式](monitoring-cloudwatchlogs-logformat.md)

以下是日志格式为纯文本的 `function` 类型 `Event` 示例：

```
{
    "time": "2022-10-12T00:03:50.000Z",
    "type": "function",
    "record": "[INFO] Hello world, I am a function!"
}
```

以下是日志格式为 JSON 的 `function` 类型 `Event` 示例：

```
{
    "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!"
    }
}
```

**注意**  
如果您使用的架构版本早于 `2022-12-13` 版本，则即使将函数的日志格式配置为 JSON，也会始终将 `"record"` 呈现为字符串。对于 Lambda 托管实例，您必须使用架构版本 `2025-01-29`。

### `extension`
<a name="telemetry-api-extension"></a>

`extension` 事件包含来自扩展代码的日志。`extension` `Event` 对象具有以下形状：

```
Event: Object
- time: String
- type: String = extension
- record: {}
```

`record` 字段的格式取决于函数的日志格式为纯文本还是 JSON 格式。要了解有关日志格式配置选项的更多信息，请参阅 [配置 JSON 和纯文本日志格式](monitoring-cloudwatchlogs-logformat.md)

以下是日志格式为纯文本的 `extension` 类型 `Event` 示例：

```
{
    "time": "2022-10-12T00:03:50.000Z",
    "type": "extension",
    "record": "[INFO] Hello world, I am an extension!"
}
```

以下是日志格式为 JSON 的 `extension` 类型 `Event` 示例：

```
{
    "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!"
    }    
}
```

**注意**  
如果您使用的架构版本早于 `2022-12-13` 版本，则即使将函数的日志格式配置为 JSON，也会始终将 `"record"` 呈现为字符串。对于 Lambda 托管实例，您必须使用架构版本 `2025-01-29`。

## 共享对象类型
<a name="telemetry-api-objects"></a>

本节详细介绍 Lambda 遥测 API 支持的共享对象类型。

### `InitPhase`
<a name="InitPhase"></a>

描述初始化步骤发生时的阶段的字符串枚举。在大多数情况下，Lambda 在 `init` 阶段期间运行函数初始化代码。但是，在某些发生错误的情况下，Lambda 可能会在 `invoke` 阶段期间重新运行函数初始化代码。（此情况称为*抑制初始化*。）
+ **类型** – `String`
+ **有效值** – `init`\$1`invoke`\$1`snap-start`

### `InitReportMetrics`
<a name="InitReportMetrics"></a>

包含有关初始化阶段指标的对象。
+ **类型** – `Object`

`InitReportMetrics` 对象具有以下形状：

```
InitReportMetrics: Object
- durationMs: Double
```

以下是 `InitReportMetrics` 对象的示例：

```
{
    "durationMs": 247.88
}
```

### `InitType`
<a name="InitType"></a>

描述 Lambda 如何初始化环境的字符串枚举。
+ **类型** – `String`
+ **有效值** – `on-demand`\$1`provisioned-concurrency`

### `ReportMetrics`
<a name="ReportMetrics"></a>

包含有关已完成阶段指标的对象。
+ **类型** – `Object`

`ReportMetrics` 对象具有以下形状：

```
ReportMetrics: Object
- billedDurationMs: Integer
- durationMs: Double
- initDurationMs?: Double
- maxMemoryUsedMB: Integer
- memorySizeMB: Integer
- restoreDurationMs?: Double
```

以下是 `ReportMetrics` 对象的示例：

```
{
    "billedDurationMs": 694,
    "durationMs": 693.92,
    "initDurationMs": 397.68,
    "maxMemoryUsedMB": 84,
    "memorySizeMB": 128
}
```

### `RestoreReportMetrics`
<a name="RestoreReportMetrics"></a>

包含有关已完成还原阶段指标的对象。
+ **类型** – `Object`

`RestoreReportMetrics` 对象具有以下形状：

```
RestoreReportMetrics: Object
- durationMs: Double
```

以下是 `RestoreReportMetrics` 对象的示例：

```
{
    "durationMs": 15.19
}
```

### `RuntimeDoneMetrics`
<a name="RuntimeDoneMetrics"></a>

包含有关调用阶段指标的对象。
+ **类型** – `Object`

`RuntimeDoneMetrics` 对象具有以下形状：

```
RuntimeDoneMetrics: Object
- durationMs: Double
- producedBytes?: Integer
```

以下是 `RuntimeDoneMetrics` 对象的示例：

```
{
    "durationMs": 200.0,
    "producedBytes": 15
}
```

### `Span`
<a name="Span"></a>

包含有关跨度详细信息的对象。跨度表示某个跟踪中的一个工作或操作单位。有关跨度的更多信息，请参阅 OpenTelemetry Docs 网站 **Tracing API**（跟踪 API）页面上的 [Span](https://opentelemetry.io/docs/reference/specification/trace/api/#span)（跨度）。

Lambda 对 `platform.RuntimeDone` 事件支持以下跨度：
+ `responseLatency` 跨度描述了 Lambda 函数开始发送响应所需的时间。
+ `responseDuration` 跨度描述 Lambda 函数完成发送整个响应所需的时间。
+ `runtimeOverhead` 跨度描述了 Lambda 运行时系统发出信号表明其已准备好处理下一个函数调用所需的时间。这是返回函数响应后，运行时系统调用[下一个调用](runtimes-api.md#runtimes-api-next) API 以获取下一个事件所需的时间。

以下是 `responseLatency` 跨度对象的示例：

```
{
        "name": "responseLatency", 
        "start": "2022-08-02T12:01:23.521Z",
        "durationMs": 23.02
      }
```

### `Status`
<a name="Status"></a>

描述初始化或调用阶段状态的对象。如果状态为 `failure` 或 `error`，则 `Status` 对象还会包含一个 `errorType` 字段，用来描述错误。
+ **类型** – `Object`
+ **有效状态值** – `success`\$1`failure`\$1`error`\$1`timeout`

### `TraceContext`
<a name="TraceContext"></a>

描述跟踪属性的对象。
+ **类型** – `Object`

`TraceContext` 对象具有以下形状：

```
TraceContext: Object
- spanId?: String
- type: TracingType enum
- value: String
```

以下是 `TraceContext` 对象的示例：

```
{
    "spanId": "073a49012f3c312e",
    "type": "X-Amzn-Trace-Id",
    "value": "Root=1-62e900b2-710d76f009d6e7785905449a;Parent=0efbd19962d95b05;Sampled=1"
}
```

### `TracingType`
<a name="TracingType"></a>

描述 ``TraceContext`` 对象中跟踪类型的字符串枚举。
+ **类型** – `String`
+ **有效值** – `X-Amzn-Trace-Id`