diff --git a/server/src/main/java/org/elasticsearch/common/regex/Regex.java b/server/src/main/java/org/elasticsearch/common/regex/Regex.java index 8669480d27f51..b9987a721aa6b 100644 --- a/server/src/main/java/org/elasticsearch/common/regex/Regex.java +++ b/server/src/main/java/org/elasticsearch/common/regex/Regex.java @@ -8,12 +8,14 @@ package org.elasticsearch.common.regex; +import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.automaton.Automata; import org.apache.lucene.util.automaton.Automaton; import org.apache.lucene.util.automaton.Operations; import org.elasticsearch.common.Strings; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Locale; import java.util.regex.Pattern; @@ -57,9 +59,29 @@ public static Automaton simpleMatchToAutomaton(String... patterns) { if (patterns.length < 1) { throw new IllegalArgumentException("There must be at least one pattern, zero given"); } + + List simpleStrings = new ArrayList<>(); List automata = new ArrayList<>(); for (String pattern : patterns) { - automata.add(simpleMatchToAutomaton(pattern)); + // Strings longer than 1000 characters aren't supported by makeStringUnion + if (isSimpleMatchPattern(pattern) || pattern.length() >= 1000) { + automata.add(simpleMatchToAutomaton(pattern)); + } else { + simpleStrings.add(new BytesRef(pattern)); + } + } + if (false == simpleStrings.isEmpty()) { + Automaton simpleStringsAutomaton; + if (simpleStrings.size() > 0) { + Collections.sort(simpleStrings); + simpleStringsAutomaton = Automata.makeStringUnion(simpleStrings); + } else { + simpleStringsAutomaton = Automata.makeString(simpleStrings.get(0).utf8ToString()); + } + if (automata.isEmpty()) { + return simpleStringsAutomaton; + } + automata.add(simpleStringsAutomaton); } return Operations.union(automata); } diff --git a/server/src/main/java/org/elasticsearch/common/xcontent/support/XContentMapValues.java b/server/src/main/java/org/elasticsearch/common/xcontent/support/XContentMapValues.java index 6ae9aa323eec2..0fd7720b4da5d 100644 --- a/server/src/main/java/org/elasticsearch/common/xcontent/support/XContentMapValues.java +++ b/server/src/main/java/org/elasticsearch/common/xcontent/support/XContentMapValues.java @@ -20,7 +20,6 @@ import org.elasticsearch.common.unit.TimeValue; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -28,6 +27,17 @@ import java.util.function.Function; public class XContentMapValues { + /** + * Maximum number of states allowed in the two automata that we use to + * perform the map filtering. This about a megabyte or so worth of + * automata. That's about eight thousand long-ish source paths. That's + * heavy but it shouldn't knock over the node or + * anything. + *

+ * For what it is worth, 50,000 states is way, way, way too many to + * visualize. + */ + private static final int MAX_DETERMINIZED_STATES = 50_000; /** * Extracts raw values (string, int, and so on) based on the path provided returning all of them @@ -241,7 +251,7 @@ public static Map filter(Map map, String[] includes, } else { Automaton includeA = Regex.simpleMatchToAutomaton(includes); includeA = makeMatchDotsInFieldNames(includeA); - include = new CharacterRunAutomaton(includeA); + include = new CharacterRunAutomaton(includeA, MAX_DETERMINIZED_STATES); } Automaton excludeA; @@ -251,7 +261,7 @@ public static Map filter(Map map, String[] includes, excludeA = Regex.simpleMatchToAutomaton(excludes); excludeA = makeMatchDotsInFieldNames(excludeA); } - CharacterRunAutomaton exclude = new CharacterRunAutomaton(excludeA); + CharacterRunAutomaton exclude = new CharacterRunAutomaton(excludeA, MAX_DETERMINIZED_STATES); // NOTE: We cannot use Operations.minus because of the special case that // we want all sub properties to match as soon as an object matches @@ -266,9 +276,15 @@ public static Map filter(Map map, String[] includes, * For instance, if the original simple regex is `foo`, this will translate * it into `foo` OR `foo.*`. */ private static Automaton makeMatchDotsInFieldNames(Automaton automaton) { - return Operations.union( - automaton, - Operations.concatenate(Arrays.asList(automaton, Automata.makeChar('.'), Automata.makeAnyString()))); + /* + * We presume `automaton` is quite large compared to the mechanisms + * to match the trailing `.*` bits so we duplicate it only once. + */ + Automaton tail = Operations.union( + Automata.makeEmptyString(), + Operations.concatenate(Automata.makeChar('.'), Automata.makeAnyString()) + ); + return Operations.concatenate(automaton, tail); } private static int step(CharacterRunAutomaton automaton, String key, int state) { diff --git a/server/src/test/java/org/elasticsearch/common/regex/RegexTests.java b/server/src/test/java/org/elasticsearch/common/regex/RegexTests.java index a6f5129dbc8dc..04a0c5b10b0e5 100644 --- a/server/src/test/java/org/elasticsearch/common/regex/RegexTests.java +++ b/server/src/test/java/org/elasticsearch/common/regex/RegexTests.java @@ -7,8 +7,11 @@ */ package org.elasticsearch.common.regex; +import org.apache.lucene.util.automaton.Automaton; +import org.apache.lucene.util.automaton.CharacterRunAutomaton; import org.elasticsearch.test.ESTestCase; +import java.io.IOException; import java.util.Locale; import java.util.Random; import java.util.regex.Pattern; @@ -79,4 +82,95 @@ public void testSimpleMatch() { assertFalse("[" + pattern + "] should not match [" + matchingString + "]", Regex.simpleMatch(pattern, matchingString)); } } + + public void testSimpleMatchToAutomaton() { + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("ddd")).run("ddd")); + assertFalse(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("ddd")).run("Ddd")); + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("d*d*d")).run("dadd")); + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("**ddd")).run("dddd")); + assertFalse(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("**ddd")).run("fff")); + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("fff*ddd")).run("fffabcddd")); + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("fff**ddd")).run("fffabcddd")); + assertFalse(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("fff**ddd")).run("fffabcdd")); + assertTrue(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("fff*******ddd")).run("fffabcddd")); + assertFalse(new CharacterRunAutomaton(Regex.simpleMatchToAutomaton("fff******ddd")).run("fffabcdd")); + } + + public void testSimpleMatchManyToAutomaton() { + assertMatchesAll(Regex.simpleMatchToAutomaton("ddd", "fff"), "ddd", "fff"); + assertMatchesNone(Regex.simpleMatchToAutomaton("ddd", "fff"), "Ddd", "Fff"); + assertMatchesAll(Regex.simpleMatchToAutomaton("d*d*d", "cc"), "dadd", "cc"); + assertMatchesNone(Regex.simpleMatchToAutomaton("d*d*d", "cc"), "dadc", "Cc"); + } + + public void testThousands() throws IOException { + String[] patterns = new String[10000]; + for (int i = 0; i < patterns.length; i++) { + patterns[i] = Integer.toString(i, Character.MAX_RADIX); + } + Automaton automaton = Regex.simpleMatchToAutomaton(patterns); + CharacterRunAutomaton run = new CharacterRunAutomaton(automaton); + for (String pattern : patterns) { + assertTrue("matches " + pattern, run.run(pattern)); + } + for (int i = 0; i < 100000; i++) { + int idx = between(0, Integer.MAX_VALUE); + String pattern = Integer.toString(idx, Character.MAX_RADIX); + if (idx < patterns.length) { + assertTrue("matches " + pattern, run.run(pattern)); + } else { + assertFalse("matches " + pattern, run.run(pattern)); + } + } + } + + public void testThousandsAndPattern() throws IOException { + int patternCount = 10000; + String[] patterns = new String[patternCount + 2]; + for (int i = 0; i < patternCount; i++) { + patterns[i] = Integer.toString(i, Character.MAX_RADIX); + } + patterns[patternCount] = "foo*bar"; + patterns[patternCount + 1] = "baz*bort"; + Automaton automaton = Regex.simpleMatchToAutomaton(patterns); + CharacterRunAutomaton run = new CharacterRunAutomaton(automaton); + for (int i = 0; i < patternCount; i++) { + assertTrue("matches " + patterns[i], run.run(patterns[i])); + } + assertTrue("matches foobar", run.run("foobar")); + assertTrue("matches foostuffbar", run.run("foostuffbar")); + assertTrue("matches bazbort", run.run("bazbort")); + assertTrue("matches bazstuffbort", run.run("bazstuffbort")); + for (int i = 0; i < 100000; i++) { + int idx = between(0, Integer.MAX_VALUE); + String pattern = Integer.toString(idx, Character.MAX_RADIX); + if ((pattern.startsWith("foo") && pattern.endsWith("bar")) || (pattern.startsWith("baz") && pattern.endsWith("bort"))) { + fail(); + } + if (idx < patternCount + || (pattern.startsWith("foo") && pattern.endsWith("bar")) // 948437811 + || (pattern.startsWith("baz") && pattern.endsWith("bort")) // Can't match, but you get the idea + ) { + assertTrue("matches " + pattern, run.run(pattern)); + } else { + assertFalse("matches " + pattern, run.run(pattern)); + } + assertTrue("matches " + pattern, run.run("foo" + pattern + "bar")); + assertTrue("matches " + pattern, run.run("baz" + pattern + "bort")); + } + } + + private void assertMatchesAll(Automaton automaton, String... strings) { + CharacterRunAutomaton run = new CharacterRunAutomaton(automaton); + for (String s : strings) { + assertTrue(run.run(s)); + } + } + + private void assertMatchesNone(Automaton automaton, String... strings) { + CharacterRunAutomaton run = new CharacterRunAutomaton(automaton); + for (String s : strings) { + assertFalse(run.run(s)); + } + } } diff --git a/server/src/test/java/org/elasticsearch/common/xcontent/support/AbstractFilteringTestCase.java b/server/src/test/java/org/elasticsearch/common/xcontent/support/AbstractFilteringTestCase.java index 0c14214f384cd..5a640db6fc910 100644 --- a/server/src/test/java/org/elasticsearch/common/xcontent/support/AbstractFilteringTestCase.java +++ b/server/src/test/java/org/elasticsearch/common/xcontent/support/AbstractFilteringTestCase.java @@ -16,10 +16,15 @@ import org.elasticsearch.test.ESTestCase; import java.io.IOException; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import org.elasticsearch.common.io.PathUtils; import java.util.Set; import static java.util.Collections.emptySet; import static java.util.Collections.singleton; +import static java.util.stream.Collectors.toSet; /** * Tests for {@link XContent} filtering. @@ -1416,4 +1421,27 @@ public void testFilterPrefix() throws IOException { .endObject(); testFilter(expected, sample, singleton("photosCount"), emptySet()); } + + public void testManyFilters() throws IOException, URISyntaxException { + Builder deep = builder -> builder.startObject() + .startObject("system") + .startObject("process") + .startObject("cgroup") + .startObject("memory") + .startObject("stats") + .startObject("mapped_file") + .field("bytes", 100) + .endObject() + .endObject() + .endObject() + .endObject() + .endObject() + .endObject() + .endObject(); + Set manyFilters = Files.readAllLines( + PathUtils.get(AbstractFilteringTestCase.class.getResource("many_filters.txt").toURI()), + StandardCharsets.UTF_8 + ).stream().filter(s -> false == s.startsWith("#")).collect(toSet()); + testFilter(deep, deep, manyFilters, emptySet()); + } } diff --git a/server/src/test/resources/org/elasticsearch/common/xcontent/support/many_filters.txt b/server/src/test/resources/org/elasticsearch/common/xcontent/support/many_filters.txt new file mode 100644 index 0000000000000..61ad0f70e88a3 --- /dev/null +++ b/server/src/test/resources/org/elasticsearch/common/xcontent/support/many_filters.txt @@ -0,0 +1,3902 @@ +# These come from a request kibana once accidentally sent to ES. ES rejected the +# request because it was too large. It really is quite large, but we should be +# able to handle it. +@timestamp +_id +_index +_score +_source +_type +activemq.broker.connections.count +activemq.broker.consumers.count +activemq.broker.mbean +activemq.broker.memory.broker.pct +activemq.broker.memory.store.pct +activemq.broker.memory.temp.pct +activemq.broker.messages.count +activemq.broker.messages.dequeue.count +activemq.broker.messages.enqueue.count +activemq.broker.name +activemq.broker.producers.count +activemq.queue.consumers.count +activemq.queue.mbean +activemq.queue.memory.broker.pct +activemq.queue.messages.dequeue.count +activemq.queue.messages.dispatch.count +activemq.queue.messages.enqueue.count +activemq.queue.messages.enqueue.time.avg +activemq.queue.messages.enqueue.time.max +activemq.queue.messages.enqueue.time.min +activemq.queue.messages.expired.count +activemq.queue.messages.inflight.count +activemq.queue.messages.size.avg +activemq.queue.name +activemq.queue.producers.count +activemq.queue.size +activemq.topic.consumers.count +activemq.topic.mbean +activemq.topic.memory.broker.pct +activemq.topic.messages.dequeue.count +activemq.topic.messages.dispatch.count +activemq.topic.messages.enqueue.count +activemq.topic.messages.enqueue.time.avg +activemq.topic.messages.enqueue.time.max +activemq.topic.messages.enqueue.time.min +activemq.topic.messages.expired.count +activemq.topic.messages.inflight.count +activemq.topic.messages.size.avg +activemq.topic.name +activemq.topic.producers.count +aerospike.namespace.client.delete.error +aerospike.namespace.client.delete.not_found +aerospike.namespace.client.delete.success +aerospike.namespace.client.delete.timeout +aerospike.namespace.client.read.error +aerospike.namespace.client.read.not_found +aerospike.namespace.client.read.success +aerospike.namespace.client.read.timeout +aerospike.namespace.client.write.error +aerospike.namespace.client.write.success +aerospike.namespace.client.write.timeout +aerospike.namespace.device.available.pct +aerospike.namespace.device.free.pct +aerospike.namespace.device.total.bytes +aerospike.namespace.device.used.bytes +aerospike.namespace.hwm_breached +aerospike.namespace.memory.free.pct +aerospike.namespace.memory.used.data.bytes +aerospike.namespace.memory.used.index.bytes +aerospike.namespace.memory.used.sindex.bytes +aerospike.namespace.memory.used.total.bytes +aerospike.namespace.name +aerospike.namespace.node.host +aerospike.namespace.node.name +aerospike.namespace.objects.master +aerospike.namespace.objects.total +aerospike.namespace.stop_writes +agent.ephemeral_id +agent.hostname +agent.id +agent.name +agent.type +agent.version +apache.status.bytes_per_request +apache.status.bytes_per_sec +apache.status.connections.async.closing +apache.status.connections.async.keep_alive +apache.status.connections.async.writing +apache.status.connections.total +apache.status.cpu.children_system +apache.status.cpu.children_user +apache.status.cpu.load +apache.status.cpu.system +apache.status.cpu.user +apache.status.hostname +apache.status.load.1 +apache.status.load.15 +apache.status.load.5 +apache.status.requests_per_sec +apache.status.scoreboard.closing_connection +apache.status.scoreboard.dns_lookup +apache.status.scoreboard.gracefully_finishing +apache.status.scoreboard.idle_cleanup +apache.status.scoreboard.keepalive +apache.status.scoreboard.logging +apache.status.scoreboard.open_slot +apache.status.scoreboard.reading_request +apache.status.scoreboard.sending_reply +apache.status.scoreboard.starting_up +apache.status.scoreboard.total +apache.status.scoreboard.waiting_for_connection +apache.status.total_accesses +apache.status.total_kbytes +apache.status.uptime.server_uptime +apache.status.uptime.uptime +apache.status.workers.busy +apache.status.workers.idle +appsearch.stats.jvm.memory_usage.heap_committed.bytes +appsearch.stats.jvm.memory_usage.heap_init.bytes +appsearch.stats.jvm.memory_usage.heap_max.bytes +appsearch.stats.jvm.memory_usage.heap_used.bytes +appsearch.stats.jvm.memory_usage.non_heap_committed.bytes +appsearch.stats.jvm.memory_usage.non_heap_init.bytes +appsearch.stats.queues.analytics_events.count +appsearch.stats.queues.document_destroyer.count +appsearch.stats.queues.engine_destroyer.count +appsearch.stats.queues.failed.count +appsearch.stats.queues.index_adder.count +appsearch.stats.queues.indexed_doc_remover.count +appsearch.stats.queues.mailer.count +appsearch.stats.queues.refresh_document_counts.count +appsearch.stats.queues.reindexer.count +appsearch.stats.queues.schema_updater.count +appsearch.stats.requests.api.duration.avg.ms +appsearch.stats.requests.api.duration.max.ms +appsearch.stats.requests.count +appsearch.stats.requests.web.response_time.avg.ms +appsearch.stats.requests.web.response_time.max.ms +as.number +as.organization.name +as.organization.name.text +aws.applicationelb.metrics.ActiveConnectionCount.sum +aws.applicationelb.metrics.ClientTLSNegotiationErrorCount.sum +aws.applicationelb.metrics.ConsumedLCUs.avg +aws.applicationelb.metrics.HTTPCode_ELB_3XX_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_4XX_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_500_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_502_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_503_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_504_Count.sum +aws.applicationelb.metrics.HTTPCode_ELB_5XX_Count.sum +aws.applicationelb.metrics.HTTP_Fixed_Response_Count.sum +aws.applicationelb.metrics.HTTP_Redirect_Count.sum +aws.applicationelb.metrics.HTTP_Redirect_Url_Limit_Exceeded_Count.sum +aws.applicationelb.metrics.IPv6ProcessedBytes.sum +aws.applicationelb.metrics.IPv6RequestCount.sum +aws.applicationelb.metrics.NewConnectionCount.sum +aws.applicationelb.metrics.ProcessedBytes.sum +aws.applicationelb.metrics.RejectedConnectionCount.sum +aws.applicationelb.metrics.RequestCount.sum +aws.applicationelb.metrics.RuleEvaluations.sum +aws.billing.AmortizedCost.amount +aws.billing.AmortizedCost.unit +aws.billing.BlendedCost.amount +aws.billing.BlendedCost.unit +aws.billing.Currency +aws.billing.EstimatedCharges +aws.billing.NormalizedUsageAmount.amount +aws.billing.NormalizedUsageAmount.unit +aws.billing.ServiceName +aws.billing.UnblendedCost.amount +aws.billing.UnblendedCost.unit +aws.billing.UsageQuantity.amount +aws.billing.UsageQuantity.unit +aws.billing.end_date +aws.billing.group_definition.key +aws.billing.group_definition.type +aws.billing.start_date +aws.cloudwatch.namespace +aws.dynamodb.metrics.AccountMaxReads.max +aws.dynamodb.metrics.AccountMaxTableLevelReads.max +aws.dynamodb.metrics.AccountMaxTableLevelWrites.max +aws.dynamodb.metrics.AccountMaxWrites.max +aws.dynamodb.metrics.AccountProvisionedReadCapacityUtilization.avg +aws.dynamodb.metrics.AccountProvisionedWriteCapacityUtilization.avg +aws.dynamodb.metrics.ConditionalCheckFailedRequests.sum +aws.dynamodb.metrics.ConsumedReadCapacityUnits.avg +aws.dynamodb.metrics.ConsumedReadCapacityUnits.sum +aws.dynamodb.metrics.ConsumedWriteCapacityUnits.avg +aws.dynamodb.metrics.ConsumedWriteCapacityUnits.sum +aws.dynamodb.metrics.MaxProvisionedTableReadCapacityUtilization.max +aws.dynamodb.metrics.MaxProvisionedTableWriteCapacityUtilization.max +aws.dynamodb.metrics.OnlineIndexPercentageProgress.avg +aws.dynamodb.metrics.PendingReplicationCount.sum +aws.dynamodb.metrics.ProvisionedReadCapacityUnits.avg +aws.dynamodb.metrics.ProvisionedWriteCapacityUnits.avg +aws.dynamodb.metrics.ReadThrottleEvents.sum +aws.dynamodb.metrics.ReplicationLatency.avg +aws.dynamodb.metrics.ReplicationLatency.max +aws.dynamodb.metrics.SuccessfulRequestLatency.avg +aws.dynamodb.metrics.SuccessfulRequestLatency.max +aws.dynamodb.metrics.SystemErrors.sum +aws.dynamodb.metrics.ThrottledRequests.sum +aws.dynamodb.metrics.TransactionConflict.avg +aws.dynamodb.metrics.TransactionConflict.sum +aws.dynamodb.metrics.WriteThrottleEvents.sum +aws.ebs.metrics.BurstBalance.avg +aws.ebs.metrics.VolumeConsumedReadWriteOps.avg +aws.ebs.metrics.VolumeIdleTime.sum +aws.ebs.metrics.VolumeQueueLength.avg +aws.ebs.metrics.VolumeReadBytes.avg +aws.ebs.metrics.VolumeReadOps.avg +aws.ebs.metrics.VolumeThroughputPercentage.avg +aws.ebs.metrics.VolumeTotalReadTime.sum +aws.ebs.metrics.VolumeTotalWriteTime.sum +aws.ebs.metrics.VolumeWriteBytes.avg +aws.ebs.metrics.VolumeWriteOps.avg +aws.ec2.cpu.credit_balance +aws.ec2.cpu.credit_usage +aws.ec2.cpu.surplus_credit_balance +aws.ec2.cpu.surplus_credits_charged +aws.ec2.cpu.total.pct +aws.ec2.diskio.read.bytes +aws.ec2.diskio.read.bytes_per_sec +aws.ec2.diskio.read.count +aws.ec2.diskio.read.count_per_sec +aws.ec2.diskio.write.bytes +aws.ec2.diskio.write.bytes_per_sec +aws.ec2.diskio.write.count +aws.ec2.diskio.write.count_per_sec +aws.ec2.instance.core.count +aws.ec2.instance.image.id +aws.ec2.instance.monitoring.state +aws.ec2.instance.private.dns_name +aws.ec2.instance.private.ip +aws.ec2.instance.public.dns_name +aws.ec2.instance.public.ip +aws.ec2.instance.state.code +aws.ec2.instance.state.name +aws.ec2.instance.threads_per_core +aws.ec2.network.in.bytes +aws.ec2.network.in.bytes_per_sec +aws.ec2.network.in.packets +aws.ec2.network.in.packets_per_sec +aws.ec2.network.out.bytes +aws.ec2.network.out.bytes_per_sec +aws.ec2.network.out.packets +aws.ec2.network.out.packets_per_sec +aws.ec2.status.check_failed +aws.ec2.status.check_failed_instance +aws.ec2.status.check_failed_system +aws.elb.metrics.BackendConnectionErrors.sum +aws.elb.metrics.EstimatedALBActiveConnectionCount.avg +aws.elb.metrics.EstimatedALBConsumedLCUs.avg +aws.elb.metrics.EstimatedALBNewConnectionCount.avg +aws.elb.metrics.EstimatedProcessedBytes.avg +aws.elb.metrics.HTTPCode_Backend_2XX.sum +aws.elb.metrics.HTTPCode_Backend_3XX.sum +aws.elb.metrics.HTTPCode_Backend_4XX.sum +aws.elb.metrics.HTTPCode_Backend_5XX.sum +aws.elb.metrics.HTTPCode_ELB_4XX.sum +aws.elb.metrics.HTTPCode_ELB_5XX.sum +aws.elb.metrics.HealthyHostCount.max +aws.elb.metrics.Latency.avg +aws.elb.metrics.RequestCount.sum +aws.elb.metrics.SpilloverCount.sum +aws.elb.metrics.SurgeQueueLength.max +aws.elb.metrics.UnHealthyHostCount.max +aws.lambda.metrics.ConcurrentExecutions.avg +aws.lambda.metrics.DeadLetterErrors.avg +aws.lambda.metrics.DestinationDeliveryFailures.avg +aws.lambda.metrics.Duration.avg +aws.lambda.metrics.Errors.avg +aws.lambda.metrics.Invocations.avg +aws.lambda.metrics.IteratorAge.avg +aws.lambda.metrics.ProvisionedConcurrencyInvocations.sum +aws.lambda.metrics.ProvisionedConcurrencySpilloverInvocations.sum +aws.lambda.metrics.ProvisionedConcurrencyUtilization.max +aws.lambda.metrics.ProvisionedConcurrentExecutions.max +aws.lambda.metrics.Throttles.avg +aws.lambda.metrics.UnreservedConcurrentExecutions.avg +aws.natgateway.metrics.ActiveConnectionCount.max +aws.natgateway.metrics.BytesInFromDestination.sum +aws.natgateway.metrics.BytesInFromSource.sum +aws.natgateway.metrics.BytesOutToDestination.sum +aws.natgateway.metrics.BytesOutToSource.sum +aws.natgateway.metrics.ConnectionAttemptCount.sum +aws.natgateway.metrics.ConnectionEstablishedCount.sum +aws.natgateway.metrics.ErrorPortAllocation.sum +aws.natgateway.metrics.IdleTimeoutCount.sum +aws.natgateway.metrics.PacketsDropCount.sum +aws.natgateway.metrics.PacketsInFromDestination.sum +aws.natgateway.metrics.PacketsInFromSource.sum +aws.natgateway.metrics.PacketsOutToDestination.sum +aws.natgateway.metrics.PacketsOutToSource.sum +aws.networkelb.metrics.ActiveFlowCount.avg +aws.networkelb.metrics.ActiveFlowCount_TCP.avg +aws.networkelb.metrics.ActiveFlowCount_TLS.avg +aws.networkelb.metrics.ActiveFlowCount_UDP.avg +aws.networkelb.metrics.ClientTLSNegotiationErrorCount.sum +aws.networkelb.metrics.ConsumedLCUs.avg +aws.networkelb.metrics.HealthyHostCount.max +aws.networkelb.metrics.NewFlowCount.sum +aws.networkelb.metrics.NewFlowCount_TLS.sum +aws.networkelb.metrics.ProcessedBytes.sum +aws.networkelb.metrics.ProcessedBytes_TLS.sum +aws.networkelb.metrics.TCP_Client_Reset_Count.sum +aws.networkelb.metrics.TCP_ELB_Reset_Count.sum +aws.networkelb.metrics.TCP_Target_Reset_Count.sum +aws.networkelb.metrics.TargetTLSNegotiationErrorCount.sum +aws.networkelb.metrics.UnHealthyHostCount.max +aws.rds.aurora_bin_log_replica_lag +aws.rds.aurora_global_db.data_transfer.bytes +aws.rds.aurora_global_db.replicated_write_io.bytes +aws.rds.aurora_global_db.replication_lag.ms +aws.rds.aurora_replica.lag.ms +aws.rds.aurora_replica.lag_max.ms +aws.rds.aurora_replica.lag_min.ms +aws.rds.aurora_volume_left_total.bytes +aws.rds.backtrack_change_records.creation_rate +aws.rds.backtrack_change_records.stored +aws.rds.backtrack_window.actual +aws.rds.backtrack_window.alert +aws.rds.backup_storage_billed_total.bytes +aws.rds.cache_hit_ratio.buffer +aws.rds.cache_hit_ratio.result_set +aws.rds.cpu.credit_balance +aws.rds.cpu.credit_usage +aws.rds.cpu.total.pct +aws.rds.database_connections +aws.rds.db_instance.arn +aws.rds.db_instance.class +aws.rds.db_instance.db_cluster_identifier +aws.rds.db_instance.engine_name +aws.rds.db_instance.identifier +aws.rds.db_instance.role +aws.rds.db_instance.status +aws.rds.deadlocks +aws.rds.disk_queue_depth +aws.rds.disk_usage.bin_log.bytes +aws.rds.disk_usage.replication_slot.mb +aws.rds.disk_usage.transaction_logs.mb +aws.rds.engine_uptime.sec +aws.rds.failed_sql_server_agent_jobs +aws.rds.free_local_storage.bytes +aws.rds.free_storage.bytes +aws.rds.freeable_memory.bytes +aws.rds.latency.commit +aws.rds.latency.ddl +aws.rds.latency.delete +aws.rds.latency.dml +aws.rds.latency.insert +aws.rds.latency.read +aws.rds.latency.select +aws.rds.latency.update +aws.rds.latency.write +aws.rds.login_failures +aws.rds.maximum_used_transaction_ids +aws.rds.oldest_replication_slot_lag.mb +aws.rds.queries +aws.rds.rds_to_aurora_postgresql_replica_lag.sec +aws.rds.read_io.ops_per_sec +aws.rds.replica_lag.sec +aws.rds.storage_used.backup_retention_period.bytes +aws.rds.storage_used.snapshot.bytes +aws.rds.swap_usage.bytes +aws.rds.throughput.commit +aws.rds.throughput.ddl +aws.rds.throughput.delete +aws.rds.throughput.dml +aws.rds.throughput.insert +aws.rds.throughput.network +aws.rds.throughput.network_receive +aws.rds.throughput.network_transmit +aws.rds.throughput.read +aws.rds.throughput.select +aws.rds.throughput.update +aws.rds.throughput.write +aws.rds.transaction_logs_generation +aws.rds.transactions.active +aws.rds.transactions.blocked +aws.rds.volume.read.iops +aws.rds.volume.write.iops +aws.rds.volume_used.bytes +aws.rds.write_io.ops_per_sec +aws.s3.bucket.name +aws.s3_daily_storage.bucket.size.bytes +aws.s3_daily_storage.number_of_objects +aws.s3_request.downloaded.bytes +aws.s3_request.errors.4xx +aws.s3_request.errors.5xx +aws.s3_request.latency.first_byte.ms +aws.s3_request.latency.total_request.ms +aws.s3_request.requests.delete +aws.s3_request.requests.get +aws.s3_request.requests.head +aws.s3_request.requests.list +aws.s3_request.requests.post +aws.s3_request.requests.put +aws.s3_request.requests.select +aws.s3_request.requests.select_returned.bytes +aws.s3_request.requests.select_scanned.bytes +aws.s3_request.requests.total +aws.s3_request.uploaded.bytes +aws.sns.metrics.NumberOfMessagesPublished.sum +aws.sns.metrics.NumberOfNotificationsDelivered.sum +aws.sns.metrics.NumberOfNotificationsFailed.sum +aws.sns.metrics.NumberOfNotificationsFailedToRedriveToDlq.sum +aws.sns.metrics.NumberOfNotificationsFilteredOut-InvalidAttributes.sum +aws.sns.metrics.NumberOfNotificationsFilteredOut-NoMessageAttributes.sum +aws.sns.metrics.NumberOfNotificationsFilteredOut.sum +aws.sns.metrics.NumberOfNotificationsRedrivenToDlq.sum +aws.sns.metrics.PublishSize.avg +aws.sns.metrics.SMSMonthToDateSpentUSD.sum +aws.sns.metrics.SMSSuccessRate.avg +aws.sqs.empty_receives +aws.sqs.messages.delayed +aws.sqs.messages.deleted +aws.sqs.messages.not_visible +aws.sqs.messages.received +aws.sqs.messages.sent +aws.sqs.messages.visible +aws.sqs.oldest_message_age.sec +aws.sqs.queue.name +aws.sqs.sent_message_size.bytes +aws.transitgateway.metrics.BytesIn.sum +aws.transitgateway.metrics.BytesOut.sum +aws.transitgateway.metrics.PacketDropCountBlackhole.sum +aws.transitgateway.metrics.PacketDropCountNoRoute.sum +aws.transitgateway.metrics.PacketsIn.sum +aws.transitgateway.metrics.PacketsOut.sum +aws.usage.metrics.CallCount.sum +aws.usage.metrics.ResourceCount.sum +aws.vpn.metrics.TunnelDataIn.sum +aws.vpn.metrics.TunnelDataOut.sum +aws.vpn.metrics.TunnelState.avg +azure.app_insights.end_date +azure.app_insights.start_date +azure.app_state.browser_timings_network_duration.avg +azure.app_state.browser_timings_processing_duration.avg +azure.app_state.browser_timings_receive_uration.avg +azure.app_state.browser_timings_send_duration.avg +azure.app_state.browser_timings_total_duration.avg +azure.app_state.end_date +azure.app_state.exceptions_browser.sum +azure.app_state.exceptions_count.sum +azure.app_state.exceptions_server.sum +azure.app_state.performance_counters_memory_available_bytes.avg +azure.app_state.performance_counters_process_cpu_percentage.avg +azure.app_state.performance_counters_process_cpu_percentage_total.avg +azure.app_state.performance_counters_process_private_bytes.avg +azure.app_state.performance_counters_processiobytes_per_second.avg +azure.app_state.requests_count.sum +azure.app_state.requests_failed.sum +azure.app_state.sessions_count.unique +azure.app_state.start_date +azure.app_state.users_authenticated.unique +azure.app_state.users_count.unique +azure.application_id +azure.billing.account_name +azure.billing.actual_cost +azure.billing.billing_period_id +azure.billing.currency +azure.billing.department_name +azure.billing.forecast_cost +azure.billing.pretax_cost +azure.billing.product +azure.billing.usage_date +azure.billing.usage_end +azure.billing.usage_start +azure.namespace +azure.resource.group +azure.resource.type +azure.subscription_id +azure.timegrain +beat.id +beat.state.management.enabled +beat.state.module.count +beat.state.output.name +beat.state.queue.name +beat.stats.libbeat.output.events.acked +beat.stats.libbeat.output.events.active +beat.stats.libbeat.output.events.batches +beat.stats.libbeat.output.events.dropped +beat.stats.libbeat.output.events.duplicates +beat.stats.libbeat.output.events.failed +beat.stats.libbeat.output.events.toomany +beat.stats.libbeat.output.events.total +beat.stats.libbeat.output.read.bytes +beat.stats.libbeat.output.read.errors +beat.stats.libbeat.output.type +beat.stats.libbeat.output.write.bytes +beat.stats.libbeat.output.write.errors +beat.stats.runtime.goroutines +beat.stats.uptime.ms +beat.type +ceph.cluster_disk.available.bytes +ceph.cluster_disk.total.bytes +ceph.cluster_disk.used.bytes +ceph.cluster_health.overall_status +ceph.cluster_health.timechecks.epoch +ceph.cluster_health.timechecks.round.status +ceph.cluster_health.timechecks.round.value +ceph.cluster_status.degraded.objects +ceph.cluster_status.degraded.ratio +ceph.cluster_status.degraded.total +ceph.cluster_status.misplace.objects +ceph.cluster_status.misplace.ratio +ceph.cluster_status.misplace.total +ceph.cluster_status.osd.epoch +ceph.cluster_status.osd.full +ceph.cluster_status.osd.nearfull +ceph.cluster_status.osd.num_in_osds +ceph.cluster_status.osd.num_osds +ceph.cluster_status.osd.num_remapped_pgs +ceph.cluster_status.osd.num_up_osds +ceph.cluster_status.pg.avail_bytes +ceph.cluster_status.pg.data_bytes +ceph.cluster_status.pg.total_bytes +ceph.cluster_status.pg.used_bytes +ceph.cluster_status.pg_state.count +ceph.cluster_status.pg_state.state_name +ceph.cluster_status.pg_state.version +ceph.cluster_status.traffic.read_bytes +ceph.cluster_status.traffic.read_op_per_sec +ceph.cluster_status.traffic.write_bytes +ceph.cluster_status.traffic.write_op_per_sec +ceph.cluster_status.version +ceph.mgr_osd_perf.id +ceph.mgr_osd_perf.stats.apply_latency_ms +ceph.mgr_osd_perf.stats.apply_latency_ns +ceph.mgr_osd_perf.stats.commit_latency_ms +ceph.mgr_osd_perf.stats.commit_latency_ns +ceph.mgr_osd_pool_stats.pool_id +ceph.mgr_osd_pool_stats.pool_name +ceph.monitor_health.available.kb +ceph.monitor_health.available.pct +ceph.monitor_health.health +ceph.monitor_health.last_updated +ceph.monitor_health.name +ceph.monitor_health.store_stats.last_updated +ceph.monitor_health.store_stats.log.bytes +ceph.monitor_health.store_stats.misc.bytes +ceph.monitor_health.store_stats.sst.bytes +ceph.monitor_health.store_stats.total.bytes +ceph.monitor_health.total.kb +ceph.monitor_health.used.kb +ceph.osd_df.available.bytes +ceph.osd_df.device_class +ceph.osd_df.id +ceph.osd_df.name +ceph.osd_df.pg_num +ceph.osd_df.total.byte +ceph.osd_df.used.byte +ceph.osd_df.used.pct +ceph.osd_tree.children +ceph.osd_tree.crush_weight +ceph.osd_tree.depth +ceph.osd_tree.device_class +ceph.osd_tree.exists +ceph.osd_tree.father +ceph.osd_tree.id +ceph.osd_tree.name +ceph.osd_tree.primary_affinity +ceph.osd_tree.reweight +ceph.osd_tree.status +ceph.osd_tree.type +ceph.osd_tree.type_id +ceph.pool_disk.id +ceph.pool_disk.name +ceph.pool_disk.stats.available.bytes +ceph.pool_disk.stats.objects +ceph.pool_disk.stats.used.bytes +ceph.pool_disk.stats.used.kb +client.address +client.as.number +client.as.organization.name +client.as.organization.name.text +client.bytes +client.domain +client.geo.city_name +client.geo.continent_name +client.geo.country_iso_code +client.geo.country_name +client.geo.location +client.geo.name +client.geo.region_iso_code +client.geo.region_name +client.ip +client.mac +client.nat.ip +client.nat.port +client.packets +client.port +client.registered_domain +client.top_level_domain +client.user.domain +client.user.email +client.user.full_name +client.user.full_name.text +client.user.group.domain +client.user.group.id +client.user.group.name +client.user.hash +client.user.id +client.user.name +client.user.name.text +cloud.account.id +cloud.availability_zone +cloud.image.id +cloud.instance.id +cloud.instance.name +cloud.machine.type +cloud.project.id +cloud.provider +cloud.region +cloudfoundry.app.id +cloudfoundry.container.cpu.pct +cloudfoundry.container.disk.bytes +cloudfoundry.container.disk.quota.bytes +cloudfoundry.container.instance_index +cloudfoundry.container.memory.bytes +cloudfoundry.container.memory.quota.bytes +cloudfoundry.counter.delta +cloudfoundry.counter.name +cloudfoundry.counter.total +cloudfoundry.type +cloudfoundry.value.name +cloudfoundry.value.unit +cloudfoundry.value.value +code_signature.exists +code_signature.status +code_signature.subject_name +code_signature.trusted +code_signature.valid +consul.agent.autopilot.healthy +consul.agent.runtime.alloc.bytes +consul.agent.runtime.garbage_collector.pause.current.ns +consul.agent.runtime.garbage_collector.pause.total.ns +consul.agent.runtime.garbage_collector.runs +consul.agent.runtime.goroutines +consul.agent.runtime.heap_objects +consul.agent.runtime.malloc_count +consul.agent.runtime.sys.bytes +container.id +container.image.name +container.image.tag +container.name +container.runtime +coredns.stats.dns.cache.hits.count +coredns.stats.dns.cache.misses.count +coredns.stats.dns.request.count +coredns.stats.dns.request.do.count +coredns.stats.dns.request.duration.ns.count +coredns.stats.dns.request.duration.ns.sum +coredns.stats.dns.request.size.bytes.count +coredns.stats.dns.request.size.bytes.sum +coredns.stats.dns.request.type.count +coredns.stats.dns.response.rcode.count +coredns.stats.dns.response.size.bytes.count +coredns.stats.dns.response.size.bytes.sum +coredns.stats.family +coredns.stats.panic.count +coredns.stats.proto +coredns.stats.rcode +coredns.stats.server +coredns.stats.type +coredns.stats.zone +couchbase.bucket.data.used.bytes +couchbase.bucket.disk.fetches +couchbase.bucket.disk.used.bytes +couchbase.bucket.item_count +couchbase.bucket.memory.used.bytes +couchbase.bucket.name +couchbase.bucket.ops_per_sec +couchbase.bucket.quota.ram.bytes +couchbase.bucket.quota.use.pct +couchbase.bucket.type +couchbase.cluster.hdd.free.bytes +couchbase.cluster.hdd.quota.total.bytes +couchbase.cluster.hdd.total.bytes +couchbase.cluster.hdd.used.by_data.bytes +couchbase.cluster.hdd.used.value.bytes +couchbase.cluster.max_bucket_count +couchbase.cluster.quota.index_memory.mb +couchbase.cluster.quota.memory.mb +couchbase.cluster.ram.quota.total.per_node.bytes +couchbase.cluster.ram.quota.total.value.bytes +couchbase.cluster.ram.quota.used.per_node.bytes +couchbase.cluster.ram.quota.used.value.bytes +couchbase.cluster.ram.total.bytes +couchbase.cluster.ram.used.by_data.bytes +couchbase.cluster.ram.used.value.bytes +couchbase.node.cmd_get +couchbase.node.couch.docs.data_size.bytes +couchbase.node.couch.docs.disk_size.bytes +couchbase.node.couch.spatial.data_size.bytes +couchbase.node.couch.spatial.disk_size.bytes +couchbase.node.couch.views.data_size.bytes +couchbase.node.couch.views.disk_size.bytes +couchbase.node.cpu_utilization_rate.pct +couchbase.node.current_items.total +couchbase.node.current_items.value +couchbase.node.ep_bg_fetched +couchbase.node.get_hits +couchbase.node.hostname +couchbase.node.mcd_memory.allocated.bytes +couchbase.node.mcd_memory.reserved.bytes +couchbase.node.memory.free.bytes +couchbase.node.memory.total.bytes +couchbase.node.memory.used.bytes +couchbase.node.ops +couchbase.node.swap.total.bytes +couchbase.node.swap.used.bytes +couchbase.node.uptime.sec +couchbase.node.vb_replica_curr_items +couchdb.server.couchdb.auth_cache_hits +couchdb.server.couchdb.auth_cache_misses +couchdb.server.couchdb.database_reads +couchdb.server.couchdb.database_writes +couchdb.server.couchdb.open_databases +couchdb.server.couchdb.open_os_files +couchdb.server.couchdb.request_time +couchdb.server.httpd.bulk_requests +couchdb.server.httpd.clients_requesting_changes +couchdb.server.httpd.requests +couchdb.server.httpd.temporary_view_reads +couchdb.server.httpd.view_reads +couchdb.server.httpd_request_methods.COPY +couchdb.server.httpd_request_methods.DELETE +couchdb.server.httpd_request_methods.GET +couchdb.server.httpd_request_methods.HEAD +couchdb.server.httpd_request_methods.POST +couchdb.server.httpd_request_methods.PUT +couchdb.server.httpd_status_codes.200 +couchdb.server.httpd_status_codes.201 +couchdb.server.httpd_status_codes.202 +couchdb.server.httpd_status_codes.301 +couchdb.server.httpd_status_codes.304 +couchdb.server.httpd_status_codes.400 +couchdb.server.httpd_status_codes.401 +couchdb.server.httpd_status_codes.403 +couchdb.server.httpd_status_codes.404 +couchdb.server.httpd_status_codes.405 +couchdb.server.httpd_status_codes.409 +couchdb.server.httpd_status_codes.412 +couchdb.server.httpd_status_codes.500 +destination.address +destination.as.number +destination.as.organization.name +destination.as.organization.name.text +destination.bytes +destination.domain +destination.geo.city_name +destination.geo.continent_name +destination.geo.country_iso_code +destination.geo.country_name +destination.geo.location +destination.geo.name +destination.geo.region_iso_code +destination.geo.region_name +destination.ip +destination.mac +destination.nat.ip +destination.nat.port +destination.packets +destination.port +destination.registered_domain +destination.top_level_domain +destination.user.domain +destination.user.email +destination.user.full_name +destination.user.full_name.text +destination.user.group.domain +destination.user.group.id +destination.user.group.name +destination.user.hash +destination.user.id +destination.user.name +destination.user.name.text +dll.code_signature.exists +dll.code_signature.status +dll.code_signature.subject_name +dll.code_signature.trusted +dll.code_signature.valid +dll.hash.md5 +dll.hash.sha1 +dll.hash.sha256 +dll.hash.sha512 +dll.name +dll.path +dll.pe.company +dll.pe.description +dll.pe.file_version +dll.pe.original_file_name +dll.pe.product +dns.answers.class +dns.answers.data +dns.answers.name +dns.answers.ttl +dns.answers.type +dns.header_flags +dns.id +dns.op_code +dns.question.class +dns.question.name +dns.question.registered_domain +dns.question.subdomain +dns.question.top_level_domain +dns.question.type +dns.resolved_ip +dns.response_code +dns.type +docker.container.command +docker.container.created +docker.container.ip_addresses +docker.container.size.root_fs +docker.container.size.rw +docker.container.status +docker.container.tags +docker.cpu.kernel.norm.pct +docker.cpu.kernel.pct +docker.cpu.kernel.ticks +docker.cpu.system.norm.pct +docker.cpu.system.pct +docker.cpu.system.ticks +docker.cpu.total.norm.pct +docker.cpu.total.pct +docker.cpu.user.norm.pct +docker.cpu.user.pct +docker.cpu.user.ticks +docker.diskio.read.bytes +docker.diskio.read.ops +docker.diskio.read.queued +docker.diskio.read.rate +docker.diskio.read.service_time +docker.diskio.read.wait_time +docker.diskio.reads +docker.diskio.summary.bytes +docker.diskio.summary.ops +docker.diskio.summary.queued +docker.diskio.summary.rate +docker.diskio.summary.service_time +docker.diskio.summary.wait_time +docker.diskio.total +docker.diskio.write.bytes +docker.diskio.write.ops +docker.diskio.write.queued +docker.diskio.write.rate +docker.diskio.write.service_time +docker.diskio.write.wait_time +docker.diskio.writes +docker.event.action +docker.event.actor.id +docker.event.from +docker.event.id +docker.event.status +docker.event.type +docker.healthcheck.event.end_date +docker.healthcheck.event.exit_code +docker.healthcheck.event.output +docker.healthcheck.event.start_date +docker.healthcheck.failingstreak +docker.healthcheck.status +docker.image.created +docker.image.id.current +docker.image.id.parent +docker.image.size.regular +docker.image.size.virtual +docker.image.tags +docker.info.containers.paused +docker.info.containers.running +docker.info.containers.stopped +docker.info.containers.total +docker.info.id +docker.info.images +docker.memory.commit.peak +docker.memory.commit.total +docker.memory.fail.count +docker.memory.limit +docker.memory.private_working_set.total +docker.memory.rss.pct +docker.memory.rss.total +docker.memory.usage.max +docker.memory.usage.pct +docker.memory.usage.total +docker.network.in.bytes +docker.network.in.dropped +docker.network.in.errors +docker.network.in.packets +docker.network.inbound.bytes +docker.network.inbound.dropped +docker.network.inbound.errors +docker.network.inbound.packets +docker.network.interface +docker.network.out.bytes +docker.network.out.dropped +docker.network.out.errors +docker.network.out.packets +docker.network.outbound.bytes +docker.network.outbound.dropped +docker.network.outbound.errors +docker.network.outbound.packets +ecs.version +elasticsearch.ccr.follower.global_checkpoint +elasticsearch.ccr.follower.index +elasticsearch.ccr.follower.operations_written +elasticsearch.ccr.follower.shard.number +elasticsearch.ccr.follower.time_since_last_read.ms +elasticsearch.ccr.leader.index +elasticsearch.ccr.leader.max_seq_no +elasticsearch.cluster.id +elasticsearch.cluster.name +elasticsearch.cluster.pending_task.insert_order +elasticsearch.cluster.pending_task.priority +elasticsearch.cluster.pending_task.source +elasticsearch.cluster.pending_task.time_in_queue.ms +elasticsearch.cluster.state.id +elasticsearch.cluster.stats.indices.count +elasticsearch.cluster.stats.indices.fielddata.memory.bytes +elasticsearch.cluster.stats.indices.shards.count +elasticsearch.cluster.stats.indices.shards.primaries +elasticsearch.cluster.stats.nodes.count +elasticsearch.cluster.stats.nodes.data +elasticsearch.cluster.stats.nodes.master +elasticsearch.cluster.stats.status +elasticsearch.enrich.executed_searches.total +elasticsearch.enrich.queue.size +elasticsearch.enrich.remote_requests.current +elasticsearch.enrich.remote_requests.total +elasticsearch.index.name +elasticsearch.index.recovery.id +elasticsearch.index.recovery.primary +elasticsearch.index.recovery.source.host +elasticsearch.index.recovery.source.id +elasticsearch.index.recovery.source.name +elasticsearch.index.recovery.stage +elasticsearch.index.recovery.target.host +elasticsearch.index.recovery.target.id +elasticsearch.index.recovery.target.name +elasticsearch.index.recovery.type +elasticsearch.index.summary.primaries.docs.count +elasticsearch.index.summary.primaries.docs.deleted +elasticsearch.index.summary.primaries.segments.count +elasticsearch.index.summary.primaries.segments.memory.bytes +elasticsearch.index.summary.primaries.store.size.bytes +elasticsearch.index.summary.total.docs.count +elasticsearch.index.summary.total.docs.deleted +elasticsearch.index.summary.total.segments.count +elasticsearch.index.summary.total.segments.memory.bytes +elasticsearch.index.summary.total.store.size.bytes +elasticsearch.index.total.docs.count +elasticsearch.index.total.docs.deleted +elasticsearch.index.total.segments.count +elasticsearch.index.total.segments.memory.bytes +elasticsearch.index.total.store.size.bytes +elasticsearch.ml.job.data_counts.invalid_date_count +elasticsearch.ml.job.data_counts.processed_record_count +elasticsearch.ml.job.id +elasticsearch.ml.job.state +elasticsearch.node.id +elasticsearch.node.jvm.memory.heap.init.bytes +elasticsearch.node.jvm.memory.heap.max.bytes +elasticsearch.node.jvm.memory.nonheap.init.bytes +elasticsearch.node.jvm.memory.nonheap.max.bytes +elasticsearch.node.jvm.version +elasticsearch.node.name +elasticsearch.node.process.mlockall +elasticsearch.node.stats.fs.summary.available.bytes +elasticsearch.node.stats.fs.summary.free.bytes +elasticsearch.node.stats.fs.summary.total.bytes +elasticsearch.node.stats.indices.docs.count +elasticsearch.node.stats.indices.docs.deleted +elasticsearch.node.stats.indices.segments.count +elasticsearch.node.stats.indices.segments.memory.bytes +elasticsearch.node.stats.indices.store.size.bytes +elasticsearch.node.stats.jvm.gc.collectors.old.collection.count +elasticsearch.node.stats.jvm.gc.collectors.old.collection.ms +elasticsearch.node.stats.jvm.gc.collectors.young.collection.count +elasticsearch.node.stats.jvm.gc.collectors.young.collection.ms +elasticsearch.node.stats.jvm.mem.pools.old.max.bytes +elasticsearch.node.stats.jvm.mem.pools.old.peak.bytes +elasticsearch.node.stats.jvm.mem.pools.old.peak_max.bytes +elasticsearch.node.stats.jvm.mem.pools.old.used.bytes +elasticsearch.node.stats.jvm.mem.pools.survivor.max.bytes +elasticsearch.node.stats.jvm.mem.pools.survivor.peak.bytes +elasticsearch.node.stats.jvm.mem.pools.survivor.peak_max.bytes +elasticsearch.node.stats.jvm.mem.pools.survivor.used.bytes +elasticsearch.node.stats.jvm.mem.pools.young.max.bytes +elasticsearch.node.stats.jvm.mem.pools.young.peak.bytes +elasticsearch.node.stats.jvm.mem.pools.young.peak_max.bytes +elasticsearch.node.stats.jvm.mem.pools.young.used.bytes +elasticsearch.node.version +elasticsearch.shard.number +elasticsearch.shard.primary +elasticsearch.shard.relocating_node.name +elasticsearch.shard.state +envoyproxy.server.cluster_manager.active_clusters +envoyproxy.server.cluster_manager.cluster_added +envoyproxy.server.cluster_manager.cluster_modified +envoyproxy.server.cluster_manager.cluster_removed +envoyproxy.server.cluster_manager.cluster_updated +envoyproxy.server.cluster_manager.cluster_updated_via_merge +envoyproxy.server.cluster_manager.update_merge_cancelled +envoyproxy.server.cluster_manager.update_out_of_merge_window +envoyproxy.server.cluster_manager.warming_clusters +envoyproxy.server.filesystem.flushed_by_timer +envoyproxy.server.filesystem.reopen_failed +envoyproxy.server.filesystem.write_buffered +envoyproxy.server.filesystem.write_completed +envoyproxy.server.filesystem.write_failed +envoyproxy.server.filesystem.write_total_buffered +envoyproxy.server.http2.header_overflow +envoyproxy.server.http2.headers_cb_no_stream +envoyproxy.server.http2.rx_messaging_error +envoyproxy.server.http2.rx_reset +envoyproxy.server.http2.too_many_header_frames +envoyproxy.server.http2.trailers +envoyproxy.server.http2.tx_reset +envoyproxy.server.listener_manager.listener_added +envoyproxy.server.listener_manager.listener_create_failure +envoyproxy.server.listener_manager.listener_create_success +envoyproxy.server.listener_manager.listener_modified +envoyproxy.server.listener_manager.listener_removed +envoyproxy.server.listener_manager.listener_stopped +envoyproxy.server.listener_manager.total_listeners_active +envoyproxy.server.listener_manager.total_listeners_draining +envoyproxy.server.listener_manager.total_listeners_warming +envoyproxy.server.runtime.admin_overrides_active +envoyproxy.server.runtime.deprecated_feature_use +envoyproxy.server.runtime.load_error +envoyproxy.server.runtime.load_success +envoyproxy.server.runtime.num_keys +envoyproxy.server.runtime.num_layers +envoyproxy.server.runtime.override_dir_exists +envoyproxy.server.runtime.override_dir_not_exists +envoyproxy.server.server.concurrency +envoyproxy.server.server.days_until_first_cert_expiring +envoyproxy.server.server.debug_assertion_failures +envoyproxy.server.server.dynamic_unknown_fields +envoyproxy.server.server.hot_restart_epoch +envoyproxy.server.server.live +envoyproxy.server.server.memory_allocated +envoyproxy.server.server.memory_heap_size +envoyproxy.server.server.parent_connections +envoyproxy.server.server.state +envoyproxy.server.server.static_unknown_fields +envoyproxy.server.server.stats_recent_lookups +envoyproxy.server.server.total_connections +envoyproxy.server.server.uptime +envoyproxy.server.server.version +envoyproxy.server.server.watchdog_mega_miss +envoyproxy.server.server.watchdog_miss +envoyproxy.server.stats.overflow +error.code +error.id +error.message +error.stack_trace +error.stack_trace.text +error.type +etcd.api_version +etcd.disk.backend_commit_duration.ns.count +etcd.disk.backend_commit_duration.ns.sum +etcd.disk.mvcc_db_total_size.bytes +etcd.disk.wal_fsync_duration.ns.count +etcd.disk.wal_fsync_duration.ns.sum +etcd.leader.followers.counts.followers.counts.fail +etcd.leader.followers.counts.followers.counts.success +etcd.leader.followers.latency.follower.latency.standardDeviation +etcd.leader.followers.latency.followers.latency.average +etcd.leader.followers.latency.followers.latency.current +etcd.leader.followers.latency.followers.latency.maximum +etcd.leader.followers.latency.followers.latency.minimum +etcd.leader.leader +etcd.memory.go_memstats_alloc.bytes +etcd.network.client_grpc_received.bytes +etcd.network.client_grpc_sent.bytes +etcd.self.id +etcd.self.leaderinfo.leader +etcd.self.leaderinfo.starttime +etcd.self.leaderinfo.uptime +etcd.self.name +etcd.self.recv.appendrequest.count +etcd.self.recv.bandwidthrate +etcd.self.recv.pkgrate +etcd.self.send.appendrequest.count +etcd.self.send.bandwidthrate +etcd.self.send.pkgrate +etcd.self.starttime +etcd.self.state +etcd.server.grpc_handled.count +etcd.server.grpc_started.count +etcd.server.has_leader +etcd.server.leader_changes.count +etcd.server.proposals_committed.count +etcd.server.proposals_failed.count +etcd.server.proposals_pending.count +etcd.store.compareanddelete.fail +etcd.store.compareanddelete.success +etcd.store.compareandswap.fail +etcd.store.compareandswap.success +etcd.store.create.fail +etcd.store.create.success +etcd.store.delete.fail +etcd.store.delete.success +etcd.store.expire.count +etcd.store.gets.fail +etcd.store.gets.success +etcd.store.sets.fail +etcd.store.sets.success +etcd.store.update.fail +etcd.store.update.success +etcd.store.watchers +event.action +event.category +event.code +event.created +event.dataset +event.duration +event.end +event.hash +event.id +event.ingested +event.kind +event.module +event.original +event.outcome +event.provider +event.reference +event.risk_score +event.risk_score_norm +event.sequence +event.severity +event.start +event.timezone +event.type +event.url +file.accessed +file.attributes +file.code_signature.exists +file.code_signature.status +file.code_signature.subject_name +file.code_signature.trusted +file.code_signature.valid +file.created +file.ctime +file.device +file.directory +file.drive_letter +file.extension +file.gid +file.group +file.hash.md5 +file.hash.sha1 +file.hash.sha256 +file.hash.sha512 +file.inode +file.mime_type +file.mode +file.mtime +file.name +file.owner +file.path +file.path.text +file.pe.company +file.pe.description +file.pe.file_version +file.pe.original_file_name +file.pe.product +file.size +file.target_path +file.target_path.text +file.type +file.uid +gcp.billing.cost_type +gcp.billing.invoice_month +gcp.billing.project_id +gcp.billing.total +gcp.compute.instance.cpu.reserved_cores.value +gcp.compute.instance.cpu.usage_time.value +gcp.compute.instance.cpu.utilization.value +gcp.compute.instance.disk.read_bytes_count.value +gcp.compute.instance.disk.read_ops_count.value +gcp.compute.instance.disk.write_bytes_count.value +gcp.compute.instance.disk.write_ops_count.value +gcp.compute.instance.firewall.dropped_bytes_count.value +gcp.compute.instance.firewall.dropped_packets_count.value +gcp.compute.instance.memory.balloon.ram_size.value +gcp.compute.instance.memory.balloon.ram_used.value +gcp.compute.instance.memory.balloon.swap_in_bytes_count.value +gcp.compute.instance.memory.balloon.swap_out_bytes_count.value +gcp.compute.instance.network.received_bytes_count.value +gcp.compute.instance.network.received_packets_count.value +gcp.compute.instance.network.sent_bytes_count.value +gcp.compute.instance.network.sent_packets_count.value +gcp.compute.instance.uptime.value +gcp.loadbalancing.https.backend_request_bytes_count.value +gcp.loadbalancing.https.backend_request_count.value +gcp.loadbalancing.https.request_bytes_count.value +gcp.loadbalancing.https.request_count.value +gcp.loadbalancing.https.response_bytes_count.value +gcp.loadbalancing.l3.internal.egress_bytes_count.value +gcp.loadbalancing.l3.internal.egress_packets_count.value +gcp.loadbalancing.l3.internal.ingress_bytes_count.value +gcp.loadbalancing.l3.internal.ingress_packets_count.value +gcp.loadbalancing.tcp_ssl_proxy.closed_connections.value +gcp.loadbalancing.tcp_ssl_proxy.egress_bytes_count.value +gcp.loadbalancing.tcp_ssl_proxy.ingress_bytes_count.value +gcp.loadbalancing.tcp_ssl_proxy.new_connections.value +gcp.loadbalancing.tcp_ssl_proxy.open_connections.value +gcp.pubsub.snapshot.backlog_bytes.value +gcp.pubsub.snapshot.backlog_bytes_by_region.value +gcp.pubsub.snapshot.config_updates_count.value +gcp.pubsub.snapshot.num_messages.value +gcp.pubsub.snapshot.num_messages_by_region.value +gcp.pubsub.snapshot.oldest_message_age.value +gcp.pubsub.snapshot.oldest_message_age_by_region.value +gcp.pubsub.subscription.ack_message_count.value +gcp.pubsub.subscription.backlog_bytes.value +gcp.pubsub.subscription.byte_cost.value +gcp.pubsub.subscription.config_updates_count.value +gcp.pubsub.subscription.dead_letter_message_count.value +gcp.pubsub.subscription.mod_ack_deadline_message_count.value +gcp.pubsub.subscription.mod_ack_deadline_message_operation_count.value +gcp.pubsub.subscription.mod_ack_deadline_request_count.value +gcp.pubsub.subscription.num_outstanding_messages.value +gcp.pubsub.subscription.num_undelivered_messages.value +gcp.pubsub.subscription.oldest_retained_acked_message_age.value +gcp.pubsub.subscription.oldest_retained_acked_message_age_by_region.value +gcp.pubsub.subscription.oldest_unacked_message_age.value +gcp.pubsub.subscription.oldest_unacked_message_age_by_region.value +gcp.pubsub.subscription.pull_ack_message_operation_count.value +gcp.pubsub.subscription.pull_ack_request_count.value +gcp.pubsub.subscription.pull_message_operation_count.value +gcp.pubsub.subscription.pull_request_count.value +gcp.pubsub.subscription.push_request_count.value +gcp.pubsub.subscription.push_request_latencies.value +gcp.pubsub.subscription.retained_acked_bytes.value +gcp.pubsub.subscription.retained_acked_bytes_by_region.value +gcp.pubsub.subscription.seek_request_count.value +gcp.pubsub.subscription.sent_message_count.value +gcp.pubsub.subscription.streaming_pull_ack_message_operation_count.value +gcp.pubsub.subscription.streaming_pull_ack_request_count.value +gcp.pubsub.subscription.streaming_pull_message_operation_count.value +gcp.pubsub.subscription.streaming_pull_mod_ack_deadline_message_operation_count.value +gcp.pubsub.subscription.streaming_pull_mod_ack_deadline_request_count.value +gcp.pubsub.subscription.streaming_pull_response_count.value +gcp.pubsub.subscription.unacked_bytes_by_region.value +gcp.pubsub.topic.byte_cost.value +gcp.pubsub.topic.config_updates_count.value +gcp.pubsub.topic.message_sizes.value +gcp.pubsub.topic.oldest_retained_acked_message_age_by_region.value +gcp.pubsub.topic.oldest_unacked_message_age_by_region.value +gcp.pubsub.topic.retained_acked_bytes_by_region.value +gcp.pubsub.topic.send_message_operation_count.value +gcp.pubsub.topic.send_request_count.value +gcp.pubsub.topic.streaming_pull_response_count.value +gcp.pubsub.topic.unacked_bytes_by_region.value +gcp.storage.api.request_count.value +gcp.storage.authz.acl_based_object_access_count.value +gcp.storage.authz.acl_operations_count.value +gcp.storage.authz.object_specific_acl_mutation_count.value +gcp.storage.network.received_bytes_count.value +gcp.storage.network.sent_bytes_count.value +gcp.storage.storage.object_count.value +gcp.storage.storage.total_byte_seconds.value +gcp.storage.storage.total_bytes.value +geo.city_name +geo.continent_name +geo.country_iso_code +geo.country_name +geo.location +geo.name +geo.region_iso_code +geo.region_name +golang.expvar.cmdline +golang.heap.allocations.active +golang.heap.allocations.allocated +golang.heap.allocations.frees +golang.heap.allocations.idle +golang.heap.allocations.mallocs +golang.heap.allocations.objects +golang.heap.allocations.total +golang.heap.cmdline +golang.heap.gc.cpu_fraction +golang.heap.gc.next_gc_limit +golang.heap.gc.pause.avg.ns +golang.heap.gc.pause.count +golang.heap.gc.pause.max.ns +golang.heap.gc.pause.sum.ns +golang.heap.gc.total_count +golang.heap.gc.total_pause.ns +golang.heap.system.obtained +golang.heap.system.released +golang.heap.system.stack +golang.heap.system.total +graphite.server.example +group.domain +group.id +group.name +haproxy.info.busy_polling +haproxy.info.bytes.out.rate +haproxy.info.bytes.out.total +haproxy.info.compress.bps.in +haproxy.info.compress.bps.out +haproxy.info.compress.bps.rate_limit +haproxy.info.connection.current +haproxy.info.connection.hard_max +haproxy.info.connection.max +haproxy.info.connection.rate.limit +haproxy.info.connection.rate.max +haproxy.info.connection.rate.value +haproxy.info.connection.ssl.current +haproxy.info.connection.ssl.max +haproxy.info.connection.ssl.total +haproxy.info.connection.total +haproxy.info.dropped_logs +haproxy.info.failed_resolutions +haproxy.info.idle.pct +haproxy.info.jobs +haproxy.info.listeners +haproxy.info.memory.max.bytes +haproxy.info.peers.active +haproxy.info.peers.connected +haproxy.info.pipes.free +haproxy.info.pipes.max +haproxy.info.pipes.used +haproxy.info.pool.allocated +haproxy.info.pool.failed +haproxy.info.pool.used +haproxy.info.process_num +haproxy.info.processes +haproxy.info.requests.max +haproxy.info.requests.total +haproxy.info.run_queue +haproxy.info.session.rate.limit +haproxy.info.session.rate.max +haproxy.info.session.rate.value +haproxy.info.sockets.max +haproxy.info.ssl.backend.key_rate.max +haproxy.info.ssl.backend.key_rate.value +haproxy.info.ssl.cache_misses +haproxy.info.ssl.cached_lookups +haproxy.info.ssl.frontend.key_rate.max +haproxy.info.ssl.frontend.key_rate.value +haproxy.info.ssl.frontend.session_reuse.pct +haproxy.info.ssl.rate.limit +haproxy.info.ssl.rate.max +haproxy.info.ssl.rate.value +haproxy.info.stopping +haproxy.info.tasks +haproxy.info.threads +haproxy.info.ulimit_n +haproxy.info.unstoppable_jobs +haproxy.info.uptime.sec +haproxy.info.zlib_mem_usage.max +haproxy.info.zlib_mem_usage.value +haproxy.stat.agent.check.description +haproxy.stat.agent.check.fall +haproxy.stat.agent.check.health +haproxy.stat.agent.check.rise +haproxy.stat.agent.code +haproxy.stat.agent.description +haproxy.stat.agent.duration +haproxy.stat.agent.fall +haproxy.stat.agent.health +haproxy.stat.agent.rise +haproxy.stat.agent.status +haproxy.stat.check.agent.last +haproxy.stat.check.code +haproxy.stat.check.down +haproxy.stat.check.duration +haproxy.stat.check.failed +haproxy.stat.check.health.fail +haproxy.stat.check.health.last +haproxy.stat.check.status +haproxy.stat.client.aborted +haproxy.stat.component_type +haproxy.stat.compressor.bypassed.bytes +haproxy.stat.compressor.in.bytes +haproxy.stat.compressor.out.bytes +haproxy.stat.compressor.response.bytes +haproxy.stat.connection.attempt.total +haproxy.stat.connection.cache.hits +haproxy.stat.connection.cache.lookup.total +haproxy.stat.connection.idle.limit +haproxy.stat.connection.idle.total +haproxy.stat.connection.rate +haproxy.stat.connection.rate_max +haproxy.stat.connection.retried +haproxy.stat.connection.reuse.total +haproxy.stat.connection.time.avg +haproxy.stat.connection.total +haproxy.stat.cookie +haproxy.stat.downtime +haproxy.stat.header.rewrite.failed.total +haproxy.stat.in.bytes +haproxy.stat.last_change +haproxy.stat.load_balancing_algorithm +haproxy.stat.out.bytes +haproxy.stat.proxy.id +haproxy.stat.proxy.mode +haproxy.stat.proxy.name +haproxy.stat.queue.limit +haproxy.stat.queue.time.avg +haproxy.stat.request.connection.errors +haproxy.stat.request.denied +haproxy.stat.request.denied_by_connection_rules +haproxy.stat.request.denied_by_session_rules +haproxy.stat.request.errors +haproxy.stat.request.intercepted +haproxy.stat.request.queued.current +haproxy.stat.request.queued.max +haproxy.stat.request.rate.max +haproxy.stat.request.rate.value +haproxy.stat.request.redispatched +haproxy.stat.request.total +haproxy.stat.response.denied +haproxy.stat.response.errors +haproxy.stat.response.http.1xx +haproxy.stat.response.http.2xx +haproxy.stat.response.http.3xx +haproxy.stat.response.http.4xx +haproxy.stat.response.http.5xx +haproxy.stat.response.http.other +haproxy.stat.response.time.avg +haproxy.stat.selected.total +haproxy.stat.server.aborted +haproxy.stat.server.active +haproxy.stat.server.backup +haproxy.stat.server.id +haproxy.stat.service_name +haproxy.stat.session.current +haproxy.stat.session.limit +haproxy.stat.session.max +haproxy.stat.session.rate.limit +haproxy.stat.session.rate.max +haproxy.stat.session.rate.value +haproxy.stat.session.total +haproxy.stat.source.address +haproxy.stat.status +haproxy.stat.throttle.pct +haproxy.stat.tracked.id +haproxy.stat.weight +hash.md5 +hash.sha1 +hash.sha256 +hash.sha512 +host.architecture +host.containerized +host.cpu.pct +host.domain +host.geo.city_name +host.geo.continent_name +host.geo.country_iso_code +host.geo.country_name +host.geo.location +host.geo.name +host.geo.region_iso_code +host.geo.region_name +host.hostname +host.id +host.ip +host.mac +host.name +host.network.in.bytes +host.network.in.packets +host.network.out.bytes +host.network.out.packets +host.os.build +host.os.codename +host.os.family +host.os.full +host.os.full.text +host.os.kernel +host.os.name +host.os.name.text +host.os.platform +host.os.type +host.os.version +host.type +host.uptime +host.user.domain +host.user.email +host.user.full_name +host.user.full_name.text +host.user.group.domain +host.user.group.id +host.user.group.name +host.user.hash +host.user.id +host.user.name +host.user.name.text +http.request.body.bytes +http.request.body.content +http.request.body.content.text +http.request.bytes +http.request.method +http.request.referrer +http.response.body.bytes +http.response.body.content +http.response.body.content.text +http.response.bytes +http.response.code +http.response.phrase +http.response.status_code +http.version +iis.application_pool.name +iis.application_pool.net_clr.filters_per_sec +iis.application_pool.net_clr.finallys_per_sec +iis.application_pool.net_clr.throw_to_catch_depth_per_sec +iis.application_pool.net_clr.total_exceptions_thrown +iis.application_pool.process.cpu_usage_perc +iis.application_pool.process.handle_count +iis.application_pool.process.io_read_operations_per_sec +iis.application_pool.process.io_write_operations_per_sec +iis.application_pool.process.page_faults_per_sec +iis.application_pool.process.private_bytes +iis.application_pool.process.thread_count +iis.application_pool.process.virtual_bytes +iis.application_pool.process.working_set +iis.webserver.asp_net.application_restarts +iis.webserver.asp_net.request_wait_time +iis.webserver.asp_net_application.errors_total_per_sec +iis.webserver.asp_net_application.pipeline_instance_count +iis.webserver.asp_net_application.requests_executing +iis.webserver.asp_net_application.requests_in_application_queue +iis.webserver.asp_net_application.requests_per_sec +iis.webserver.cache.current_file_cache_memory_usage +iis.webserver.cache.current_files_cached +iis.webserver.cache.current_uris_cached +iis.webserver.cache.file_cache_hits +iis.webserver.cache.file_cache_misses +iis.webserver.cache.maximum_file_cache_memory_usage +iis.webserver.cache.output_cache_current_items +iis.webserver.cache.output_cache_current_memory_usage +iis.webserver.cache.output_cache_total_hits +iis.webserver.cache.output_cache_total_misses +iis.webserver.cache.total_files_cached +iis.webserver.cache.total_uris_cached +iis.webserver.cache.uri_cache_hits +iis.webserver.cache.uri_cache_misses +iis.webserver.network.anonymous_users_per_sec +iis.webserver.network.bytes_received_per_sec +iis.webserver.network.bytes_sent_per_sec +iis.webserver.network.current_anonymous_users +iis.webserver.network.current_connections +iis.webserver.network.current_non_anonymous_users +iis.webserver.network.delete_requests_per_sec +iis.webserver.network.get_requests_per_sec +iis.webserver.network.maximum_connections +iis.webserver.network.post_requests_per_sec +iis.webserver.network.service_uptime +iis.webserver.network.total_anonymous_users +iis.webserver.network.total_bytes_received +iis.webserver.network.total_bytes_sent +iis.webserver.network.total_connection_attempts +iis.webserver.network.total_delete_requests +iis.webserver.network.total_get_requests +iis.webserver.network.total_non_anonymous_users +iis.webserver.network.total_post_requests +iis.webserver.process.cpu_usage_perc +iis.webserver.process.handle_count +iis.webserver.process.io_read_operations_per_sec +iis.webserver.process.io_write_operations_per_sec +iis.webserver.process.page_faults_per_sec +iis.webserver.process.private_bytes +iis.webserver.process.thread_count +iis.webserver.process.virtual_bytes +iis.webserver.process.worker_process_count +iis.webserver.process.working_set +iis.website.name +iis.website.network.bytes_received_per_sec +iis.website.network.bytes_sent_per_sec +iis.website.network.current_connections +iis.website.network.delete_requests_per_sec +iis.website.network.get_requests_per_sec +iis.website.network.maximum_connections +iis.website.network.post_requests_per_sec +iis.website.network.put_requests_per_sec +iis.website.network.service_uptime +iis.website.network.total_bytes_received +iis.website.network.total_bytes_sent +iis.website.network.total_connection_attempts +iis.website.network.total_delete_requests +iis.website.network.total_get_requests +iis.website.network.total_post_requests +iis.website.network.total_put_requests +interface.alias +interface.id +interface.name +istio.citadel.grpc.method +istio.citadel.grpc.server.handled +istio.citadel.grpc.server.handling.latency.ms.count +istio.citadel.grpc.server.handling.latency.ms.sum +istio.citadel.grpc.server.msg.received +istio.citadel.grpc.server.msg.sent +istio.citadel.grpc.server.started +istio.citadel.grpc.service +istio.citadel.grpc.type +istio.citadel.secret_controller_svc_acc_created_cert.count +istio.citadel.server_root_cert_expiry_seconds +istio.galley.collection +istio.galley.istio.authentication.meshpolicies +istio.galley.istio.authentication.policies +istio.galley.istio.mesh.MeshConfig +istio.galley.istio.networking.destinationrules +istio.galley.istio.networking.envoyfilters +istio.galley.istio.networking.gateways +istio.galley.istio.networking.sidecars +istio.galley.istio.networking.virtualservices +istio.galley.istio.policy.attributemanifests +istio.galley.istio.policy.handlers +istio.galley.istio.policy.instances +istio.galley.istio.policy.rules +istio.galley.name +istio.galley.namespace +istio.galley.runtime.processor.event_span.duration.ms.count +istio.galley.runtime.processor.event_span.duration.ms.sum +istio.galley.runtime.processor.snapshot_events.count +istio.galley.runtime.processor.snapshot_events.sum +istio.galley.runtime.processor.snapshot_lifetime.duration.ms.count +istio.galley.runtime.processor.snapshot_lifetime.duration.ms.sum +istio.galley.runtime.state_type_instances +istio.galley.runtime.strategy.on_change +istio.galley.runtime.strategy.timer_quiesce_reached +istio.galley.source_kube_event_success_total +istio.galley.validation.cert_key.updates +istio.galley.validation.config.load +istio.galley.validation.config.updates +istio.galley.version +istio.mesh.connection.security.policy +istio.mesh.destination.app +istio.mesh.destination.principal +istio.mesh.destination.service.host +istio.mesh.destination.service.name +istio.mesh.destination.service.namespace +istio.mesh.destination.version +istio.mesh.destination.workload.name +istio.mesh.destination.workload.namespace +istio.mesh.instance +istio.mesh.job +istio.mesh.reporter +istio.mesh.request.duration.ms.count +istio.mesh.request.duration.ms.sum +istio.mesh.request.protocol +istio.mesh.request.size.bytes.count +istio.mesh.request.size.bytes.sum +istio.mesh.requests +istio.mesh.response.code +istio.mesh.response.size.bytes.count +istio.mesh.response.size.bytes.sum +istio.mesh.source.app +istio.mesh.source.principal +istio.mesh.source.version +istio.mesh.source.workload.name +istio.mesh.source.workload.namespace +istio.mixer.config.adapter.info.configs +istio.mixer.config.adapter.info.errors.config +istio.mixer.config.attributes +istio.mixer.config.handler.configs +istio.mixer.config.handler.errors.validation +istio.mixer.config.instance.configs +istio.mixer.config.instance.errors.config +istio.mixer.config.rule.configs +istio.mixer.config.rule.errors.config +istio.mixer.config.rule.errors.match +istio.mixer.config.template.configs +istio.mixer.config.template.errors.config +istio.mixer.config.unsatisfied.action_handler +istio.mixer.dispatcher_destinations_per_variety_total +istio.mixer.handler.daemons +istio.mixer.handler.failures.build +istio.mixer.handler.failures.close +istio.mixer.handler.handlers.closed +istio.mixer.handler.handlers.new +istio.mixer.handler.handlers.reused +istio.mixer.handler.name +istio.mixer.istio.mcp.request.acks +istio.mixer.variety +istio.pilot.cluster +istio.pilot.conflict.listener.inbound +istio.pilot.conflict.listener.outbound.http.over.current.tcp +istio.pilot.conflict.listener.outbound.http.over.https +istio.pilot.conflict.listener.outbound.tcp.over.current.http +istio.pilot.conflict.listener.outbound.tcp.over.current.tcp +istio.pilot.no.ip +istio.pilot.proxy.conv.ms.count +istio.pilot.proxy.conv.ms.sum +istio.pilot.services +istio.pilot.type +istio.pilot.virt.services +istio.pilot.xds.count +istio.pilot.xds.eds.instances +istio.pilot.xds.internal.errors +istio.pilot.xds.push.context.errors +istio.pilot.xds.push.time.ms.count +istio.pilot.xds.push.time.ms.sum +istio.pilot.xds.pushes +jolokia.agent.id +jolokia.agent.version +jolokia.secured +jolokia.server.product +jolokia.server.vendor +jolokia.server.version +jolokia.url +kafka.broker.address +kafka.broker.id +kafka.broker.log.flush_rate +kafka.broker.mbean +kafka.broker.messages_in +kafka.broker.net.in.bytes_per_sec +kafka.broker.net.out.bytes_per_sec +kafka.broker.net.rejected.bytes_per_sec +kafka.broker.replication.leader_elections +kafka.broker.replication.unclean_leader_elections +kafka.broker.request.channel.queue.size +kafka.broker.request.fetch.failed +kafka.broker.request.fetch.failed_per_second +kafka.broker.request.produce.failed +kafka.broker.request.produce.failed_per_second +kafka.broker.session.zookeeper.disconnect +kafka.broker.session.zookeeper.expire +kafka.broker.session.zookeeper.readonly +kafka.broker.session.zookeeper.sync +kafka.broker.topic.messages_in +kafka.broker.topic.net.in.bytes_per_sec +kafka.broker.topic.net.out.bytes_per_sec +kafka.broker.topic.net.rejected.bytes_per_sec +kafka.consumer.bytes_consumed +kafka.consumer.fetch_rate +kafka.consumer.in.bytes_per_sec +kafka.consumer.kafka_commits +kafka.consumer.max_lag +kafka.consumer.mbean +kafka.consumer.messages_in +kafka.consumer.records_consumed +kafka.consumer.zookeeper_commits +kafka.consumergroup.broker.address +kafka.consumergroup.broker.id +kafka.consumergroup.client.host +kafka.consumergroup.client.id +kafka.consumergroup.client.member_id +kafka.consumergroup.consumer_lag +kafka.consumergroup.error.code +kafka.consumergroup.id +kafka.consumergroup.meta +kafka.consumergroup.offset +kafka.consumergroup.partition +kafka.consumergroup.topic +kafka.partition.broker.address +kafka.partition.broker.id +kafka.partition.id +kafka.partition.offset.newest +kafka.partition.offset.oldest +kafka.partition.partition.error.code +kafka.partition.partition.id +kafka.partition.partition.insync_replica +kafka.partition.partition.is_leader +kafka.partition.partition.leader +kafka.partition.partition.replica +kafka.partition.topic.error.code +kafka.partition.topic.name +kafka.partition.topic_broker_id +kafka.partition.topic_id +kafka.producer.available_buffer_bytes +kafka.producer.batch_size_avg +kafka.producer.batch_size_max +kafka.producer.io_wait +kafka.producer.mbean +kafka.producer.message_rate +kafka.producer.out.bytes_per_sec +kafka.producer.record_error_rate +kafka.producer.record_retry_rate +kafka.producer.record_send_rate +kafka.producer.record_size_avg +kafka.producer.record_size_max +kafka.producer.records_per_request +kafka.producer.request_rate +kafka.producer.response_rate +kafka.topic.error.code +kafka.topic.name +kibana.stats.concurrent_connections +kibana.stats.host.name +kibana.stats.index +kibana.stats.name +kibana.stats.process.event_loop_delay.ms +kibana.stats.process.memory.heap.size_limit.bytes +kibana.stats.process.memory.heap.total.bytes +kibana.stats.process.memory.heap.uptime.ms +kibana.stats.process.memory.heap.used.bytes +kibana.stats.request.disconnects +kibana.stats.request.total +kibana.stats.response_time.avg.ms +kibana.stats.response_time.max.ms +kibana.stats.snapshot +kibana.stats.status +kibana.status.metrics.concurrent_connections +kibana.status.metrics.requests.disconnects +kibana.status.metrics.requests.total +kibana.status.name +kibana.status.status.overall.state +kubernetes.apiserver.audit.event.count +kubernetes.apiserver.audit.rejected.count +kubernetes.apiserver.client.request.count +kubernetes.apiserver.etcd.object.count +kubernetes.apiserver.http.request.count +kubernetes.apiserver.http.request.duration.us.count +kubernetes.apiserver.http.request.duration.us.sum +kubernetes.apiserver.http.request.size.bytes.count +kubernetes.apiserver.http.request.size.bytes.sum +kubernetes.apiserver.http.response.size.bytes.count +kubernetes.apiserver.http.response.size.bytes.sum +kubernetes.apiserver.process.cpu.sec +kubernetes.apiserver.process.fds.open.count +kubernetes.apiserver.process.memory.resident.bytes +kubernetes.apiserver.process.memory.virtual.bytes +kubernetes.apiserver.process.started.sec +kubernetes.apiserver.request.client +kubernetes.apiserver.request.code +kubernetes.apiserver.request.component +kubernetes.apiserver.request.content_type +kubernetes.apiserver.request.count +kubernetes.apiserver.request.current.count +kubernetes.apiserver.request.dry_run +kubernetes.apiserver.request.duration.us.count +kubernetes.apiserver.request.duration.us.sum +kubernetes.apiserver.request.group +kubernetes.apiserver.request.handler +kubernetes.apiserver.request.host +kubernetes.apiserver.request.kind +kubernetes.apiserver.request.latency.count +kubernetes.apiserver.request.latency.sum +kubernetes.apiserver.request.longrunning.count +kubernetes.apiserver.request.method +kubernetes.apiserver.request.resource +kubernetes.apiserver.request.scope +kubernetes.apiserver.request.subresource +kubernetes.apiserver.request.verb +kubernetes.apiserver.request.version +kubernetes.container.cpu.limit.cores +kubernetes.container.cpu.limit.nanocores +kubernetes.container.cpu.request.cores +kubernetes.container.cpu.request.nanocores +kubernetes.container.cpu.usage.core.ns +kubernetes.container.cpu.usage.limit.pct +kubernetes.container.cpu.usage.nanocores +kubernetes.container.cpu.usage.node.pct +kubernetes.container.id +kubernetes.container.image +kubernetes.container.logs.available.bytes +kubernetes.container.logs.capacity.bytes +kubernetes.container.logs.inodes.count +kubernetes.container.logs.inodes.free +kubernetes.container.logs.inodes.used +kubernetes.container.logs.used.bytes +kubernetes.container.memory.available.bytes +kubernetes.container.memory.limit.bytes +kubernetes.container.memory.majorpagefaults +kubernetes.container.memory.pagefaults +kubernetes.container.memory.request.bytes +kubernetes.container.memory.rss.bytes +kubernetes.container.memory.usage.bytes +kubernetes.container.memory.usage.limit.pct +kubernetes.container.memory.usage.node.pct +kubernetes.container.memory.workingset.bytes +kubernetes.container.name +kubernetes.container.rootfs.available.bytes +kubernetes.container.rootfs.capacity.bytes +kubernetes.container.rootfs.inodes.used +kubernetes.container.rootfs.used.bytes +kubernetes.container.start_time +kubernetes.container.status.phase +kubernetes.container.status.ready +kubernetes.container.status.reason +kubernetes.container.status.restarts +kubernetes.controllermanager.client.request.count +kubernetes.controllermanager.code +kubernetes.controllermanager.handler +kubernetes.controllermanager.host +kubernetes.controllermanager.http.request.count +kubernetes.controllermanager.http.request.duration.us.count +kubernetes.controllermanager.http.request.duration.us.sum +kubernetes.controllermanager.http.request.size.bytes.count +kubernetes.controllermanager.http.request.size.bytes.sum +kubernetes.controllermanager.http.response.size.bytes.count +kubernetes.controllermanager.http.response.size.bytes.sum +kubernetes.controllermanager.leader.is_master +kubernetes.controllermanager.method +kubernetes.controllermanager.name +kubernetes.controllermanager.node.collector.count +kubernetes.controllermanager.node.collector.eviction.count +kubernetes.controllermanager.node.collector.health.pct +kubernetes.controllermanager.node.collector.unhealthy.count +kubernetes.controllermanager.process.cpu.sec +kubernetes.controllermanager.process.fds.open.count +kubernetes.controllermanager.process.memory.resident.bytes +kubernetes.controllermanager.process.memory.virtual.bytes +kubernetes.controllermanager.process.started.sec +kubernetes.controllermanager.workqueue.adds.count +kubernetes.controllermanager.workqueue.depth.count +kubernetes.controllermanager.workqueue.longestrunning.sec +kubernetes.controllermanager.workqueue.retries.count +kubernetes.controllermanager.workqueue.unfinished.sec +kubernetes.controllermanager.zone +kubernetes.cronjob.active.count +kubernetes.cronjob.concurrency +kubernetes.cronjob.created.sec +kubernetes.cronjob.deadline.sec +kubernetes.cronjob.is_suspended +kubernetes.cronjob.last_schedule.sec +kubernetes.cronjob.name +kubernetes.cronjob.next_schedule.sec +kubernetes.cronjob.schedule +kubernetes.daemonset.name +kubernetes.daemonset.replicas.available +kubernetes.daemonset.replicas.desired +kubernetes.daemonset.replicas.ready +kubernetes.daemonset.replicas.unavailable +kubernetes.deployment.name +kubernetes.deployment.paused +kubernetes.deployment.replicas.available +kubernetes.deployment.replicas.desired +kubernetes.deployment.replicas.unavailable +kubernetes.deployment.replicas.updated +kubernetes.event.count +kubernetes.event.involved_object.api_version +kubernetes.event.involved_object.kind +kubernetes.event.involved_object.name +kubernetes.event.involved_object.resource_version +kubernetes.event.involved_object.uid +kubernetes.event.message +kubernetes.event.metadata.generate_name +kubernetes.event.metadata.name +kubernetes.event.metadata.namespace +kubernetes.event.metadata.resource_version +kubernetes.event.metadata.self_link +kubernetes.event.metadata.timestamp.created +kubernetes.event.metadata.uid +kubernetes.event.reason +kubernetes.event.source.component +kubernetes.event.source.host +kubernetes.event.timestamp.first_occurrence +kubernetes.event.timestamp.last_occurrence +kubernetes.event.type +kubernetes.namespace +kubernetes.node.cpu.allocatable.cores +kubernetes.node.cpu.capacity.cores +kubernetes.node.cpu.usage.core.ns +kubernetes.node.cpu.usage.nanocores +kubernetes.node.fs.available.bytes +kubernetes.node.fs.capacity.bytes +kubernetes.node.fs.inodes.count +kubernetes.node.fs.inodes.free +kubernetes.node.fs.inodes.used +kubernetes.node.fs.used.bytes +kubernetes.node.memory.allocatable.bytes +kubernetes.node.memory.available.bytes +kubernetes.node.memory.capacity.bytes +kubernetes.node.memory.majorpagefaults +kubernetes.node.memory.pagefaults +kubernetes.node.memory.rss.bytes +kubernetes.node.memory.usage.bytes +kubernetes.node.memory.workingset.bytes +kubernetes.node.name +kubernetes.node.network.rx.bytes +kubernetes.node.network.rx.errors +kubernetes.node.network.tx.bytes +kubernetes.node.network.tx.errors +kubernetes.node.pod.allocatable.total +kubernetes.node.pod.capacity.total +kubernetes.node.runtime.imagefs.available.bytes +kubernetes.node.runtime.imagefs.capacity.bytes +kubernetes.node.runtime.imagefs.used.bytes +kubernetes.node.start_time +kubernetes.node.status.disk_pressure +kubernetes.node.status.memory_pressure +kubernetes.node.status.out_of_disk +kubernetes.node.status.pid_pressure +kubernetes.node.status.ready +kubernetes.node.status.unschedulable +kubernetes.persistentvolume.capacity.bytes +kubernetes.persistentvolume.name +kubernetes.persistentvolume.phase +kubernetes.persistentvolume.storage_class +kubernetes.persistentvolumeclaim.access_mode +kubernetes.persistentvolumeclaim.name +kubernetes.persistentvolumeclaim.phase +kubernetes.persistentvolumeclaim.request_storage.bytes +kubernetes.persistentvolumeclaim.storage_class +kubernetes.persistentvolumeclaim.volume_name +kubernetes.pod.cpu.usage.limit.pct +kubernetes.pod.cpu.usage.nanocores +kubernetes.pod.cpu.usage.node.pct +kubernetes.pod.host_ip +kubernetes.pod.ip +kubernetes.pod.memory.available.bytes +kubernetes.pod.memory.major_page_faults +kubernetes.pod.memory.page_faults +kubernetes.pod.memory.rss.bytes +kubernetes.pod.memory.usage.bytes +kubernetes.pod.memory.usage.limit.pct +kubernetes.pod.memory.usage.node.pct +kubernetes.pod.memory.working_set.bytes +kubernetes.pod.name +kubernetes.pod.network.rx.bytes +kubernetes.pod.network.rx.errors +kubernetes.pod.network.tx.bytes +kubernetes.pod.network.tx.errors +kubernetes.pod.start_time +kubernetes.pod.status.phase +kubernetes.pod.status.ready +kubernetes.pod.status.scheduled +kubernetes.pod.uid +kubernetes.proxy.client.request.count +kubernetes.proxy.code +kubernetes.proxy.handler +kubernetes.proxy.host +kubernetes.proxy.http.request.count +kubernetes.proxy.http.request.duration.us.count +kubernetes.proxy.http.request.duration.us.sum +kubernetes.proxy.http.request.size.bytes.count +kubernetes.proxy.http.request.size.bytes.sum +kubernetes.proxy.http.response.size.bytes.count +kubernetes.proxy.http.response.size.bytes.sum +kubernetes.proxy.method +kubernetes.proxy.process.cpu.sec +kubernetes.proxy.process.fds.open.count +kubernetes.proxy.process.memory.resident.bytes +kubernetes.proxy.process.memory.virtual.bytes +kubernetes.proxy.process.started.sec +kubernetes.proxy.sync.networkprogramming.duration.us.count +kubernetes.proxy.sync.networkprogramming.duration.us.sum +kubernetes.proxy.sync.rules.duration.us.count +kubernetes.proxy.sync.rules.duration.us.sum +kubernetes.replicaset.name +kubernetes.replicaset.replicas.available +kubernetes.replicaset.replicas.desired +kubernetes.replicaset.replicas.labeled +kubernetes.replicaset.replicas.observed +kubernetes.replicaset.replicas.ready +kubernetes.resourcequota.created.sec +kubernetes.resourcequota.name +kubernetes.resourcequota.quota +kubernetes.resourcequota.resource +kubernetes.resourcequota.type +kubernetes.scheduler.client.request.count +kubernetes.scheduler.code +kubernetes.scheduler.handler +kubernetes.scheduler.host +kubernetes.scheduler.http.request.count +kubernetes.scheduler.http.request.duration.us.count +kubernetes.scheduler.http.request.duration.us.sum +kubernetes.scheduler.http.request.size.bytes.count +kubernetes.scheduler.http.request.size.bytes.sum +kubernetes.scheduler.http.response.size.bytes.count +kubernetes.scheduler.http.response.size.bytes.sum +kubernetes.scheduler.leader.is_master +kubernetes.scheduler.method +kubernetes.scheduler.name +kubernetes.scheduler.operation +kubernetes.scheduler.process.cpu.sec +kubernetes.scheduler.process.fds.open.count +kubernetes.scheduler.process.memory.resident.bytes +kubernetes.scheduler.process.memory.virtual.bytes +kubernetes.scheduler.process.started.sec +kubernetes.scheduler.result +kubernetes.scheduler.scheduling.duration.seconds.count +kubernetes.scheduler.scheduling.duration.seconds.sum +kubernetes.scheduler.scheduling.e2e.duration.us.count +kubernetes.scheduler.scheduling.e2e.duration.us.sum +kubernetes.scheduler.scheduling.pod.attempts.count +kubernetes.scheduler.scheduling.pod.preemption.victims.bucket.* +kubernetes.scheduler.scheduling.pod.preemption.victims.count +kubernetes.scheduler.scheduling.pod.preemption.victims.sum +kubernetes.service.cluster_ip +kubernetes.service.created +kubernetes.service.external_ip +kubernetes.service.external_name +kubernetes.service.ingress_hostname +kubernetes.service.ingress_ip +kubernetes.service.load_balancer_ip +kubernetes.service.name +kubernetes.service.type +kubernetes.statefulset.created +kubernetes.statefulset.generation.desired +kubernetes.statefulset.generation.observed +kubernetes.statefulset.name +kubernetes.statefulset.replicas.desired +kubernetes.statefulset.replicas.observed +kubernetes.storageclass.created +kubernetes.storageclass.name +kubernetes.storageclass.provisioner +kubernetes.storageclass.reclaim_policy +kubernetes.storageclass.volume_binding_mode +kubernetes.system.container +kubernetes.system.cpu.usage.core.ns +kubernetes.system.cpu.usage.nanocores +kubernetes.system.memory.majorpagefaults +kubernetes.system.memory.pagefaults +kubernetes.system.memory.rss.bytes +kubernetes.system.memory.usage.bytes +kubernetes.system.memory.workingset.bytes +kubernetes.system.start_time +kubernetes.volume.fs.available.bytes +kubernetes.volume.fs.capacity.bytes +kubernetes.volume.fs.inodes.count +kubernetes.volume.fs.inodes.free +kubernetes.volume.fs.inodes.used +kubernetes.volume.fs.used.bytes +kubernetes.volume.fs.used.pct +kubernetes.volume.name +kvm.dommemstat.id +kvm.dommemstat.name +kvm.dommemstat.stat.name +kvm.dommemstat.stat.value +kvm.id +kvm.name +kvm.status.state +linux.conntrack.summary.drop +linux.conntrack.summary.early_drop +linux.conntrack.summary.entries +linux.conntrack.summary.found +linux.conntrack.summary.ignore +linux.conntrack.summary.insert_failed +linux.conntrack.summary.invalid +linux.conntrack.summary.search_restart +linux.iostat.await +linux.iostat.busy +linux.iostat.queue.avg_size +linux.iostat.read.await +linux.iostat.read.per_sec.bytes +linux.iostat.read.request.merges_per_sec +linux.iostat.read.request.per_sec +linux.iostat.request.avg_size +linux.iostat.service_time +linux.iostat.write.await +linux.iostat.write.per_sec.bytes +linux.iostat.write.request.merges_per_sec +linux.iostat.write.request.per_sec +linux.ksm.stats.full_scans +linux.ksm.stats.pages_shared +linux.ksm.stats.pages_sharing +linux.ksm.stats.pages_unshared +linux.ksm.stats.stable_node_chains +linux.ksm.stats.stable_node_dups +linux.memory.hugepages.default_size +linux.memory.hugepages.free +linux.memory.hugepages.reserved +linux.memory.hugepages.surplus +linux.memory.hugepages.total +linux.memory.hugepages.used.bytes +linux.memory.hugepages.used.pct +linux.memory.page_stats.direct_efficiency.pct +linux.memory.page_stats.kswapd_efficiency.pct +linux.memory.page_stats.pgfree.pages +linux.memory.page_stats.pgscan_direct.pages +linux.memory.page_stats.pgscan_kswapd.pages +linux.memory.page_stats.pgsteal_direct.pages +linux.memory.page_stats.pgsteal_kswapd.pages +linux.pageinfo.buddy_info.DMA.0 +linux.pageinfo.buddy_info.DMA.1 +linux.pageinfo.buddy_info.DMA.10 +linux.pageinfo.buddy_info.DMA.2 +linux.pageinfo.buddy_info.DMA.3 +linux.pageinfo.buddy_info.DMA.4 +linux.pageinfo.buddy_info.DMA.5 +linux.pageinfo.buddy_info.DMA.6 +linux.pageinfo.buddy_info.DMA.7 +linux.pageinfo.buddy_info.DMA.8 +linux.pageinfo.buddy_info.DMA.9 +log.level +log.logger +log.origin.file.line +log.origin.file.name +log.origin.function +log.original +log.syslog.facility.code +log.syslog.facility.name +log.syslog.priority +log.syslog.severity.code +log.syslog.severity.name +logstash.node.jvm.version +logstash.node.stats.events.filtered +logstash.node.stats.events.in +logstash.node.stats.events.out +memcached.stats.bytes.current +memcached.stats.bytes.limit +memcached.stats.cmd.get +memcached.stats.cmd.set +memcached.stats.connections.current +memcached.stats.connections.total +memcached.stats.evictions +memcached.stats.get.hits +memcached.stats.get.misses +memcached.stats.items.current +memcached.stats.items.total +memcached.stats.pid +memcached.stats.read.bytes +memcached.stats.threads +memcached.stats.uptime.sec +memcached.stats.written.bytes +message +metricset.name +metricset.period +mongodb.collstats.collection +mongodb.collstats.commands.count +mongodb.collstats.commands.time.us +mongodb.collstats.db +mongodb.collstats.getmore.count +mongodb.collstats.getmore.time.us +mongodb.collstats.insert.count +mongodb.collstats.insert.time.us +mongodb.collstats.lock.read.count +mongodb.collstats.lock.read.time.us +mongodb.collstats.lock.write.count +mongodb.collstats.lock.write.time.us +mongodb.collstats.name +mongodb.collstats.queries.count +mongodb.collstats.queries.time.us +mongodb.collstats.remove.count +mongodb.collstats.remove.time.us +mongodb.collstats.total.count +mongodb.collstats.total.time.us +mongodb.collstats.update.count +mongodb.collstats.update.time.us +mongodb.dbstats.avg_obj_size.bytes +mongodb.dbstats.collections +mongodb.dbstats.data_file_version.major +mongodb.dbstats.data_file_version.minor +mongodb.dbstats.data_size.bytes +mongodb.dbstats.db +mongodb.dbstats.extent_free_list.num +mongodb.dbstats.extent_free_list.size.bytes +mongodb.dbstats.file_size.bytes +mongodb.dbstats.index_size.bytes +mongodb.dbstats.indexes +mongodb.dbstats.ns_size_mb.mb +mongodb.dbstats.num_extents +mongodb.dbstats.objects +mongodb.dbstats.storage_size.bytes +mongodb.metrics.commands.aggregate.failed +mongodb.metrics.commands.aggregate.total +mongodb.metrics.commands.build_info.failed +mongodb.metrics.commands.build_info.total +mongodb.metrics.commands.coll_stats.failed +mongodb.metrics.commands.coll_stats.total +mongodb.metrics.commands.connection_pool_stats.failed +mongodb.metrics.commands.connection_pool_stats.total +mongodb.metrics.commands.count.failed +mongodb.metrics.commands.count.total +mongodb.metrics.commands.db_stats.failed +mongodb.metrics.commands.db_stats.total +mongodb.metrics.commands.distinct.failed +mongodb.metrics.commands.distinct.total +mongodb.metrics.commands.find.failed +mongodb.metrics.commands.find.total +mongodb.metrics.commands.get_cmd_line_opts.failed +mongodb.metrics.commands.get_cmd_line_opts.total +mongodb.metrics.commands.get_last_error.failed +mongodb.metrics.commands.get_last_error.total +mongodb.metrics.commands.get_log.failed +mongodb.metrics.commands.get_log.total +mongodb.metrics.commands.get_more.failed +mongodb.metrics.commands.get_more.total +mongodb.metrics.commands.get_parameter.failed +mongodb.metrics.commands.get_parameter.total +mongodb.metrics.commands.host_info.failed +mongodb.metrics.commands.host_info.total +mongodb.metrics.commands.insert.failed +mongodb.metrics.commands.insert.total +mongodb.metrics.commands.is_master.failed +mongodb.metrics.commands.is_master.total +mongodb.metrics.commands.is_self.failed +mongodb.metrics.commands.is_self.total +mongodb.metrics.commands.last_collections.failed +mongodb.metrics.commands.last_collections.total +mongodb.metrics.commands.last_commands.failed +mongodb.metrics.commands.last_commands.total +mongodb.metrics.commands.list_databased.failed +mongodb.metrics.commands.list_databased.total +mongodb.metrics.commands.list_indexes.failed +mongodb.metrics.commands.list_indexes.total +mongodb.metrics.commands.ping.failed +mongodb.metrics.commands.ping.total +mongodb.metrics.commands.profile.failed +mongodb.metrics.commands.profile.total +mongodb.metrics.commands.replset_get_rbid.failed +mongodb.metrics.commands.replset_get_rbid.total +mongodb.metrics.commands.replset_get_status.failed +mongodb.metrics.commands.replset_get_status.total +mongodb.metrics.commands.replset_heartbeat.failed +mongodb.metrics.commands.replset_heartbeat.total +mongodb.metrics.commands.replset_update_position.failed +mongodb.metrics.commands.replset_update_position.total +mongodb.metrics.commands.server_status.failed +mongodb.metrics.commands.server_status.total +mongodb.metrics.commands.update.failed +mongodb.metrics.commands.update.total +mongodb.metrics.commands.whatsmyuri.failed +mongodb.metrics.commands.whatsmyuri.total +mongodb.metrics.cursor.open.no_timeout +mongodb.metrics.cursor.open.pinned +mongodb.metrics.cursor.open.total +mongodb.metrics.cursor.timed_out +mongodb.metrics.document.deleted +mongodb.metrics.document.inserted +mongodb.metrics.document.returned +mongodb.metrics.document.updated +mongodb.metrics.get_last_error.write_timeouts +mongodb.metrics.get_last_error.write_wait.count +mongodb.metrics.get_last_error.write_wait.ms +mongodb.metrics.operation.scan_and_order +mongodb.metrics.operation.write_conflicts +mongodb.metrics.query_executor.scanned_documents.count +mongodb.metrics.query_executor.scanned_indexes.count +mongodb.metrics.replication.apply.attempts_to_become_secondary +mongodb.metrics.replication.apply.batches.count +mongodb.metrics.replication.apply.batches.time.ms +mongodb.metrics.replication.apply.ops +mongodb.metrics.replication.buffer.count +mongodb.metrics.replication.buffer.max_size.bytes +mongodb.metrics.replication.buffer.size.bytes +mongodb.metrics.replication.executor.counters.cancels +mongodb.metrics.replication.executor.counters.event_created +mongodb.metrics.replication.executor.counters.event_wait +mongodb.metrics.replication.executor.counters.scheduled.dbwork +mongodb.metrics.replication.executor.counters.scheduled.exclusive +mongodb.metrics.replication.executor.counters.scheduled.failures +mongodb.metrics.replication.executor.counters.scheduled.netcmd +mongodb.metrics.replication.executor.counters.scheduled.work +mongodb.metrics.replication.executor.counters.scheduled.work_at +mongodb.metrics.replication.executor.counters.waits +mongodb.metrics.replication.executor.event_waiters +mongodb.metrics.replication.executor.network_interface +mongodb.metrics.replication.executor.queues.free +mongodb.metrics.replication.executor.queues.in_progress.dbwork +mongodb.metrics.replication.executor.queues.in_progress.exclusive +mongodb.metrics.replication.executor.queues.in_progress.network +mongodb.metrics.replication.executor.queues.ready +mongodb.metrics.replication.executor.queues.sleepers +mongodb.metrics.replication.executor.shutting_down +mongodb.metrics.replication.executor.unsignaled_events +mongodb.metrics.replication.initial_sync.completed +mongodb.metrics.replication.initial_sync.failed_attempts +mongodb.metrics.replication.initial_sync.failures +mongodb.metrics.replication.network.bytes +mongodb.metrics.replication.network.getmores.count +mongodb.metrics.replication.network.getmores.time.ms +mongodb.metrics.replication.network.ops +mongodb.metrics.replication.network.reders_created +mongodb.metrics.replication.preload.docs.count +mongodb.metrics.replication.preload.docs.time.ms +mongodb.metrics.replication.preload.indexes.count +mongodb.metrics.replication.preload.indexes.time.ms +mongodb.metrics.storage.free_list.search.bucket_exhausted +mongodb.metrics.storage.free_list.search.requests +mongodb.metrics.storage.free_list.search.scanned +mongodb.metrics.ttl.deleted_documents.count +mongodb.metrics.ttl.passes.count +mongodb.replstatus.headroom.max +mongodb.replstatus.headroom.min +mongodb.replstatus.lag.max +mongodb.replstatus.lag.min +mongodb.replstatus.members.arbiter.count +mongodb.replstatus.members.arbiter.hosts +mongodb.replstatus.members.down.count +mongodb.replstatus.members.down.hosts +mongodb.replstatus.members.primary.host +mongodb.replstatus.members.primary.optime +mongodb.replstatus.members.recovering.count +mongodb.replstatus.members.recovering.hosts +mongodb.replstatus.members.rollback.count +mongodb.replstatus.members.rollback.hosts +mongodb.replstatus.members.secondary.count +mongodb.replstatus.members.secondary.hosts +mongodb.replstatus.members.secondary.optimes +mongodb.replstatus.members.startup2.count +mongodb.replstatus.members.startup2.hosts +mongodb.replstatus.members.unhealthy.count +mongodb.replstatus.members.unhealthy.hosts +mongodb.replstatus.members.unknown.count +mongodb.replstatus.members.unknown.hosts +mongodb.replstatus.oplog.first.timestamp +mongodb.replstatus.oplog.last.timestamp +mongodb.replstatus.oplog.size.allocated +mongodb.replstatus.oplog.size.used +mongodb.replstatus.oplog.window +mongodb.replstatus.optimes.applied +mongodb.replstatus.optimes.durable +mongodb.replstatus.optimes.last_committed +mongodb.replstatus.server_date +mongodb.replstatus.set_name +mongodb.status.asserts.msg +mongodb.status.asserts.regular +mongodb.status.asserts.rollovers +mongodb.status.asserts.user +mongodb.status.asserts.warning +mongodb.status.background_flushing.average.ms +mongodb.status.background_flushing.flushes +mongodb.status.background_flushing.last.ms +mongodb.status.background_flushing.last_finished +mongodb.status.background_flushing.total.ms +mongodb.status.connections.available +mongodb.status.connections.current +mongodb.status.connections.total_created +mongodb.status.extra_info.heap_usage.bytes +mongodb.status.extra_info.page_faults +mongodb.status.global_lock.active_clients.readers +mongodb.status.global_lock.active_clients.total +mongodb.status.global_lock.active_clients.writers +mongodb.status.global_lock.current_queue.readers +mongodb.status.global_lock.current_queue.total +mongodb.status.global_lock.current_queue.writers +mongodb.status.global_lock.total_time.us +mongodb.status.journaling.commits +mongodb.status.journaling.commits_in_write_lock +mongodb.status.journaling.compression +mongodb.status.journaling.early_commits +mongodb.status.journaling.journaled.mb +mongodb.status.journaling.times.commits.ms +mongodb.status.journaling.times.commits_in_write_lock.ms +mongodb.status.journaling.times.dt.ms +mongodb.status.journaling.times.prep_log_buffer.ms +mongodb.status.journaling.times.remap_private_view.ms +mongodb.status.journaling.times.write_to_data_files.ms +mongodb.status.journaling.times.write_to_journal.ms +mongodb.status.journaling.write_to_data_files.mb +mongodb.status.local_time +mongodb.status.locks.collection.acquire.count.R +mongodb.status.locks.collection.acquire.count.W +mongodb.status.locks.collection.acquire.count.r +mongodb.status.locks.collection.acquire.count.w +mongodb.status.locks.collection.deadlock.count.R +mongodb.status.locks.collection.deadlock.count.W +mongodb.status.locks.collection.deadlock.count.r +mongodb.status.locks.collection.deadlock.count.w +mongodb.status.locks.collection.wait.count.R +mongodb.status.locks.collection.wait.count.W +mongodb.status.locks.collection.wait.count.r +mongodb.status.locks.collection.wait.count.w +mongodb.status.locks.collection.wait.us.R +mongodb.status.locks.collection.wait.us.W +mongodb.status.locks.collection.wait.us.r +mongodb.status.locks.collection.wait.us.w +mongodb.status.locks.database.acquire.count.R +mongodb.status.locks.database.acquire.count.W +mongodb.status.locks.database.acquire.count.r +mongodb.status.locks.database.acquire.count.w +mongodb.status.locks.database.deadlock.count.R +mongodb.status.locks.database.deadlock.count.W +mongodb.status.locks.database.deadlock.count.r +mongodb.status.locks.database.deadlock.count.w +mongodb.status.locks.database.wait.count.R +mongodb.status.locks.database.wait.count.W +mongodb.status.locks.database.wait.count.r +mongodb.status.locks.database.wait.count.w +mongodb.status.locks.database.wait.us.R +mongodb.status.locks.database.wait.us.W +mongodb.status.locks.database.wait.us.r +mongodb.status.locks.database.wait.us.w +mongodb.status.locks.global.acquire.count.R +mongodb.status.locks.global.acquire.count.W +mongodb.status.locks.global.acquire.count.r +mongodb.status.locks.global.acquire.count.w +mongodb.status.locks.global.deadlock.count.R +mongodb.status.locks.global.deadlock.count.W +mongodb.status.locks.global.deadlock.count.r +mongodb.status.locks.global.deadlock.count.w +mongodb.status.locks.global.wait.count.R +mongodb.status.locks.global.wait.count.W +mongodb.status.locks.global.wait.count.r +mongodb.status.locks.global.wait.count.w +mongodb.status.locks.global.wait.us.R +mongodb.status.locks.global.wait.us.W +mongodb.status.locks.global.wait.us.r +mongodb.status.locks.global.wait.us.w +mongodb.status.locks.meta_data.acquire.count.R +mongodb.status.locks.meta_data.acquire.count.W +mongodb.status.locks.meta_data.acquire.count.r +mongodb.status.locks.meta_data.acquire.count.w +mongodb.status.locks.meta_data.deadlock.count.R +mongodb.status.locks.meta_data.deadlock.count.W +mongodb.status.locks.meta_data.deadlock.count.r +mongodb.status.locks.meta_data.deadlock.count.w +mongodb.status.locks.meta_data.wait.count.R +mongodb.status.locks.meta_data.wait.count.W +mongodb.status.locks.meta_data.wait.count.r +mongodb.status.locks.meta_data.wait.count.w +mongodb.status.locks.meta_data.wait.us.R +mongodb.status.locks.meta_data.wait.us.W +mongodb.status.locks.meta_data.wait.us.r +mongodb.status.locks.meta_data.wait.us.w +mongodb.status.locks.oplog.acquire.count.R +mongodb.status.locks.oplog.acquire.count.W +mongodb.status.locks.oplog.acquire.count.r +mongodb.status.locks.oplog.acquire.count.w +mongodb.status.locks.oplog.deadlock.count.R +mongodb.status.locks.oplog.deadlock.count.W +mongodb.status.locks.oplog.deadlock.count.r +mongodb.status.locks.oplog.deadlock.count.w +mongodb.status.locks.oplog.wait.count.R +mongodb.status.locks.oplog.wait.count.W +mongodb.status.locks.oplog.wait.count.r +mongodb.status.locks.oplog.wait.count.w +mongodb.status.locks.oplog.wait.us.R +mongodb.status.locks.oplog.wait.us.W +mongodb.status.locks.oplog.wait.us.r +mongodb.status.locks.oplog.wait.us.w +mongodb.status.memory.bits +mongodb.status.memory.mapped.mb +mongodb.status.memory.mapped_with_journal.mb +mongodb.status.memory.resident.mb +mongodb.status.memory.virtual.mb +mongodb.status.network.in.bytes +mongodb.status.network.out.bytes +mongodb.status.network.requests +mongodb.status.ops.counters.command +mongodb.status.ops.counters.delete +mongodb.status.ops.counters.getmore +mongodb.status.ops.counters.insert +mongodb.status.ops.counters.query +mongodb.status.ops.counters.update +mongodb.status.ops.latencies.commands.count +mongodb.status.ops.latencies.commands.latency +mongodb.status.ops.latencies.reads.count +mongodb.status.ops.latencies.reads.latency +mongodb.status.ops.latencies.writes.count +mongodb.status.ops.latencies.writes.latency +mongodb.status.ops.replicated.command +mongodb.status.ops.replicated.delete +mongodb.status.ops.replicated.getmore +mongodb.status.ops.replicated.insert +mongodb.status.ops.replicated.query +mongodb.status.ops.replicated.update +mongodb.status.process +mongodb.status.storage_engine.name +mongodb.status.uptime.ms +mongodb.status.version +mongodb.status.wired_tiger.cache.dirty.bytes +mongodb.status.wired_tiger.cache.maximum.bytes +mongodb.status.wired_tiger.cache.pages.evicted +mongodb.status.wired_tiger.cache.pages.read +mongodb.status.wired_tiger.cache.pages.write +mongodb.status.wired_tiger.cache.used.bytes +mongodb.status.wired_tiger.concurrent_transactions.read.available +mongodb.status.wired_tiger.concurrent_transactions.read.out +mongodb.status.wired_tiger.concurrent_transactions.read.total_tickets +mongodb.status.wired_tiger.concurrent_transactions.write.available +mongodb.status.wired_tiger.concurrent_transactions.write.out +mongodb.status.wired_tiger.concurrent_transactions.write.total_tickets +mongodb.status.wired_tiger.log.flushes +mongodb.status.wired_tiger.log.max_file_size.bytes +mongodb.status.wired_tiger.log.scans +mongodb.status.wired_tiger.log.size.bytes +mongodb.status.wired_tiger.log.syncs +mongodb.status.wired_tiger.log.write.bytes +mongodb.status.wired_tiger.log.writes +mongodb.status.write_backs_queued +mssql.database.id +mssql.database.name +mssql.performance.active_temp_tables +mssql.performance.batch_requests_per_sec +mssql.performance.buffer.cache_hit.pct +mssql.performance.buffer.checkpoint_pages_per_sec +mssql.performance.buffer.database_pages +mssql.performance.buffer.page_life_expectancy.sec +mssql.performance.buffer.target_pages +mssql.performance.compilations_per_sec +mssql.performance.connections_reset_per_sec +mssql.performance.lock_waits_per_sec +mssql.performance.logins_per_sec +mssql.performance.logouts_per_sec +mssql.performance.page_splits_per_sec +mssql.performance.recompilations_per_sec +mssql.performance.transactions +mssql.performance.user_connections +mssql.transaction_log.space_usage.since_last_backup.bytes +mssql.transaction_log.space_usage.total.bytes +mssql.transaction_log.space_usage.used.bytes +mssql.transaction_log.space_usage.used.pct +mssql.transaction_log.stats.active_size.bytes +mssql.transaction_log.stats.backup_time +mssql.transaction_log.stats.recovery_size.bytes +mssql.transaction_log.stats.since_last_checkpoint.bytes +mssql.transaction_log.stats.total_size.bytes +munin.plugin.name +mysql.galera_status.apply.oooe +mysql.galera_status.apply.oool +mysql.galera_status.apply.window +mysql.galera_status.cert.deps_distance +mysql.galera_status.cert.index_size +mysql.galera_status.cert.interval +mysql.galera_status.cluster.conf_id +mysql.galera_status.cluster.size +mysql.galera_status.cluster.status +mysql.galera_status.commit.oooe +mysql.galera_status.commit.window +mysql.galera_status.connected +mysql.galera_status.evs.evict +mysql.galera_status.evs.state +mysql.galera_status.flow_ctl.paused +mysql.galera_status.flow_ctl.paused_ns +mysql.galera_status.flow_ctl.recv +mysql.galera_status.flow_ctl.sent +mysql.galera_status.last_committed +mysql.galera_status.local.bf_aborts +mysql.galera_status.local.cert_failures +mysql.galera_status.local.commits +mysql.galera_status.local.recv.queue +mysql.galera_status.local.recv.queue_avg +mysql.galera_status.local.recv.queue_max +mysql.galera_status.local.recv.queue_min +mysql.galera_status.local.replays +mysql.galera_status.local.send.queue +mysql.galera_status.local.send.queue_avg +mysql.galera_status.local.send.queue_max +mysql.galera_status.local.send.queue_min +mysql.galera_status.local.state +mysql.galera_status.ready +mysql.galera_status.received.bytes +mysql.galera_status.received.count +mysql.galera_status.repl.bytes +mysql.galera_status.repl.count +mysql.galera_status.repl.data_bytes +mysql.galera_status.repl.keys +mysql.galera_status.repl.keys_bytes +mysql.galera_status.repl.other_bytes +mysql.performance.events_statements.avg.timer.wait +mysql.performance.events_statements.count.star +mysql.performance.events_statements.digest +mysql.performance.events_statements.last.seen +mysql.performance.events_statements.max.timer.wait +mysql.performance.events_statements.quantile.95 +mysql.performance.table_io_waits.count.fetch +mysql.performance.table_io_waits.index.name +mysql.performance.table_io_waits.object.name +mysql.performance.table_io_waits.object.schema +mysql.status.aborted.clients +mysql.status.aborted.connects +mysql.status.binlog.cache.disk_use +mysql.status.binlog.cache.use +mysql.status.bytes.received +mysql.status.bytes.sent +mysql.status.cache.ssl.hits +mysql.status.cache.ssl.misses +mysql.status.cache.ssl.size +mysql.status.cache.table.open_cache.hits +mysql.status.cache.table.open_cache.misses +mysql.status.cache.table.open_cache.overflows +mysql.status.command.delete +mysql.status.command.insert +mysql.status.command.select +mysql.status.command.update +mysql.status.connection.errors.accept +mysql.status.connection.errors.internal +mysql.status.connection.errors.max +mysql.status.connection.errors.peer_address +mysql.status.connection.errors.select +mysql.status.connection.errors.tcpwrap +mysql.status.connections +mysql.status.created.tmp.disk_tables +mysql.status.created.tmp.files +mysql.status.created.tmp.tables +mysql.status.delayed.errors +mysql.status.delayed.insert_threads +mysql.status.delayed.writes +mysql.status.flush_commands +mysql.status.handler.commit +mysql.status.handler.delete +mysql.status.handler.external_lock +mysql.status.handler.mrr_init +mysql.status.handler.prepare +mysql.status.handler.read.first +mysql.status.handler.read.key +mysql.status.handler.read.last +mysql.status.handler.read.next +mysql.status.handler.read.prev +mysql.status.handler.read.rnd +mysql.status.handler.read.rnd_next +mysql.status.handler.rollback +mysql.status.handler.savepoint +mysql.status.handler.savepoint_rollback +mysql.status.handler.update +mysql.status.handler.write +mysql.status.innodb.buffer_pool.bytes.data +mysql.status.innodb.buffer_pool.bytes.dirty +mysql.status.innodb.buffer_pool.dump_status +mysql.status.innodb.buffer_pool.load_status +mysql.status.innodb.buffer_pool.pages.data +mysql.status.innodb.buffer_pool.pages.dirty +mysql.status.innodb.buffer_pool.pages.flushed +mysql.status.innodb.buffer_pool.pages.free +mysql.status.innodb.buffer_pool.pages.latched +mysql.status.innodb.buffer_pool.pages.misc +mysql.status.innodb.buffer_pool.pages.total +mysql.status.innodb.buffer_pool.pool.reads +mysql.status.innodb.buffer_pool.pool.resize_status +mysql.status.innodb.buffer_pool.pool.wait_free +mysql.status.innodb.buffer_pool.read.ahead +mysql.status.innodb.buffer_pool.read.ahead_evicted +mysql.status.innodb.buffer_pool.read.ahead_rnd +mysql.status.innodb.buffer_pool.read.requests +mysql.status.innodb.buffer_pool.write_requests +mysql.status.innodb.rows.deleted +mysql.status.innodb.rows.inserted +mysql.status.innodb.rows.reads +mysql.status.innodb.rows.updated +mysql.status.max_used_connections +mysql.status.open.files +mysql.status.open.streams +mysql.status.open.tables +mysql.status.opened_tables +mysql.status.queries +mysql.status.questions +mysql.status.threads.cached +mysql.status.threads.connected +mysql.status.threads.created +mysql.status.threads.running +nats.connection.idle_time +nats.connection.in.bytes +nats.connection.in.messages +nats.connection.name +nats.connection.out.bytes +nats.connection.out.messages +nats.connection.pending_bytes +nats.connection.subscriptions +nats.connection.uptime +nats.connections.total +nats.route.in.bytes +nats.route.in.messages +nats.route.ip +nats.route.out.bytes +nats.route.out.messages +nats.route.pending_size +nats.route.port +nats.route.remote_id +nats.route.subscriptions +nats.routes.total +nats.server.id +nats.server.time +nats.stats.cores +nats.stats.cpu +nats.stats.http.req_stats.uri.connz +nats.stats.http.req_stats.uri.root +nats.stats.http.req_stats.uri.routez +nats.stats.http.req_stats.uri.subsz +nats.stats.http.req_stats.uri.varz +nats.stats.in.bytes +nats.stats.in.messages +nats.stats.mem.bytes +nats.stats.out.bytes +nats.stats.out.messages +nats.stats.remotes +nats.stats.slow_consumers +nats.stats.total_connections +nats.stats.uptime +nats.subscriptions.cache.fanout.avg +nats.subscriptions.cache.fanout.max +nats.subscriptions.cache.hit_rate +nats.subscriptions.cache.size +nats.subscriptions.inserts +nats.subscriptions.matches +nats.subscriptions.removes +nats.subscriptions.total +network.application +network.bytes +network.community_id +network.direction +network.forwarded_ip +network.iana_number +network.inner.vlan.id +network.inner.vlan.name +network.name +network.packets +network.protocol +network.transport +network.type +network.vlan.id +network.vlan.name +nginx.stubstatus.accepts +nginx.stubstatus.active +nginx.stubstatus.current +nginx.stubstatus.dropped +nginx.stubstatus.handled +nginx.stubstatus.hostname +nginx.stubstatus.reading +nginx.stubstatus.requests +nginx.stubstatus.waiting +nginx.stubstatus.writing +observer.egress.interface.alias +observer.egress.interface.id +observer.egress.interface.name +observer.egress.vlan.id +observer.egress.vlan.name +observer.egress.zone +observer.geo.city_name +observer.geo.continent_name +observer.geo.country_iso_code +observer.geo.country_name +observer.geo.location +observer.geo.name +observer.geo.region_iso_code +observer.geo.region_name +observer.hostname +observer.ingress.interface.alias +observer.ingress.interface.id +observer.ingress.interface.name +observer.ingress.vlan.id +observer.ingress.vlan.name +observer.ingress.zone +observer.ip +observer.mac +observer.name +observer.os.family +observer.os.full +observer.os.full.text +observer.os.kernel +observer.os.name +observer.os.name.text +observer.os.platform +observer.os.version +observer.product +observer.serial_number +observer.type +observer.vendor +observer.version +oracle.performance.buffer_pool +oracle.performance.cache.buffer.hit.pct +oracle.performance.cache.get.consistent +oracle.performance.cache.get.db_blocks +oracle.performance.cache.physical_reads +oracle.performance.cursors.avg +oracle.performance.cursors.cache_hit.pct +oracle.performance.cursors.max +oracle.performance.cursors.opened.current +oracle.performance.cursors.opened.total +oracle.performance.cursors.parse.real +oracle.performance.cursors.parse.total +oracle.performance.cursors.session.cache_hits +oracle.performance.cursors.total +oracle.performance.io_reloads +oracle.performance.lock_requests +oracle.performance.machine +oracle.performance.pin_requests +oracle.performance.username +oracle.tablespace.data_file.id +oracle.tablespace.data_file.name +oracle.tablespace.data_file.online_status +oracle.tablespace.data_file.size.bytes +oracle.tablespace.data_file.size.free.bytes +oracle.tablespace.data_file.size.max.bytes +oracle.tablespace.data_file.status +oracle.tablespace.name +oracle.tablespace.space.free.bytes +oracle.tablespace.space.total.bytes +oracle.tablespace.space.used.bytes +organization.id +organization.name +organization.name.text +os.family +os.full +os.full.text +os.kernel +os.name +os.name.text +os.platform +os.version +package.architecture +package.build_version +package.checksum +package.description +package.install_scope +package.installed +package.license +package.name +package.path +package.reference +package.size +package.type +package.version +pe.company +pe.description +pe.file_version +pe.original_file_name +pe.product +php_fpm.pool.connections.accepted +php_fpm.pool.connections.listen_queue_len +php_fpm.pool.connections.max_listen_queue +php_fpm.pool.connections.queued +php_fpm.pool.name +php_fpm.pool.process_manager +php_fpm.pool.processes.active +php_fpm.pool.processes.idle +php_fpm.pool.processes.max_active +php_fpm.pool.processes.max_children_reached +php_fpm.pool.processes.total +php_fpm.pool.slow_requests +php_fpm.pool.start_since +php_fpm.pool.start_time +php_fpm.process.last_request_cpu +php_fpm.process.last_request_memory +php_fpm.process.request_duration +php_fpm.process.requests +php_fpm.process.script +php_fpm.process.start_since +php_fpm.process.start_time +php_fpm.process.state +postgresql.activity.application_name +postgresql.activity.backend_start +postgresql.activity.client.address +postgresql.activity.client.hostname +postgresql.activity.client.port +postgresql.activity.database.name +postgresql.activity.database.oid +postgresql.activity.pid +postgresql.activity.query +postgresql.activity.query_start +postgresql.activity.state +postgresql.activity.state_change +postgresql.activity.transaction_start +postgresql.activity.user.id +postgresql.activity.user.name +postgresql.activity.waiting +postgresql.bgwriter.buffers.allocated +postgresql.bgwriter.buffers.backend +postgresql.bgwriter.buffers.backend_fsync +postgresql.bgwriter.buffers.checkpoints +postgresql.bgwriter.buffers.clean +postgresql.bgwriter.buffers.clean_full +postgresql.bgwriter.checkpoints.requested +postgresql.bgwriter.checkpoints.scheduled +postgresql.bgwriter.checkpoints.times.sync.ms +postgresql.bgwriter.checkpoints.times.write.ms +postgresql.bgwriter.stats_reset +postgresql.database.blocks.hit +postgresql.database.blocks.read +postgresql.database.blocks.time.read.ms +postgresql.database.blocks.time.write.ms +postgresql.database.conflicts +postgresql.database.deadlocks +postgresql.database.name +postgresql.database.number_of_backends +postgresql.database.oid +postgresql.database.rows.deleted +postgresql.database.rows.fetched +postgresql.database.rows.inserted +postgresql.database.rows.returned +postgresql.database.rows.updated +postgresql.database.stats_reset +postgresql.database.temporary.bytes +postgresql.database.temporary.files +postgresql.database.transactions.commit +postgresql.database.transactions.rollback +postgresql.statement.database.oid +postgresql.statement.query.calls +postgresql.statement.query.id +postgresql.statement.query.memory.local.dirtied +postgresql.statement.query.memory.local.hit +postgresql.statement.query.memory.local.read +postgresql.statement.query.memory.local.written +postgresql.statement.query.memory.shared.dirtied +postgresql.statement.query.memory.shared.hit +postgresql.statement.query.memory.shared.read +postgresql.statement.query.memory.shared.written +postgresql.statement.query.memory.temp.read +postgresql.statement.query.memory.temp.written +postgresql.statement.query.rows +postgresql.statement.query.text +postgresql.statement.query.time.max.ms +postgresql.statement.query.time.mean.ms +postgresql.statement.query.time.min.ms +postgresql.statement.query.time.stddev.ms +postgresql.statement.query.time.total.ms +postgresql.statement.user.id +process.args +process.args_count +process.code_signature.exists +process.code_signature.status +process.code_signature.subject_name +process.code_signature.trusted +process.code_signature.valid +process.command_line +process.command_line.text +process.cpu.pct +process.cpu.start_time +process.entity_id +process.executable +process.executable.text +process.exit_code +process.hash.md5 +process.hash.sha1 +process.hash.sha256 +process.hash.sha512 +process.memory.pct +process.name +process.name.text +process.parent.args +process.parent.args_count +process.parent.code_signature.exists +process.parent.code_signature.status +process.parent.code_signature.subject_name +process.parent.code_signature.trusted +process.parent.code_signature.valid +process.parent.command_line +process.parent.command_line.text +process.parent.entity_id +process.parent.executable +process.parent.executable.text +process.parent.exit_code +process.parent.hash.md5 +process.parent.hash.sha1 +process.parent.hash.sha256 +process.parent.hash.sha512 +process.parent.name +process.parent.name.text +process.parent.pgid +process.parent.pid +process.parent.ppid +process.parent.start +process.parent.thread.id +process.parent.thread.name +process.parent.title +process.parent.title.text +process.parent.uptime +process.parent.working_directory +process.parent.working_directory.text +process.pe.company +process.pe.description +process.pe.file_version +process.pe.original_file_name +process.pe.product +process.pgid +process.pid +process.ppid +process.start +process.state +process.thread.id +process.thread.name +process.title +process.title.text +process.uptime +process.working_directory +process.working_directory.text +rabbitmq.connection.channel_max +rabbitmq.connection.channels +rabbitmq.connection.client_provided.name +rabbitmq.connection.frame_max +rabbitmq.connection.host +rabbitmq.connection.name +rabbitmq.connection.octet_count.received +rabbitmq.connection.octet_count.sent +rabbitmq.connection.packet_count.pending +rabbitmq.connection.packet_count.received +rabbitmq.connection.packet_count.sent +rabbitmq.connection.peer.host +rabbitmq.connection.peer.port +rabbitmq.connection.port +rabbitmq.connection.type +rabbitmq.exchange.auto_delete +rabbitmq.exchange.durable +rabbitmq.exchange.internal +rabbitmq.exchange.messages.publish_in.count +rabbitmq.exchange.messages.publish_in.details.rate +rabbitmq.exchange.messages.publish_out.count +rabbitmq.exchange.messages.publish_out.details.rate +rabbitmq.exchange.name +rabbitmq.node.disk.free.bytes +rabbitmq.node.disk.free.limit.bytes +rabbitmq.node.fd.total +rabbitmq.node.fd.used +rabbitmq.node.gc.num.count +rabbitmq.node.gc.reclaimed.bytes +rabbitmq.node.io.file_handle.open_attempt.avg.ms +rabbitmq.node.io.file_handle.open_attempt.count +rabbitmq.node.io.read.avg.ms +rabbitmq.node.io.read.bytes +rabbitmq.node.io.read.count +rabbitmq.node.io.reopen.count +rabbitmq.node.io.seek.avg.ms +rabbitmq.node.io.seek.count +rabbitmq.node.io.sync.avg.ms +rabbitmq.node.io.sync.count +rabbitmq.node.io.write.avg.ms +rabbitmq.node.io.write.bytes +rabbitmq.node.io.write.count +rabbitmq.node.mem.limit.bytes +rabbitmq.node.mem.used.bytes +rabbitmq.node.mnesia.disk.tx.count +rabbitmq.node.mnesia.ram.tx.count +rabbitmq.node.msg.store_read.count +rabbitmq.node.msg.store_write.count +rabbitmq.node.name +rabbitmq.node.proc.total +rabbitmq.node.proc.used +rabbitmq.node.processors +rabbitmq.node.queue.index.journal_write.count +rabbitmq.node.queue.index.read.count +rabbitmq.node.queue.index.write.count +rabbitmq.node.run.queue +rabbitmq.node.socket.total +rabbitmq.node.socket.used +rabbitmq.node.type +rabbitmq.node.uptime +rabbitmq.queue.arguments.max_priority +rabbitmq.queue.auto_delete +rabbitmq.queue.consumers.count +rabbitmq.queue.consumers.utilisation.pct +rabbitmq.queue.disk.reads.count +rabbitmq.queue.disk.writes.count +rabbitmq.queue.durable +rabbitmq.queue.exclusive +rabbitmq.queue.memory.bytes +rabbitmq.queue.messages.persistent.count +rabbitmq.queue.messages.ready.count +rabbitmq.queue.messages.ready.details.rate +rabbitmq.queue.messages.total.count +rabbitmq.queue.messages.total.details.rate +rabbitmq.queue.messages.unacknowledged.count +rabbitmq.queue.messages.unacknowledged.details.rate +rabbitmq.queue.name +rabbitmq.queue.state +rabbitmq.vhost +redis.info.clients.biggest_input_buf +redis.info.clients.blocked +redis.info.clients.connected +redis.info.clients.longest_output_list +redis.info.clients.max_input_buffer +redis.info.clients.max_output_buffer +redis.info.cluster.enabled +redis.info.cpu.used.sys +redis.info.cpu.used.sys_children +redis.info.cpu.used.user +redis.info.cpu.used.user_children +redis.info.memory.active_defrag.is_running +redis.info.memory.allocator +redis.info.memory.allocator_stats.active +redis.info.memory.allocator_stats.allocated +redis.info.memory.allocator_stats.fragmentation.bytes +redis.info.memory.allocator_stats.fragmentation.ratio +redis.info.memory.allocator_stats.resident +redis.info.memory.allocator_stats.rss.bytes +redis.info.memory.allocator_stats.rss.ratio +redis.info.memory.fragmentation.bytes +redis.info.memory.fragmentation.ratio +redis.info.memory.max.policy +redis.info.memory.max.value +redis.info.memory.used.dataset +redis.info.memory.used.lua +redis.info.memory.used.peak +redis.info.memory.used.rss +redis.info.memory.used.value +redis.info.persistence.aof.bgrewrite.last_status +redis.info.persistence.aof.buffer.size +redis.info.persistence.aof.copy_on_write.last_size +redis.info.persistence.aof.enabled +redis.info.persistence.aof.fsync.delayed +redis.info.persistence.aof.fsync.pending +redis.info.persistence.aof.rewrite.buffer.size +redis.info.persistence.aof.rewrite.current_time.sec +redis.info.persistence.aof.rewrite.in_progress +redis.info.persistence.aof.rewrite.last_time.sec +redis.info.persistence.aof.rewrite.scheduled +redis.info.persistence.aof.size.base +redis.info.persistence.aof.size.current +redis.info.persistence.aof.write.last_status +redis.info.persistence.loading +redis.info.persistence.rdb.bgsave.current_time.sec +redis.info.persistence.rdb.bgsave.in_progress +redis.info.persistence.rdb.bgsave.last_status +redis.info.persistence.rdb.bgsave.last_time.sec +redis.info.persistence.rdb.copy_on_write.last_size +redis.info.persistence.rdb.last_save.changes_since +redis.info.persistence.rdb.last_save.time +redis.info.replication.backlog.active +redis.info.replication.backlog.first_byte_offset +redis.info.replication.backlog.histlen +redis.info.replication.backlog.size +redis.info.replication.connected_slaves +redis.info.replication.master.last_io_seconds_ago +redis.info.replication.master.link_status +redis.info.replication.master.offset +redis.info.replication.master.second_offset +redis.info.replication.master.sync.in_progress +redis.info.replication.master.sync.last_io_seconds_ago +redis.info.replication.master.sync.left_bytes +redis.info.replication.master_offset +redis.info.replication.role +redis.info.replication.slave.is_readonly +redis.info.replication.slave.offset +redis.info.replication.slave.priority +redis.info.server.arch_bits +redis.info.server.build_id +redis.info.server.config_file +redis.info.server.gcc_version +redis.info.server.git_dirty +redis.info.server.git_sha1 +redis.info.server.hz +redis.info.server.lru_clock +redis.info.server.mode +redis.info.server.multiplexing_api +redis.info.server.run_id +redis.info.server.tcp_port +redis.info.server.uptime +redis.info.slowlog.count +redis.info.stats.active_defrag.hits +redis.info.stats.active_defrag.key_hits +redis.info.stats.active_defrag.key_misses +redis.info.stats.active_defrag.misses +redis.info.stats.commands_processed +redis.info.stats.connections.received +redis.info.stats.connections.rejected +redis.info.stats.instantaneous.input_kbps +redis.info.stats.instantaneous.ops_per_sec +redis.info.stats.instantaneous.output_kbps +redis.info.stats.keys.evicted +redis.info.stats.keys.expired +redis.info.stats.keyspace.hits +redis.info.stats.keyspace.misses +redis.info.stats.latest_fork_usec +redis.info.stats.migrate_cached_sockets +redis.info.stats.net.input.bytes +redis.info.stats.net.output.bytes +redis.info.stats.pubsub.channels +redis.info.stats.pubsub.patterns +redis.info.stats.slave_expires_tracked_keys +redis.info.stats.sync.full +redis.info.stats.sync.partial.err +redis.info.stats.sync.partial.ok +redis.key.expire.ttl +redis.key.id +redis.key.length +redis.key.name +redis.key.type +redis.keyspace.avg_ttl +redis.keyspace.expires +redis.keyspace.id +redis.keyspace.keys +registry.data.bytes +registry.data.strings +registry.data.type +registry.hive +registry.key +registry.path +registry.value +related.hash +related.ip +related.user +rule.author +rule.category +rule.description +rule.id +rule.license +rule.name +rule.reference +rule.ruleset +rule.uuid +rule.version +server.address +server.as.number +server.as.organization.name +server.as.organization.name.text +server.bytes +server.domain +server.geo.city_name +server.geo.continent_name +server.geo.country_iso_code +server.geo.country_name +server.geo.location +server.geo.name +server.geo.region_iso_code +server.geo.region_name +server.ip +server.mac +server.nat.ip +server.nat.port +server.packets +server.port +server.registered_domain +server.top_level_domain +server.user.domain +server.user.email +server.user.full_name +server.user.full_name.text +server.user.group.domain +server.user.group.id +server.user.group.name +server.user.hash +server.user.id +server.user.name +server.user.name.text +service.address +service.ephemeral_id +service.hostname +service.id +service.name +service.node.name +service.state +service.type +service.version +source.address +source.as.number +source.as.organization.name +source.as.organization.name.text +source.bytes +source.domain +source.geo.city_name +source.geo.continent_name +source.geo.country_iso_code +source.geo.country_name +source.geo.location +source.geo.name +source.geo.region_iso_code +source.geo.region_name +source.ip +source.mac +source.nat.ip +source.nat.port +source.packets +source.port +source.registered_domain +source.top_level_domain +source.user.domain +source.user.email +source.user.full_name +source.user.full_name.text +source.user.group.domain +source.user.group.id +source.user.group.name +source.user.hash +source.user.id +source.user.name +source.user.name.text +sql.driver +sql.query +stan.channels.bytes +stan.channels.depth +stan.channels.first_seq +stan.channels.last_seq +stan.channels.messages +stan.channels.name +stan.cluster.id +stan.server.id +stan.stats.bytes +stan.stats.channels +stan.stats.clients +stan.stats.messages +stan.stats.role +stan.stats.state +stan.stats.subscriptions +stan.subscriptions.channel +stan.subscriptions.id +stan.subscriptions.last_sent +stan.subscriptions.offline +stan.subscriptions.pending +stan.subscriptions.queue +stan.subscriptions.stalled +system.core.id +system.core.idle.pct +system.core.idle.ticks +system.core.iowait.pct +system.core.iowait.ticks +system.core.irq.pct +system.core.irq.ticks +system.core.nice.pct +system.core.nice.ticks +system.core.softirq.pct +system.core.softirq.ticks +system.core.steal.pct +system.core.steal.ticks +system.core.system.pct +system.core.system.ticks +system.core.user.pct +system.core.user.ticks +system.cpu.cores +system.cpu.idle.norm.pct +system.cpu.idle.pct +system.cpu.idle.ticks +system.cpu.iowait.norm.pct +system.cpu.iowait.pct +system.cpu.iowait.ticks +system.cpu.irq.norm.pct +system.cpu.irq.pct +system.cpu.irq.ticks +system.cpu.nice.norm.pct +system.cpu.nice.pct +system.cpu.nice.ticks +system.cpu.softirq.norm.pct +system.cpu.softirq.pct +system.cpu.softirq.ticks +system.cpu.steal.norm.pct +system.cpu.steal.pct +system.cpu.steal.ticks +system.cpu.system.norm.pct +system.cpu.system.pct +system.cpu.system.ticks +system.cpu.total.norm.pct +system.cpu.total.pct +system.cpu.user.norm.pct +system.cpu.user.pct +system.cpu.user.ticks +system.diskio.io.ops +system.diskio.io.time +system.diskio.iostat.await +system.diskio.iostat.busy +system.diskio.iostat.queue.avg_size +system.diskio.iostat.read.await +system.diskio.iostat.read.per_sec.bytes +system.diskio.iostat.read.request.merges_per_sec +system.diskio.iostat.read.request.per_sec +system.diskio.iostat.request.avg_size +system.diskio.iostat.service_time +system.diskio.iostat.write.await +system.diskio.iostat.write.per_sec.bytes +system.diskio.iostat.write.request.merges_per_sec +system.diskio.iostat.write.request.per_sec +system.diskio.name +system.diskio.read.bytes +system.diskio.read.count +system.diskio.read.time +system.diskio.serial_number +system.diskio.write.bytes +system.diskio.write.count +system.diskio.write.time +system.entropy.available_bits +system.entropy.pct +system.filesystem.available +system.filesystem.device_name +system.filesystem.files +system.filesystem.free +system.filesystem.free_files +system.filesystem.mount_point +system.filesystem.total +system.filesystem.type +system.filesystem.used.bytes +system.filesystem.used.pct +system.fsstat.count +system.fsstat.total_files +system.fsstat.total_size.free +system.fsstat.total_size.total +system.fsstat.total_size.used +system.load.1 +system.load.15 +system.load.5 +system.load.cores +system.load.norm.1 +system.load.norm.15 +system.load.norm.5 +system.memory.actual.free +system.memory.actual.used.bytes +system.memory.actual.used.pct +system.memory.free +system.memory.hugepages.default_size +system.memory.hugepages.free +system.memory.hugepages.reserved +system.memory.hugepages.surplus +system.memory.hugepages.swap.out.fallback +system.memory.hugepages.swap.out.pages +system.memory.hugepages.total +system.memory.hugepages.used.bytes +system.memory.hugepages.used.pct +system.memory.page_stats.direct_efficiency.pct +system.memory.page_stats.kswapd_efficiency.pct +system.memory.page_stats.pgfree.pages +system.memory.page_stats.pgscan_direct.pages +system.memory.page_stats.pgscan_kswapd.pages +system.memory.page_stats.pgsteal_direct.pages +system.memory.page_stats.pgsteal_kswapd.pages +system.memory.swap.free +system.memory.swap.in.pages +system.memory.swap.out.pages +system.memory.swap.readahead.cached +system.memory.swap.readahead.pages +system.memory.swap.total +system.memory.swap.used.bytes +system.memory.swap.used.pct +system.memory.total +system.memory.used.bytes +system.memory.used.pct +system.network.in.bytes +system.network.in.dropped +system.network.in.errors +system.network.in.packets +system.network.name +system.network.out.bytes +system.network.out.dropped +system.network.out.errors +system.network.out.packets +system.process.cgroup.blkio.id +system.process.cgroup.blkio.path +system.process.cgroup.blkio.total.bytes +system.process.cgroup.blkio.total.ios +system.process.cgroup.cpu.cfs.period.us +system.process.cgroup.cpu.cfs.quota.us +system.process.cgroup.cpu.cfs.shares +system.process.cgroup.cpu.id +system.process.cgroup.cpu.path +system.process.cgroup.cpu.rt.period.us +system.process.cgroup.cpu.rt.runtime.us +system.process.cgroup.cpu.stats.periods +system.process.cgroup.cpu.stats.throttled.ns +system.process.cgroup.cpu.stats.throttled.periods +system.process.cgroup.cpuacct.id +system.process.cgroup.cpuacct.path +system.process.cgroup.cpuacct.stats.system.ns +system.process.cgroup.cpuacct.stats.user.ns +system.process.cgroup.cpuacct.total.ns +system.process.cgroup.id +system.process.cgroup.memory.id +system.process.cgroup.memory.kmem.failures +system.process.cgroup.memory.kmem.limit.bytes +system.process.cgroup.memory.kmem.usage.bytes +system.process.cgroup.memory.kmem.usage.max.bytes +system.process.cgroup.memory.kmem_tcp.failures +system.process.cgroup.memory.kmem_tcp.limit.bytes +system.process.cgroup.memory.kmem_tcp.usage.bytes +system.process.cgroup.memory.kmem_tcp.usage.max.bytes +system.process.cgroup.memory.mem.failures +system.process.cgroup.memory.mem.limit.bytes +system.process.cgroup.memory.mem.usage.bytes +system.process.cgroup.memory.mem.usage.max.bytes +system.process.cgroup.memory.memsw.failures +system.process.cgroup.memory.memsw.limit.bytes +system.process.cgroup.memory.memsw.usage.bytes +system.process.cgroup.memory.memsw.usage.max.bytes +system.process.cgroup.memory.path +system.process.cgroup.memory.stats.active_anon.bytes +system.process.cgroup.memory.stats.active_file.bytes +system.process.cgroup.memory.stats.cache.bytes +system.process.cgroup.memory.stats.hierarchical_memory_limit.bytes +system.process.cgroup.memory.stats.hierarchical_memsw_limit.bytes +system.process.cgroup.memory.stats.inactive_anon.bytes +system.process.cgroup.memory.stats.inactive_file.bytes +system.process.cgroup.memory.stats.major_page_faults +system.process.cgroup.memory.stats.mapped_file.bytes +system.process.cgroup.memory.stats.page_faults +system.process.cgroup.memory.stats.pages_in +system.process.cgroup.memory.stats.pages_out +system.process.cgroup.memory.stats.rss.bytes +system.process.cgroup.memory.stats.rss_huge.bytes +system.process.cgroup.memory.stats.swap.bytes +system.process.cgroup.memory.stats.unevictable.bytes +system.process.cgroup.path +system.process.cmdline +system.process.cpu.start_time +system.process.cpu.system.ticks +system.process.cpu.total.norm.pct +system.process.cpu.total.pct +system.process.cpu.total.ticks +system.process.cpu.total.value +system.process.cpu.user.ticks +system.process.fd.limit.hard +system.process.fd.limit.soft +system.process.fd.open +system.process.memory.rss.bytes +system.process.memory.rss.pct +system.process.memory.share +system.process.memory.size +system.process.state +system.process.summary.dead +system.process.summary.idle +system.process.summary.running +system.process.summary.sleeping +system.process.summary.stopped +system.process.summary.total +system.process.summary.unknown +system.process.summary.zombie +system.raid.blocks.synced +system.raid.blocks.total +system.raid.disks.active +system.raid.disks.failed +system.raid.disks.spare +system.raid.disks.total +system.raid.level +system.raid.name +system.raid.status +system.raid.sync_action +system.service.exec_code +system.service.load_state +system.service.name +system.service.resources.cpu.usage.ns +system.service.resources.memory.usage.bytes +system.service.resources.network.in.bytes +system.service.resources.network.in.packets +system.service.resources.network.out.bytes +system.service.resources.network.out.packets +system.service.resources.tasks.count +system.service.state +system.service.state_since +system.service.sub_state +system.service.unit_file.state +system.service.unit_file.vendor_preset +system.socket.local.ip +system.socket.local.port +system.socket.process.cmdline +system.socket.remote.etld_plus_one +system.socket.remote.host +system.socket.remote.host_error +system.socket.remote.ip +system.socket.remote.port +system.socket.summary.all.count +system.socket.summary.all.listening +system.socket.summary.tcp.all.close_wait +system.socket.summary.tcp.all.closing +system.socket.summary.tcp.all.count +system.socket.summary.tcp.all.established +system.socket.summary.tcp.all.fin_wait1 +system.socket.summary.tcp.all.fin_wait2 +system.socket.summary.tcp.all.last_ack +system.socket.summary.tcp.all.listening +system.socket.summary.tcp.all.orphan +system.socket.summary.tcp.all.syn_recv +system.socket.summary.tcp.all.syn_sent +system.socket.summary.tcp.all.time_wait +system.socket.summary.tcp.memory +system.socket.summary.udp.all.count +system.socket.summary.udp.memory +system.uptime.duration.ms +system.users.id +system.users.leader +system.users.path +system.users.remote +system.users.remote_host +system.users.scope +system.users.seat +system.users.service +system.users.state +system.users.type +systemd.fragment_path +systemd.unit +tags +task_stats.cpu.kernel.norm.pct +task_stats.cpu.kernel.pct +task_stats.cpu.kernel.ticks +task_stats.cpu.system.norm.pct +task_stats.cpu.system.pct +task_stats.cpu.system.ticks +task_stats.cpu.total.norm.pct +task_stats.cpu.total.pct +task_stats.cpu.user.norm.pct +task_stats.cpu.user.pct +task_stats.cpu.user.ticks +task_stats.diskio.read.bytes +task_stats.diskio.read.ops +task_stats.diskio.read.queued +task_stats.diskio.read.rate +task_stats.diskio.read.reads +task_stats.diskio.read.service_time +task_stats.diskio.read.summary.bytes +task_stats.diskio.read.summary.ops +task_stats.diskio.read.summary.queued +task_stats.diskio.read.summary.rate +task_stats.diskio.read.summary.service_time +task_stats.diskio.read.summary.wait_time +task_stats.diskio.read.total +task_stats.diskio.read.wait_time +task_stats.diskio.read.write.bytes +task_stats.diskio.read.write.ops +task_stats.diskio.read.write.queued +task_stats.diskio.read.write.rate +task_stats.diskio.read.write.service_time +task_stats.diskio.read.write.wait_time +task_stats.diskio.read.writes +task_stats.identifier +task_stats.network.inbound.bytes +task_stats.network.inbound.dropped +task_stats.network.inbound.errors +task_stats.network.inbound.packets +task_stats.network.interface +task_stats.network.outbound.bytes +task_stats.network.outbound.dropped +task_stats.network.outbound.errors +task_stats.network.outbound.packets +threat.framework +threat.tactic.id +threat.tactic.name +threat.tactic.reference +threat.technique.id +threat.technique.name +threat.technique.name.text +threat.technique.reference +timeseries.instance +tls.cipher +tls.client.certificate +tls.client.certificate_chain +tls.client.hash.md5 +tls.client.hash.sha1 +tls.client.hash.sha256 +tls.client.issuer +tls.client.ja3 +tls.client.not_after +tls.client.not_before +tls.client.server_name +tls.client.subject +tls.client.supported_ciphers +tls.curve +tls.established +tls.next_protocol +tls.resumed +tls.server.certificate +tls.server.certificate_chain +tls.server.hash.md5 +tls.server.hash.sha1 +tls.server.hash.sha256 +tls.server.issuer +tls.server.ja3s +tls.server.not_after +tls.server.not_before +tls.server.subject +tls.version +tls.version_protocol +tomcat.cache.hit.total +tomcat.cache.lookup.total +tomcat.cache.mbean +tomcat.cache.size.max.kb +tomcat.cache.size.total.kb +tomcat.cache.ttl.ms +tomcat.memory.heap.usage.committed +tomcat.memory.heap.usage.init +tomcat.memory.heap.usage.max +tomcat.memory.heap.usage.used +tomcat.memory.mbean +tomcat.memory.other.usage.committed +tomcat.memory.other.usage.init +tomcat.memory.other.usage.max +tomcat.memory.other.usage.used +tomcat.requests.bytes.received +tomcat.requests.bytes.sent +tomcat.requests.errors.total +tomcat.requests.mbean +tomcat.requests.processing.ms +tomcat.requests.total +tomcat.threading.busy +tomcat.threading.cpu.time.ms +tomcat.threading.current +tomcat.threading.keep_alive.timeout.ms +tomcat.threading.keep_alive.total +tomcat.threading.max +tomcat.threading.peak +tomcat.threading.started.total +tomcat.threading.total +tomcat.threading.user.time.ms +tracing.trace.id +tracing.transaction.id +traefik.health.response.avg_time.us +traefik.health.response.count +traefik.health.uptime.sec +type +url.domain +url.extension +url.fragment +url.full +url.full.text +url.original +url.original.text +url.password +url.path +url.port +url.query +url.registered_domain +url.scheme +url.top_level_domain +url.username +user.domain +user.email +user.full_name +user.full_name.text +user.group.domain +user.group.id +user.group.name +user.hash +user.id +user.name +user.name.text +user_agent.device.name +user_agent.name +user_agent.original +user_agent.original.text +user_agent.os.family +user_agent.os.full +user_agent.os.full.text +user_agent.os.kernel +user_agent.os.name +user_agent.os.name.text +user_agent.os.platform +user_agent.os.version +user_agent.version +uwsgi.status.core.id +uwsgi.status.core.read_errors +uwsgi.status.core.requests.offloaded +uwsgi.status.core.requests.routed +uwsgi.status.core.requests.static +uwsgi.status.core.requests.total +uwsgi.status.core.worker_pid +uwsgi.status.core.write_errors +uwsgi.status.total.exceptions +uwsgi.status.total.pid +uwsgi.status.total.read_errors +uwsgi.status.total.requests +uwsgi.status.total.write_errors +uwsgi.status.worker.accepting +uwsgi.status.worker.avg_rt +uwsgi.status.worker.delta_requests +uwsgi.status.worker.exceptions +uwsgi.status.worker.harakiri_count +uwsgi.status.worker.id +uwsgi.status.worker.pid +uwsgi.status.worker.requests +uwsgi.status.worker.respawn_count +uwsgi.status.worker.rss +uwsgi.status.worker.running_time +uwsgi.status.worker.signal_queue +uwsgi.status.worker.signals +uwsgi.status.worker.status +uwsgi.status.worker.tx +uwsgi.status.worker.vsz +vlan.id +vlan.name +vsphere.datastore.capacity.free.bytes +vsphere.datastore.capacity.total.bytes +vsphere.datastore.capacity.used.bytes +vsphere.datastore.capacity.used.pct +vsphere.datastore.fstype +vsphere.datastore.name +vsphere.host.cpu.free.mhz +vsphere.host.cpu.total.mhz +vsphere.host.cpu.used.mhz +vsphere.host.memory.free.bytes +vsphere.host.memory.total.bytes +vsphere.host.memory.used.bytes +vsphere.host.name +vsphere.host.network_names +vsphere.virtualmachine.cpu.used.mhz +vsphere.virtualmachine.host.hostname +vsphere.virtualmachine.host.id +vsphere.virtualmachine.memory.free.guest.bytes +vsphere.virtualmachine.memory.total.guest.bytes +vsphere.virtualmachine.memory.used.guest.bytes +vsphere.virtualmachine.memory.used.host.bytes +vsphere.virtualmachine.name +vsphere.virtualmachine.network_names +vsphere.virtualmachine.os +vulnerability.category +vulnerability.classification +vulnerability.description +vulnerability.description.text +vulnerability.enumeration +vulnerability.id +vulnerability.reference +vulnerability.report_id +vulnerability.scanner.vendor +vulnerability.score.base +vulnerability.score.environmental +vulnerability.score.temporal +vulnerability.score.version +vulnerability.severity +windows.perfmon.instance +windows.service.display_name +windows.service.exit_code +windows.service.id +windows.service.name +windows.service.path_name +windows.service.pid +windows.service.start_name +windows.service.start_type +windows.service.state +windows.service.uptime.ms +zookeeper.connection.interest_ops +zookeeper.connection.queued +zookeeper.connection.received +zookeeper.connection.sent +zookeeper.mntr.approximate_data_size +zookeeper.mntr.ephemerals_count +zookeeper.mntr.followers +zookeeper.mntr.hostname +zookeeper.mntr.latency.avg +zookeeper.mntr.latency.max +zookeeper.mntr.latency.min +zookeeper.mntr.max_file_descriptor_count +zookeeper.mntr.num_alive_connections +zookeeper.mntr.open_file_descriptor_count +zookeeper.mntr.outstanding_requests +zookeeper.mntr.packets.received +zookeeper.mntr.packets.sent +zookeeper.mntr.pending_syncs +zookeeper.mntr.server_state +zookeeper.mntr.synced_followers +zookeeper.mntr.version +zookeeper.mntr.watch_count +zookeeper.mntr.znode_count +zookeeper.server.connections +zookeeper.server.count +zookeeper.server.epoch +zookeeper.server.latency.avg +zookeeper.server.latency.max +zookeeper.server.latency.min +zookeeper.server.mode +zookeeper.server.node_count +zookeeper.server.outstanding +zookeeper.server.received +zookeeper.server.sent +zookeeper.server.version_date +zookeeper.server.zxid