From ed3ee020cee5b0c73a7702b5f06ec36db0022e6d Mon Sep 17 00:00:00 2001 From: kaiyan-sheng Date: Wed, 3 Jun 2020 07:32:04 -0600 Subject: [PATCH] Fix fields.yml for googlecloud module --- metricbeat/docs/fields.asciidoc | 1223 +++++++++++++++++ .../module/googlecloud/_meta/fields.yml | 27 +- .../metricbeat/module/googlecloud/fields.go | 2 +- 3 files changed, 1242 insertions(+), 10 deletions(-) diff --git a/metricbeat/docs/fields.asciidoc b/metricbeat/docs/fields.asciidoc index 25fd88e9828..9a342fccfe4 100644 --- a/metricbeat/docs/fields.asciidoc +++ b/metricbeat/docs/fields.asciidoc @@ -17174,13 +17174,1236 @@ GCP module + *`googlecloud.labels`*:: + -- +Google cloud monitoring metrics labels + + type: object -- +[float] +=== compute + +Google Cloud Compute metrics + + + + +*`googlecloud.compute.instance.firewall.dropped_bytes_count`*:: ++ +-- +Incoming bytes dropped by the firewall + +type: long + +-- + +*`googlecloud.compute.instance.firewall.dropped_packets_count`*:: ++ +-- +Incoming packets dropped by the firewall + +type: long + +-- + + +*`googlecloud.compute.instance.cpu.reserved_cores`*:: ++ +-- +Number of cores reserved on the host of the instance + +type: double + +-- + +*`googlecloud.compute.instance.cpu.utilization`*:: ++ +-- +The fraction of the allocated CPU that is currently in use on the instance + +type: double + +-- + +*`googlecloud.compute.instance.cpu.usage_time`*:: ++ +-- +Usage for all cores in seconds + +type: double + +-- + + +*`googlecloud.compute.instance.disk.read_bytes_count`*:: ++ +-- +Count of bytes read from disk + +type: long + +-- + +*`googlecloud.compute.instance.disk.read_ops_count`*:: ++ +-- +Count of disk read IO operations + +type: long + +-- + +*`googlecloud.compute.instance.disk.write_bytes_count`*:: ++ +-- +Count of bytes written to disk + +type: long + +-- + +*`googlecloud.compute.instance.disk.write_ops_count`*:: ++ +-- +Count of disk write IO operations + +type: long + +-- + +*`googlecloud.compute.instance.uptime`*:: ++ +-- +How long the VM has been running, in seconds + +type: long + +-- + + +*`googlecloud.compute.instance.network.received_bytes_count`*:: ++ +-- +Count of bytes received from the network + +type: long + +-- + +*`googlecloud.compute.instance.network.received_packets_count`*:: ++ +-- +Count of packets received from the network + +type: long + +-- + +*`googlecloud.compute.instance.network.sent_bytes_count`*:: ++ +-- +Count of bytes sent over the network + +type: long + +-- + +*`googlecloud.compute.instance.network.sent_packets_count`*:: ++ +-- +Count of packets sent over the network + +type: long + +-- + +[float] +=== loadbalancing + +Google Cloud Load Balancing metrics + + +[float] +=== https + +Google Cloud Load Balancing metrics + + +[float] +=== backend_latencies + +A distribution of the latency calculated from when the request was sent by the proxy to the backend until the proxy received from the backend the last byte of response. + + +*`googlecloud.loadbalancing.https.backend_latencies.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_latencies.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_latencies.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.https.backend_latencies.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.https.backend_latencies.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_latencies.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_request_bytes_count`*:: ++ +-- +The number of bytes sent as requests from HTTP/S load balancer to backends. + +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_request_count`*:: ++ +-- +The number of requests served by backends of HTTP/S load balancer. + +type: long + +-- + +*`googlecloud.loadbalancing.https.backend_response_bytes_count`*:: ++ +-- +The number of bytes sent as responses from backends (or cache) to HTTP/S load balancer. + +type: long + +-- + +[float] +=== frontend_tcp_rtt + +A distribution of the RTT measured for each connection between client and proxy. + + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + + +[float] +=== backend_latencies + +A distribution of the latency calculated from when the request was sent by the proxy to the backend until the proxy received from the backend the last byte of response. + + +*`googlecloud.loadbalancing.https.internal.backend_latencies.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.backend_latencies.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.backend_latencies.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.https.internal.backend_latencies.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.https.internal.backend_latencies.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.backend_latencies.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.request_bytes_count`*:: ++ +-- +The number of bytes sent as requests from clients to HTTP/S load balancer. + +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.request_count`*:: ++ +-- +The number of requests served by HTTP/S load balancer. + +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.response_bytes_count`*:: ++ +-- +The number of bytes sent as responses from HTTP/S load balancer to clients. + +type: long + +-- + +[float] +=== total_latencies + +A distribution of the latency calculated from when the request was received by the proxy until the proxy got ACK from client on last response byte. + + +*`googlecloud.loadbalancing.https.internal.total_latencies.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.total_latencies.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.total_latencies.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.https.internal.total_latencies.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.https.internal.total_latencies.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.internal.total_latencies.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.request_bytes_count`*:: ++ +-- +The number of bytes sent as requests from clients to HTTP/S load balancer. + +type: long + +-- + +*`googlecloud.loadbalancing.https.request_count`*:: ++ +-- +The number of requests served by HTTP/S load balancer. + +type: long + +-- + +*`googlecloud.loadbalancing.https.response_bytes_count`*:: ++ +-- +The number of bytes sent as responses from HTTP/S load balancer to clients. + +type: long + +-- + +[float] +=== total_latencies + +A distribution of the latency calculated from when the request was received by the proxy until the proxy got ACK from client on last response byte. + + +*`googlecloud.loadbalancing.https.total_latencies.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.total_latencies.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.total_latencies.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.https.total_latencies.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.https.total_latencies.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.https.total_latencies.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +[float] +=== l3.internal + +Google Cloud Load Balancing metrics + + +*`googlecloud.loadbalancing.l3.internal.egress_bytes_count`*:: ++ +-- +The number of bytes sent from ILB backend to client (for TCP flows it's counting bytes on application stream only). + +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.egress_packets_count`*:: ++ +-- +The number of packets sent from ILB backend to client of the flow. + +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.ingress_bytes_count`*:: ++ +-- +The number of bytes sent from client to ILB backend (for TCP flows it's counting bytes on application stream only). + +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.ingress_packets_count`*:: ++ +-- +The number of packets sent from client to ILB backend. + +type: long + +-- + +[float] +=== rtt_latencies + +A distribution of RTT measured over TCP connections for ILB flows. + + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.l3.internal.rtt_latencies.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +[float] +=== tcp_ssl_proxy + +Google Cloud Load Balancing metrics + + +*`googlecloud.loadbalancing.tcp_ssl_proxy.closed_connections`*:: ++ +-- +Number of connections that were terminated over TCP/SSL proxy. + +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.egress_bytes_count`*:: ++ +-- +Number of bytes sent from VM to client using proxy. + +type: long + +-- + +[float] +=== frontend_tcp_rtt + +A distribution of the smoothed RTT (in ms) measured by the proxy's TCP stack, each minute application layer bytes pass from proxy to client. + + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.count`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.mean`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.bucket_counts`*:: ++ +-- +type: long + +-- + + + + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.growth_factor`*:: ++ +-- +type: double + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.scale`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.bucket_options.Options.ExponentialBuckets.num_finite_buckets`*:: ++ +-- +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.ingress_bytes_count`*:: ++ +-- +Number of bytes sent from client to VM using proxy. + +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.new_connections`*:: ++ +-- +Number of connections that were created over TCP/SSL proxy. + +type: long + +-- + +*`googlecloud.loadbalancing.tcp_ssl_proxy.open_connections`*:: ++ +-- +Current number of outstanding connections through the TCP/SSL proxy. + +type: long + +-- + +[float] +=== pubsub + +Google Cloud PubSub metrics + + +[float] +=== subscription + +Suscription related metrics + + +*`googlecloud.pubsub.subscription.ack_message_count`*:: ++ +-- +Cumulative count of messages acknowledged by Acknowledge requests, grouped by delivery type. + +type: long + +-- + +*`googlecloud.pubsub.subscription.backlog_bytes`*:: ++ +-- +Total byte size of the unacknowledged messages (a.k.a. backlog messages) in a subscription. + +type: long + +-- + +*`googlecloud.pubsub.subscription.num_outstanding_messages`*:: ++ +-- +Number of messages delivered to a subscription's push endpoint, but not yet acknowledged. + +type: long + +-- + +*`googlecloud.pubsub.subscription.num_undelivered_messages`*:: ++ +-- +Number of unacknowledged messages (a.k.a. backlog messages) in a subscription. + +type: long + +-- + +*`googlecloud.pubsub.subscription.oldest_unacked_message_age`*:: ++ +-- +Age (in seconds) of the oldest unacknowledged message (a.k.a. backlog message) in a subscription. + +type: long + +-- + +*`googlecloud.pubsub.subscription.pull_ack_message_operation_count`*:: ++ +-- +Cumulative count of acknowledge message operations, grouped by result. For a definition of message operations, see Cloud Pub/Sub metric subscription/mod_ack_deadline_message_operation_count. + +type: long + +-- + +*`googlecloud.pubsub.subscription.pull_ack_request_count`*:: ++ +-- +Cumulative count of acknowledge requests, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.pull_message_operation_count`*:: ++ +-- +Cumulative count of pull message operations, grouped by result. For a definition of message operations, see Cloud Pub/Sub metric subscription/mod_ack_deadline_message_operation_count. + +type: long + +-- + +*`googlecloud.pubsub.subscription.pull_request_count`*:: ++ +-- +Cumulative count of pull requests, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.push_request_count`*:: ++ +-- +Cumulative count of push attempts, grouped by result. Unlike pulls, the push server implementation does not batch user messages. So each request only contains one user message. The push server retries on errors, so a given user message can appear multiple times. + +type: long + +-- + +*`googlecloud.pubsub.subscription.push_request_latencies`*:: ++ +-- +Distribution of push request latencies (in microseconds), grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.sent_message_count`*:: ++ +-- +Cumulative count of messages sent by Cloud Pub/Sub to subscriber clients, grouped by delivery type. + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_ack_message_operation_count`*:: ++ +-- +Cumulative count of StreamingPull acknowledge message operations, grouped by result. For a definition of message operations, see Cloud Pub/Sub metric subscription/mod_ack_deadline_message_operation_count. + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_ack_request_count`*:: ++ +-- +Cumulative count of streaming pull requests with non-empty acknowledge ids, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_message_operation_count`*:: ++ +-- +Cumulative count of streaming pull message operations, grouped by result. For a definition of message operations, see Cloud Pub/Sub metric subscription/mod_ack_deadline_message_operation_count + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_response_count`*:: ++ +-- +Cumulative count of streaming pull responses, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.dead_letter_message_count`*:: ++ +-- +Cumulative count of messages published to dead letter topic, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.mod_ack_deadline_message_count`*:: ++ +-- +Cumulative count of messages whose deadline was updated by ModifyAckDeadline requests, grouped by delivery type. + +type: long + +-- + +*`googlecloud.pubsub.subscription.mod_ack_deadline_message_operation_count`*:: ++ +-- +Cumulative count of ModifyAckDeadline message operations, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.mod_ack_deadline_request_count`*:: ++ +-- +Cumulative count of ModifyAckDeadline requests, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.oldest_retained_acked_message_age`*:: ++ +-- +Age (in seconds) of the oldest acknowledged message retained in a subscription. + +type: long + +-- + +*`googlecloud.pubsub.subscription.oldest_retained_acked_message_age_by_region`*:: ++ +-- +Age (in seconds) of the oldest acknowledged message retained in a subscription, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.subscription.oldest_unacked_message_age_by_region`*:: ++ +-- +Age (in seconds) of the oldest unacknowledged message in a subscription, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.subscription.retained_acked_bytes`*:: ++ +-- +Total byte size of the acknowledged messages retained in a subscription. + +type: long + +-- + +*`googlecloud.pubsub.subscription.retained_acked_bytes_by_region`*:: ++ +-- +Total byte size of the acknowledged messages retained in a subscription, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.subscription.seek_request_count`*:: ++ +-- +Cumulative count of seek attempts, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_mod_ack_deadline_message_operation_count`*:: ++ +-- +Cumulative count of StreamingPull ModifyAckDeadline operations, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.streaming_pull_mod_ack_deadline_request_count`*:: ++ +-- +Cumulative count of streaming pull requests with non-empty ModifyAckDeadline fields, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.byte_cost`*:: ++ +-- +Cumulative cost of operations, measured in bytes. This is used to measure quota utilization. + +type: long + +-- + +*`googlecloud.pubsub.subscription.config_updates_count`*:: ++ +-- +Cumulative count of configuration changes for each subscription, grouped by operation type and result. + +type: long + +-- + +*`googlecloud.pubsub.subscription.unacked_bytes_by_region`*:: ++ +-- +Total byte size of the unacknowledged messages in a subscription, broken down by Cloud region. + +type: long + +-- + +[float] +=== topic + +Topic related metrics + + +*`googlecloud.pubsub.topic.streaming_pull_response_count`*:: ++ +-- +Cumulative count of streaming pull responses, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.topic.send_message_operation_count`*:: ++ +-- +Cumulative count of publish message operations, grouped by result. For a definition of message operations, see Cloud Pub/Sub metric subscription/mod_ack_deadline_message_operation_count. + +type: long + +-- + +*`googlecloud.pubsub.topic.send_request_count`*:: ++ +-- +Cumulative count of publish requests, grouped by result. + +type: long + +-- + +*`googlecloud.pubsub.topic.oldest_retained_acked_message_age_by_region`*:: ++ +-- +Age (in seconds) of the oldest acknowledged message retained in a topic, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.topic.oldest_unacked_message_age_by_region`*:: ++ +-- +Age (in seconds) of the oldest unacknowledged message in a topic, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.topic.retained_acked_bytes_by_region`*:: ++ +-- +Total byte size of the acknowledged messages retained in a topic, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.topic.byte_cost`*:: ++ +-- +Cost of operations, measured in bytes. This is used to measure utilization for quotas. + +type: long + +-- + +*`googlecloud.pubsub.topic.config_updates_count`*:: ++ +-- +Cumulative count of configuration changes, grouped by operation type and result. + +type: long + +-- + +*`googlecloud.pubsub.topic.unacked_bytes_by_region`*:: ++ +-- +Total byte size of the unacknowledged messages in a topic, broken down by Cloud region. + +type: long + +-- + +[float] +=== snapshot + +Snapshot related metrics + + +*`googlecloud.pubsub.snapshot.oldest_message_age`*:: ++ +-- +Age (in seconds) of the oldest message retained in a snapshot. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.oldest_message_age_by_region`*:: ++ +-- +Age (in seconds) of the oldest message retained in a snapshot, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.backlog_bytes`*:: ++ +-- +Total byte size of the messages retained in a snapshot. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.backlog_bytes_by_region`*:: ++ +-- +Total byte size of the messages retained in a snapshot, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.num_messages`*:: ++ +-- +Number of messages retained in a snapshot. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.num_messages_by_region`*:: ++ +-- +Number of messages retained in a snapshot, broken down by Cloud region. + +type: long + +-- + +*`googlecloud.pubsub.snapshot.config_updates_count`*:: ++ +-- +Cumulative count of configuration changes, grouped by operation type and result. + +type: long + +-- + +[float] +=== storage + +Google Cloud Storage metrics + + + +*`googlecloud.storage.api.request_count`*:: ++ +-- +Delta count of API calls, grouped by the API method name and response code. + +type: long + +-- + + +*`googlecloud.storage.authz.acl_based_object_access_count`*:: ++ +-- +Delta count of requests that result in an object being granted access solely due to object ACLs. + +type: long + +-- + +*`googlecloud.storage.authz.acl_operations_count`*:: ++ +-- +Usage of ACL operations broken down by type. + +type: long + +-- + +*`googlecloud.storage.authz.object_specific_acl_mutation_count`*:: ++ +-- +Delta count of changes made to object specific ACLs. + +type: long + +-- + + +*`googlecloud.storage.network.received_bytes_count`*:: ++ +-- +Delta count of bytes received over the network, grouped by the API method name and response code. + +type: long + +-- + +*`googlecloud.storage.network.sent_bytes_count`*:: ++ +-- +Delta count of bytes sent over the network, grouped by the API method name and response code. + +type: long + +-- + + +*`googlecloud.storage.storage.object_count`*:: ++ +-- +Total number of objects per bucket, grouped by storage class. This value is measured once per day, and the value is repeated at each sampling interval throughout the day. + +type: long + +-- + +*`googlecloud.storage.storage.total_byte_seconds`*:: ++ +-- +Delta count of bytes received over the network, grouped by the API method name and response code. + +type: long + +-- + +*`googlecloud.storage.storage.total_bytes`*:: ++ +-- +Total size of all objects in the bucket, grouped by storage class. This value is measured once per day, and the value is repeated at each sampling interval throughout the day. + +type: long + +-- + [[exported-fields-graphite]] == Graphite fields diff --git a/x-pack/metricbeat/module/googlecloud/_meta/fields.yml b/x-pack/metricbeat/module/googlecloud/_meta/fields.yml index 8bbae3bf4fe..3801f6365d9 100644 --- a/x-pack/metricbeat/module/googlecloud/_meta/fields.yml +++ b/x-pack/metricbeat/module/googlecloud/_meta/fields.yml @@ -4,14 +4,23 @@ description: > GCP module fields: - - name: googlecloud.labels - type: object + - name: googlecloud + type: group fields: - - name: user.* - type: object - - name: metadata.* - type: object - - name: metrics.* - type: object - - name: system.* + - name: labels type: object + description: > + Google cloud monitoring metrics labels + fields: + - name: user.* + type: object + object_type: keyword + - name: metadata.* + type: object + object_type: keyword + - name: metrics.* + type: object + object_type: keyword + - name: system.* + type: object + object_type: keyword diff --git a/x-pack/metricbeat/module/googlecloud/fields.go b/x-pack/metricbeat/module/googlecloud/fields.go index 8fac4947787..8d2b126098f 100644 --- a/x-pack/metricbeat/module/googlecloud/fields.go +++ b/x-pack/metricbeat/module/googlecloud/fields.go @@ -19,5 +19,5 @@ func init() { // AssetGooglecloud returns asset data. // This is the base64 encoded gzipped contents of module/googlecloud. func AssetGooglecloud() string { - return "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" + return "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" }