From e0238454a290230dcd64b44cae9d84445a38a06a Mon Sep 17 00:00:00 2001 From: Chris Mark Date: Tue, 14 Apr 2020 11:22:30 +0300 Subject: [PATCH] Add static mapping for dynamodb metricset (#17614) * Add static mapping for dynamodb metricset Signed-off-by: chrismark * Fix field types Signed-off-by: chrismark --- metricbeat/docs/fields.asciidoc | 277 ++++++++++++++++++ .../module/aws/dynamodb/_meta/fields.yml | 134 +++++++++ x-pack/metricbeat/module/aws/fields.go | 2 +- 3 files changed, 412 insertions(+), 1 deletion(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 0af75fe4aac..8996357d382 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -1600,6 +1600,283 @@ type: keyword `dynamodb` contains the metrics that were scraped from AWS CloudWatch which contains monitoring metrics sent by AWS DynamoDB. + + +[float] +=== SuccessfulRequestLatency + +The latency of successful requests to DynamoDB or Amazon DynamoDB Streams during the specified time period. + + + +*`aws.dynamodb.metrics.SuccessfulRequestLatency.avg`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.SuccessfulRequestLatency.max`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.OnlineIndexPercentageProgress.avg`*:: ++ +-- +The percentage of completion when a new global secondary index is being added to a table. + + +type: double + +-- + +*`aws.dynamodb.metrics.ProvisionedWriteCapacityUnits.avg`*:: ++ +-- +The number of provisioned write capacity units for a table or a global secondary index. + + +type: double + +-- + +*`aws.dynamodb.metrics.ProvisionedReadCapacityUnits.avg`*:: ++ +-- +The number of provisioned read capacity units for a table or a global secondary index. + + +type: double + +-- + +[float] +=== ConsumedReadCapacityUnits + +The number of read capacity units consumed over the specified time period, so you can track how much of your provisioned throughput is used. + + + +*`aws.dynamodb.metrics.ConsumedReadCapacityUnits.avg`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.ConsumedReadCapacityUnits.sum`*:: ++ +-- +type: long + +-- + +[float] +=== ConsumedWriteCapacityUnits + +The number of write capacity units consumed over the specified time period, so you can track how much of your provisioned throughput is used. + + + +*`aws.dynamodb.metrics.ConsumedWriteCapacityUnits.avg`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.ConsumedWriteCapacityUnits.sum`*:: ++ +-- +type: long + +-- + +[float] +=== ReplicationLatency + +The elapsed time between an updated item appearing in the DynamoDB stream for one replica table, and that item appearing in another replica in the global table. + + + +*`aws.dynamodb.metrics.ReplicationLatency.avg`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.ReplicationLatency.max`*:: ++ +-- +type: double + +-- + +[float] +=== TransactionConflict + +Rejected item-level requests due to transactional conflicts between concurrent requests on the same items. + + + +*`aws.dynamodb.metrics.TransactionConflict.avg`*:: ++ +-- +type: double + +-- + +*`aws.dynamodb.metrics.TransactionConflict.sum`*:: ++ +-- +type: long + +-- + +*`aws.dynamodb.metrics.AccountProvisionedReadCapacityUtilization.avg`*:: ++ +-- +The average percentage of provisioned read capacity units utilized by the account. + + +type: double + +-- + +*`aws.dynamodb.metrics.AccountProvisionedWriteCapacityUtilization.avg`*:: ++ +-- +The average percentage of provisioned write capacity units utilized by the account. + + +type: double + +-- + +*`aws.dynamodb.metrics.SystemErrors.sum`*:: ++ +-- +The requests to DynamoDB or Amazon DynamoDB Streams that generate an HTTP 500 status code during the specified time period. + + +type: long + +-- + +*`aws.dynamodb.metrics.ConditionalCheckFailedRequests.sum`*:: ++ +-- +The number of failed attempts to perform conditional writes. + + +type: long + +-- + +*`aws.dynamodb.metrics.PendingReplicationCount.sum`*:: ++ +-- +The number of item updates that are written to one replica table, but that have not yet been written to another replica in the global table. + + +type: long + +-- + +*`aws.dynamodb.metrics.ReadThrottleEvents.sum`*:: ++ +-- +Requests to DynamoDB that exceed the provisioned read capacity units for a table or a global secondary index. + + +type: long + +-- + +*`aws.dynamodb.metrics.ThrottledRequests.sum`*:: ++ +-- +Requests to DynamoDB that exceed the provisioned throughput limits on a resource (such as a table or an index). + + +type: long + +-- + +*`aws.dynamodb.metrics.WriteThrottleEvents.sum`*:: ++ +-- +Requests to DynamoDB that exceed the provisioned write capacity units for a table or a global secondary index. + + +type: long + +-- + +*`aws.dynamodb.metrics.AccountMaxReads.max`*:: ++ +-- +The maximum number of read capacity units that can be used by an account. This limit does not apply to on-demand tables or global secondary indexes. + + +type: long + +-- + +*`aws.dynamodb.metrics.AccountMaxTableLevelReads.max`*:: ++ +-- +The maximum number of read capacity units that can be used by a table or global secondary index of an account. For on-demand tables this limit caps the maximum read request units a table or a global secondary index can use. + + +type: long + +-- + +*`aws.dynamodb.metrics.AccountMaxTableLevelWrites.max`*:: ++ +-- +The maximum number of write capacity units that can be used by a table or global secondary index of an account. For on-demand tables this limit caps the maximum write request units a table or a global secondary index can use. + + +type: long + +-- + +*`aws.dynamodb.metrics.AccountMaxWrites.max`*:: ++ +-- +The maximum number of write capacity units that can be used by an account. This limit does not apply to on-demand tables or global secondary indexes. + + +type: long + +-- + +*`aws.dynamodb.metrics.MaxProvisionedTableReadCapacityUtilization.max`*:: ++ +-- +The percentage of provisioned read capacity units utilized by the highest provisioned read table or global secondary index of an account. + + +type: double + +-- + +*`aws.dynamodb.metrics.MaxProvisionedTableWriteCapacityUtilization.max`*:: ++ +-- +The percentage of provisioned write capacity utilized by the highest provisioned write table or global secondary index of an account. + + +type: double + +-- + [float] === ebs diff --git a/x-pack/metricbeat/module/aws/dynamodb/_meta/fields.yml b/x-pack/metricbeat/module/aws/dynamodb/_meta/fields.yml index 0ac62c55439..ddb767cbe55 100644 --- a/x-pack/metricbeat/module/aws/dynamodb/_meta/fields.yml +++ b/x-pack/metricbeat/module/aws/dynamodb/_meta/fields.yml @@ -4,3 +4,137 @@ `dynamodb` contains the metrics that were scraped from AWS CloudWatch which contains monitoring metrics sent by AWS DynamoDB. release: beta fields: + - name: metrics + type: group + fields: + - name: SuccessfulRequestLatency + type: group + description: > + The latency of successful requests to DynamoDB or Amazon DynamoDB Streams + during the specified time period. + fields: + - name: avg + type: double + - name: max + type: double + - name: OnlineIndexPercentageProgress.avg + type: double + description: > + The percentage of completion when a new global secondary index is being added to a table. + - name: ProvisionedWriteCapacityUnits.avg + type: double + description: > + The number of provisioned write capacity units for a table or a global secondary index. + - name: ProvisionedReadCapacityUnits.avg + type: double + description: > + The number of provisioned read capacity units for a table or a global secondary index. + - name: ConsumedReadCapacityUnits + type: group + description: > + The number of read capacity units consumed over the specified time period, + so you can track how much of your provisioned throughput is used. + fields: + - name: avg + type: double + - name: sum + type: long + - name: ConsumedWriteCapacityUnits + type: group + description: > + The number of write capacity units consumed over the specified time period, + so you can track how much of your provisioned throughput is used. + fields: + - name: avg + type: double + - name: sum + type: long + - name: ReplicationLatency + type: group + description: > + The elapsed time between an updated item appearing in the DynamoDB stream for + one replica table, and that item appearing in another replica in the global table. + fields: + - name: avg + type: double + - name: max + type: double + - name: TransactionConflict + type: group + description: > + Rejected item-level requests due to transactional conflicts between concurrent + requests on the same items. + fields: + - name: avg + type: double + - name: sum + type: long + - name: AccountProvisionedReadCapacityUtilization.avg + type: double + description: > + The average percentage of provisioned read capacity units utilized by the account. + - name: AccountProvisionedWriteCapacityUtilization.avg + type: double + description: > + The average percentage of provisioned write capacity units utilized by the account. + - name: SystemErrors.sum + type: long + description: > + The requests to DynamoDB or Amazon DynamoDB Streams that generate + an HTTP 500 status code during the specified time period. + - name: ConditionalCheckFailedRequests.sum + type: long + description: > + The number of failed attempts to perform conditional writes. + - name: PendingReplicationCount.sum + type: long + description: > + The number of item updates that are written to one replica table, + but that have not yet been written to another replica in the global table. + - name: ReadThrottleEvents.sum + type: long + description: > + Requests to DynamoDB that exceed the provisioned read capacity + units for a table or a global secondary index. + - name: ThrottledRequests.sum + type: long + description: > + Requests to DynamoDB that exceed the provisioned throughput limits + on a resource (such as a table or an index). + - name: WriteThrottleEvents.sum + type: long + description: > + Requests to DynamoDB that exceed the provisioned write capacity + units for a table or a global secondary index. + - name: AccountMaxReads.max + type: long + description: > + The maximum number of read capacity units that can be used by an account. + This limit does not apply to on-demand tables or global secondary indexes. + - name: AccountMaxTableLevelReads.max + type: long + description: > + The maximum number of read capacity units that can be used by a table or global + secondary index of an account. For on-demand tables this limit caps the maximum + read request units a table or a global secondary index can use. + - name: AccountMaxTableLevelWrites.max + type: long + description: > + The maximum number of write capacity units that can be used by a table or global + secondary index of an account. For on-demand tables this limit caps the maximum + write request units a table or a global secondary index can use. + - name: AccountMaxWrites.max + type: long + description: > + The maximum number of write capacity units that can be used by an account. + This limit does not apply to on-demand tables or global secondary indexes. + - name: MaxProvisionedTableReadCapacityUtilization.max + type: double + description: > + The percentage of provisioned read capacity units utilized by the highest + provisioned read table or global secondary index of an account. + - name: MaxProvisionedTableWriteCapacityUtilization.max + type: double + description: > + The percentage of provisioned write capacity utilized by the highest provisioned + write table or global secondary index of an account. diff --git a/x-pack/metricbeat/module/aws/fields.go b/x-pack/metricbeat/module/aws/fields.go index fea94e574c1..d50507f86c0 100644 --- a/x-pack/metricbeat/module/aws/fields.go +++ b/x-pack/metricbeat/module/aws/fields.go @@ -19,5 +19,5 @@ func init() { // AssetAws returns asset data. // This is the base64 encoded gzipped contents of module/aws. func AssetAws() string { - return "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" + return "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" }