This is an automated email from the ASF dual-hosted git repository. hapylestat pushed a commit to branch branch-2.7 in repository https://gitbox.apache.org/repos/asf/ambari.git
The following commit(s) were added to refs/heads/branch-2.7 by this push: new b13ed67 AMBARI-25402 Please provide jvm metrics for kafka components in Ambari (santal) (#3110) b13ed67 is described below commit b13ed674486e7eeb70cc6f529904b93dbd85dd55 Author: Szilárd Antal <san...@cloudera.com> AuthorDate: Wed Nov 6 13:39:54 2019 +0100 AMBARI-25402 Please provide jvm metrics for kafka components in Ambari (santal) (#3110) AMBARI-25402 Please provide jvm metrics for kafka components in Ambari (santal via dgrinenko) - renamed mxbean variables, removed unused constant - simplified the getThreadMetricNameByState method, created unit test - added license --- .../hadoop/metrics2/sink/kafka/JvmMetricSet.java | 180 ++++++++++++++++ .../sink/kafka/KafkaTimelineMetricsReporter.java | 40 ++-- .../metrics2/sink/kafka/MetricNameBuilder.java | 85 ++++++++ .../metrics2/sink/kafka/JvmMetricSetTest.java | 48 +++++ .../common-services/KAFKA/1.0.1/metainfo.xml | 28 +++ .../common-services/KAFKA/1.0.1/metrics.json | 239 +++++++++++++++++++++ 6 files changed, 602 insertions(+), 18 deletions(-) diff --git a/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSet.java b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSet.java new file mode 100644 index 0000000..72ba380 --- /dev/null +++ b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSet.java @@ -0,0 +1,180 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * <p> + * http://www.apache.org/licenses/LICENSE-2.0 + * <p> + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.metrics2.sink.kafka; + +import java.lang.management.ManagementFactory; +import java.lang.management.MemoryMXBean; +import java.lang.management.RuntimeMXBean; +import java.lang.management.ThreadMXBean; +import java.util.AbstractMap; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import com.yammer.metrics.core.Gauge; +import com.yammer.metrics.core.MetricName; +import com.yammer.metrics.util.RatioGauge; + +public class JvmMetricSet { + + private static final String MEMORY = "memory"; + private static final String THREADS = "threads"; + private static final String RUNTIME = "runtime"; + + private static final JvmMetricSet INSTANCE = new JvmMetricSet(); + + + public static JvmMetricSet getInstance() { + return INSTANCE; + } + + private final MemoryMXBean memoryMXBean; + private final ThreadMXBean threadMXBean; + private final RuntimeMXBean runtimeMXBean; + + private static class JvmMetric { + private final MetricName metricName; + private final Gauge<?> metric; + + JvmMetric(MetricName metricName, Gauge<?> metric) { + this.metricName = metricName; + this.metric = metric; + } + + MetricName getMetricName() { + return metricName; + } + + Gauge<?> getMetric() { + return metric; + } + } + + + private JvmMetricSet() { + this(ManagementFactory.getMemoryMXBean(), ManagementFactory.getThreadMXBean(), + ManagementFactory.getRuntimeMXBean()); + + } + + private JvmMetricSet(MemoryMXBean memoryMXBean, ThreadMXBean threadMXBean, RuntimeMXBean runtimeMXBean) { + this.memoryMXBean = memoryMXBean; + this.threadMXBean = threadMXBean; + this.runtimeMXBean = runtimeMXBean; + } + + public Map<MetricName, Gauge<?>> getJvmMetrics() { + return Stream.concat( + getMemoryUsageMetrics().stream(), + Stream.concat( + getThreadMetrics().stream(), + Stream.of(getRuntimeMetrics()) + )) + .collect(Collectors.toMap(JvmMetric::getMetricName, JvmMetric::getMetric)); + } + + private List<JvmMetric> getMemoryUsageMetrics() { + + return Stream.of( + new AbstractMap.SimpleEntry<>("heap_usage", memoryMXBean.getHeapMemoryUsage()), + new AbstractMap.SimpleEntry<>("non_heap_usage", memoryMXBean.getNonHeapMemoryUsage())) + .map(entry -> + new JvmMetric( + MetricNameBuilder.builder().type(MEMORY).name(entry.getKey()).build(), + new RatioGauge() { + + @Override + protected double getNumerator() { + return entry.getValue().getUsed(); + } + + @Override + protected double getDenominator() { + return entry.getValue().getMax(); + } + } + )) + .collect(Collectors.toList()); + + } + + private List<JvmMetric> getThreadMetrics() { + + return + Stream.concat( + Stream.of( + new JvmMetric( + MetricNameBuilder.builder().type(THREADS).name("thread_count").build(), + new Gauge<Integer>() { + @Override + public Integer value() { + return threadMXBean.getThreadCount(); + } + } + ), + new JvmMetric( + MetricNameBuilder.builder().type(THREADS).name("daemon_thread_count").build(), + new Gauge<Integer>() { + @Override + public Integer value() { + return threadMXBean.getDaemonThreadCount(); + } + } + )), + Stream + .of(Thread.State.RUNNABLE, Thread.State.BLOCKED, Thread.State.TIMED_WAITING, Thread.State.TERMINATED) + .map(state -> new JvmMetric( + MetricNameBuilder.builder().type(THREADS).name(getThreadMetricNameByState(state)).build(), + new Gauge<Long>() { + @Override + public Long value() { + return getThreadCountByState(state); + } + } + ))) + .collect(Collectors.toList()); + } + + private String getThreadMetricNameByState(@Nonnull Thread.State state) { + return String.format("thread-states.%s", state.name().toLowerCase()); + } + + private long getThreadCountByState(@Nonnull Thread.State state) { + return Arrays.stream(threadMXBean.getThreadInfo(threadMXBean.getAllThreadIds(), 0)) + .filter(threadInfo -> threadInfo.getThreadState().equals(state)) + .count(); + } + + private JvmMetric getRuntimeMetrics() { + return new JvmMetric( + MetricNameBuilder.builder().type(RUNTIME).name("uptime").build(), + new Gauge<Long>() { + @Override + public Long value() { + return runtimeMXBean.getUptime(); + } + } + ); + } + +} + + diff --git a/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/KafkaTimelineMetricsReporter.java b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/KafkaTimelineMetricsReporter.java index f07d508..8e10fbc 100644 --- a/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/KafkaTimelineMetricsReporter.java +++ b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/KafkaTimelineMetricsReporter.java @@ -18,6 +18,24 @@ package org.apache.hadoop.metrics2.sink.kafka; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map.Entry; +import java.util.Set; +import java.util.concurrent.TimeUnit; +import org.apache.commons.lang.ArrayUtils; +import org.apache.commons.lang.ClassUtils; +import org.apache.commons.lang.StringUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.metrics2.sink.timeline.AbstractTimelineMetricsSink; +import org.apache.hadoop.metrics2.sink.timeline.TimelineMetric; +import org.apache.hadoop.metrics2.sink.timeline.TimelineMetrics; +import org.apache.hadoop.metrics2.sink.timeline.cache.TimelineMetricsCache; import com.yammer.metrics.Metrics; import com.yammer.metrics.core.Counter; import com.yammer.metrics.core.Gauge; @@ -33,24 +51,6 @@ import com.yammer.metrics.stats.Snapshot; import kafka.metrics.KafkaMetricsConfig; import kafka.metrics.KafkaMetricsReporter; import kafka.utils.VerifiableProperties; -import org.apache.commons.lang.ArrayUtils; -import org.apache.commons.lang.ClassUtils; -import org.apache.commons.lang.StringUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.metrics2.sink.timeline.AbstractTimelineMetricsSink; -import org.apache.hadoop.metrics2.sink.timeline.TimelineMetric; -import org.apache.hadoop.metrics2.sink.timeline.TimelineMetrics; -import org.apache.hadoop.metrics2.sink.timeline.cache.TimelineMetricsCache; -import java.net.InetAddress; -import java.net.UnknownHostException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Map.Entry; -import java.util.Set; -import java.util.concurrent.TimeUnit; import static org.apache.hadoop.metrics2.sink.timeline.TimelineMetricMetadata.MetricType; import static org.apache.hadoop.metrics2.sink.timeline.cache.TimelineMetricsCache.MAX_EVICTION_TIME_MILLIS; import static org.apache.hadoop.metrics2.sink.timeline.cache.TimelineMetricsCache.MAX_RECS_PER_NAME_DEFAULT; @@ -302,6 +302,10 @@ public class KafkaTimelineMetricsReporter extends AbstractTimelineMetricsSink protected TimelineScheduledReporter(MetricsRegistry registry, String name, TimeUnit rateUnit, TimeUnit durationUnit) { super(registry, name, rateUnit, durationUnit); + + JvmMetricSet.getInstance() + .getJvmMetrics() + .forEach(registry::newGauge); } @Override diff --git a/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/MetricNameBuilder.java b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/MetricNameBuilder.java new file mode 100644 index 0000000..3507d2d --- /dev/null +++ b/ambari-metrics/ambari-metrics-kafka-sink/src/main/java/org/apache/hadoop/metrics2/sink/kafka/MetricNameBuilder.java @@ -0,0 +1,85 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.metrics2.sink.kafka; + +import java.util.regex.Pattern; + +import com.yammer.metrics.core.MetricName; + +import static java.util.Optional.ofNullable; + +public class MetricNameBuilder { + private static final Pattern WHITESPACE = Pattern.compile("[\\s]+"); + + private String group = "jvm"; + private String type; + private String name; + + private final String replacement; + + static MetricNameBuilder builder() { + return new MetricNameBuilder(); + } + + MetricNameBuilder() { + this(null); + } + + MetricNameBuilder(String replacement) { + this.replacement = ofNullable(replacement).orElse("_"); + } + + public MetricNameBuilder group(String group) { + this.group = group; + return this; + } + + public MetricNameBuilder type(String type) { + this.type = replaceWhiteSpaces(type); + return this; + } + + public MetricNameBuilder name(String name) { + this.name = ofNullable(this.name).orElse("") + replaceWhiteSpaces(name); + return this; + } + + private String replaceWhiteSpaces(String value) { + return ofNullable(value) + .map(val -> WHITESPACE.matcher(val).replaceAll(replacement)) + .orElse(""); + } + + public MetricName build() { + return new MetricName(this.group, type, name, null, createMBeanName()); + } + + private String createMBeanName() { + final StringBuilder builder = new StringBuilder(); + builder.append(group); + builder.append(":type="); + builder.append(type); + if (name.length() > 0) { + builder.append(",name="); + builder.append(name); + } + return builder.toString(); + } + +} \ No newline at end of file diff --git a/ambari-metrics/ambari-metrics-kafka-sink/src/test/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSetTest.java b/ambari-metrics/ambari-metrics-kafka-sink/src/test/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSetTest.java new file mode 100644 index 0000000..f4c242b --- /dev/null +++ b/ambari-metrics/ambari-metrics-kafka-sink/src/test/java/org/apache/hadoop/metrics2/sink/kafka/JvmMetricSetTest.java @@ -0,0 +1,48 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.metrics2.sink.kafka; + +import java.util.Map; +import org.junit.Test; +import com.yammer.metrics.core.Gauge; +import com.yammer.metrics.core.MetricName; +import static java.util.stream.Collectors.toList; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; +import static org.junit.matchers.JUnitMatchers.hasItems; + +public class JvmMetricSetTest { + + @Test + public void testGetJvmMetrics() { + + Map<MetricName, Gauge<?>> result = JvmMetricSet.getInstance().getJvmMetrics(); + + assertNotNull(result); + assertFalse(result.isEmpty()); + assertThat( + result.keySet() + .stream() + .map(MetricName::getName) + .collect(toList()), + hasItems("heap_usage", "thread-states.blocked", "thread-states.timed_waiting", "uptime")); + } + +} \ No newline at end of file diff --git a/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metainfo.xml b/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metainfo.xml new file mode 100644 index 0000000..7acc35f --- /dev/null +++ b/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metainfo.xml @@ -0,0 +1,28 @@ +<?xml version="1.0"?> +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> +<metainfo> + <schemaVersion>2.0</schemaVersion> + <services> + <service> + <name>KAFKA</name> + <extends>common-services/KAFKA/0.10.0</extends> + <version>1.0.1</version> + <restartRequiredAfterRackChange>true</restartRequiredAfterRackChange> + </service> + </services> +</metainfo> diff --git a/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metrics.json b/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metrics.json new file mode 100644 index 0000000..9056187 --- /dev/null +++ b/ambari-server/src/main/resources/common-services/KAFKA/1.0.1/metrics.json @@ -0,0 +1,239 @@ +{ + "KAFKA_BROKER": { + "Component": [ + { + "type": "ganglia", + "metrics": { + "default": { + "metrics/jvm/uptime": { + "metric": "jvm.runtime.uptime", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/heap_usage": { + "metric": "jvm.memory.heap_usage", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/non_heap_usage": { + "metric": "jvm.memory.non_heap_usage", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/thread-states/runnable": { + "metric": "jvm.threads.thread-states.runnable", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/thread-states/blocked": { + "metric": "jvm.threads.thread-states.blocked", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/thread-states/timed_waiting": { + "metric": "jvm.threads.thread-states.timed_waiting", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/thread-states/terminated": { + "metric": "jvm.threads.thread-states.terminated", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/thread_count": { + "metric": "jvm.threads.thread_count", + "pointInTime": true, + "temporal": true + }, + "metrics/jvm/daemon_thread_count": { + "metric": "jvm.threads.daemon_thread_count", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsMessagesInPerSec/1MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.MessagesInPerSec.1MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsMessagesInPerSec/5MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.MessagesInPerSec.5MinuteRate", + "pointInTime": false, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsMessagesInPerSec/15MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.MessagesInPerSec.15MinuteRate", + "pointInTime": false, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsMessagesInPerSec/meanRate": { + "metric": "kafka.server.BrokerTopicMetrics.MessagesInPerSec.meanRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsMessagesInPerSec/count": { + "metric": "kafka.server.BrokerTopicMetrics.MessagesInPerSec.count", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesInPerSec/1MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesInPerSec.1MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesInPerSec/5MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesInPerSec.5MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesInPerSec/15MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesInPerSec.15MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesInPerSec/meanRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesInPerSec.meanRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesInPerSec/count": { + "metric": "kafka.server.BrokerTopicMetrics.BytesInPerSec.count", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesOutPerSec/1MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesOutPerSec.1MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesOutPerSec/5MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesOutPerSec.5MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesOutPerSec/15MinuteRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesOutPerSec.15MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesOutPerSec/meanRate": { + "metric": "kafka.server.BrokerTopicMetrics.BytesOutPerSec.meanRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/BrokerTopicMetrics/AllTopicsBytesOutPerSec/count": { + "metric": "kafka.server.BrokerTopicMetrics.BytesOutPerSec.count", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/KafkaController/ActiveControllerCount": { + "metric": "kafka.controller.KafkaController.ActiveControllerCount", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/LeaderElectionRateAndTimeMs/meanRate": { + "metric": "kafka.controller.ControllerStats.LeaderElectionRateAndTimeMs.meanRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/LeaderElectionRateAndTimeMs/1MinuteRate": { + "metric": "kafka.controller.ControllerStats.LeaderElectionRateAndTimeMs.1MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/LeaderElectionRateAndTimeMs/5MinuteRate": { + "metric": "kafka.controller.ControllerStats.LeaderElectionRateAndTimeMs.5MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/LeaderElectionRateAndTimeMs/15MinuteRate": { + "metric": "kafka.controller.ControllerStats.LeaderElectionRateAndTimeMs.15MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/LeaderElectionRateAndTimeMs/count": { + "metric": "kafka.controller.ControllerStats.LeaderElectionRateAndTimeMs.count", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/UncleanLeaderElectionsPerSec/1MinuteRate": { + "metric": "kafka.controller.ControllerStats.UncleanLeaderElectionsPerSec.1MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/UncleanLeaderElectionsPerSec/5MinuteRate": { + "metric": "kafka.controller.ControllerStats.UncleanLeaderElectionsPerSec.5MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/UncleanLeaderElectionsPerSec/15MinuteRate": { + "metric": "kafka.controller.ControllerStats.UncleanLeaderElectionsPerSec.15MinuteRate", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/controller/ControllerStats/OfflinePartitionsCount": { + "metric": "kafka.controller.ControllerStats.OfflinePartitionsCount", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ReplicaManager/PartitionCount": { + "metric": "kafka.server.ReplicaManager.PartitionCount", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ReplicaManager/LeaderCount": { + "metric": "kafka.server.ReplicaManager.LeaderCount", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ReplicaManager/UnderReplicatedPartitions": { + "metric": "kafka.server.ReplicaManager.UnderReplicatedPartitions", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ReplicaManager/ISRShrinksPerSec": { + "metric": "kafka.server.ReplicaManager.ISRShrinksPerSec", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ReplicaManager/ISRExpandsPerSec": { + "metric": "kafka.server.ReplicaManager.ISRExpandsPerSec", + "pointInTime": true, + "temporal": true + }, + + "metrics/kafka/server/ReplicaFetcherManager/Replica-MaxLag": { + "metric": "kafka.server.ReplicaFetcherManager.MaxLag.clientId.Replica", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/ProducerRequestPurgatory/PurgatorySize": { + "metric": "kafka.server.ProducerRequestPurgatory.PurgatorySize", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/server/FetchRequestPurgatory/PurgatorySize": { + "metric": "kafka.server.FetchRequestPurgatory.PurgatorySize", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/cluster/Partition/$1-UnderReplicated": { + "metric": "kafka.cluster.Partition.(\\w+)-UnderReplicated", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/consumer/ConsumerFetcherManager/$1-MaxLag": { + "metric": "kafka.consumer.ConsumerFetcherManager.(\\w+)-MaxLag", + "pointInTime": true, + "temporal": true + }, + "metrics/kafka/consumer/ConsumerFetcherManager/$1-MinFetch": { + "metric": "kafka.consumer.ConsumerFetcherManager.(\\w+)-MinFetch", + "pointInTime": true, + "temporal": true + } + } + } + } + ] + } +}