From e4151dcd89a075902fd290e5dc551fe31611e9a1 Mon Sep 17 00:00:00 2001 From: chrismark Date: Wed, 8 Apr 2020 18:12:51 +0300 Subject: [PATCH] Add static mapping for dynamodb metricset 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..e8c279c8dc5 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 average of successful requests to DynamoDB or Amazon DynamoDB Streams during the specified time period. + + + +*`aws.dynamodb.metrics.SuccessfulRequestLatency.avg`*:: ++ +-- +type: long + +-- + +*`aws.dynamodb.metrics.SuccessfulRequestLatency.max`*:: ++ +-- +type: long + +-- + +*`aws.dynamodb.metrics.OnlineIndexPercentageProgress.avg`*:: ++ +-- +The percentage of completion when a new global secondary index is being added to a table. + + +type: long + +-- + +*`aws.dynamodb.metrics.ProvisionedWriteCapacityUnits.avg`*:: ++ +-- +The number of provisioned write capacity units for a table or a global secondary index. + + +type: long + +-- + +*`aws.dynamodb.metrics.ProvisionedReadCapacityUnits.avg`*:: ++ +-- +The number of provisioned read capacity units for a table or a global secondary index. + + +type: long + +-- + +[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: long + +-- + +*`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: long + +-- + +*`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: long + +-- + +*`aws.dynamodb.metrics.ReplicationLatency.max`*:: ++ +-- +type: long + +-- + +[float] +=== TransactionConflict + +Rejected item-level requests due to transactional conflicts between concurrent requests on the same items. + + + +*`aws.dynamodb.metrics.TransactionConflict.avg`*:: ++ +-- +type: long + +-- + +*`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: long + +-- + +*`aws.dynamodb.metrics.AccountProvisionedWriteCapacityUtilization.avg`*:: ++ +-- +The average percentage of provisioned write capacity units utilized by the account. + + +type: long + +-- + +*`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: long + +-- + +*`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: long + +-- + [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..5cbf1088a16 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 average of successful requests to DynamoDB or Amazon DynamoDB + Streams during the specified time period. + fields: + - name: avg + type: long + - name: max + type: long + - name: OnlineIndexPercentageProgress.avg + type: long + description: > + The percentage of completion when a new global secondary index is being added to a table. + - name: ProvisionedWriteCapacityUnits.avg + type: long + description: > + The number of provisioned write capacity units for a table or a global secondary index. + - name: ProvisionedReadCapacityUnits.avg + type: long + 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: long + - 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: long + - 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: long + - name: max + type: long + - name: TransactionConflict + type: group + description: > + Rejected item-level requests due to transactional conflicts between concurrent + requests on the same items. + fields: + - name: avg + type: long + - name: sum + type: long + - name: AccountProvisionedReadCapacityUtilization.avg + type: long + description: > + The average percentage of provisioned read capacity units utilized by the account. + - name: AccountProvisionedWriteCapacityUtilization.avg + type: long + 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: long + 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: long + 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..c9c9fa2eae0 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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" }