[英]How to get kafka consume lag in java program
我編寫了一個 Java 程序來使用來自 kafka 的消息。 我想監控消費延遲,如何通過java獲取?
順便說一句,我使用:
<groupId>org.apache.kafka</groupId>
<artifactId>kafka_2.11</artifactId>
<version>0.10.1.1</version>
提前致謝。
如果您不想在項目中包含 kafka(和 scala)依賴項,您可以使用下面的類。 它僅使用 kafka-clients 依賴項。
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
public class KafkaConsumerMonitor {
public static class PartionOffsets {
private long endOffset;
private long currentOffset;
private int partion;
private String topic;
public PartionOffsets(long endOffset, long currentOffset, int partion, String topic) {
this.endOffset = endOffset;
this.currentOffset = currentOffset;
this.partion = partion;
this.topic = topic;
}
public long getEndOffset() {
return endOffset;
}
public long getCurrentOffset() {
return currentOffset;
}
public int getPartion() {
return partion;
}
public String getTopic() {
return topic;
}
}
private final String monitoringConsumerGroupID = "monitoring_consumer_" + UUID.randomUUID().toString();
public Map<TopicPartition, PartionOffsets> getConsumerGroupOffsets(String host, String topic, String groupId) {
Map<TopicPartition, Long> logEndOffset = getLogEndOffset(topic, host);
KafkaConsumer consumer = createNewConsumer(groupId, host);
BinaryOperator<PartionOffsets> mergeFunction = (a, b) -> {
throw new IllegalStateException();
};
Map<TopicPartition, PartionOffsets> result = logEndOffset.entrySet()
.stream()
.collect(Collectors.toMap(
entry -> (entry.getKey()),
entry -> {
OffsetAndMetadata committed = consumer.committed(entry.getKey());
return new PartionOffsets(entry.getValue(), committed.offset(), entry.getKey().partition(), topic);
}, mergeFunction));
return result;
}
public Map<TopicPartition, Long> getLogEndOffset(String topic, String host) {
Map<TopicPartition, Long> endOffsets = new ConcurrentHashMap<>();
KafkaConsumer<?, ?> consumer = createNewConsumer(monitoringConsumerGroupID, host);
List<PartitionInfo> partitionInfoList = consumer.partitionsFor(topic);
List<TopicPartition> topicPartitions = partitionInfoList.stream().map(pi -> new TopicPartition(topic, pi.partition())).collect(Collectors.toList());
consumer.assign(topicPartitions);
consumer.seekToEnd(topicPartitions);
topicPartitions.forEach(topicPartition -> endOffsets.put(topicPartition, consumer.position(topicPartition)));
consumer.close();
return endOffsets;
}
private static KafkaConsumer<?, ?> createNewConsumer(String groupId, String host) {
Properties properties = new Properties();
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, host);
properties.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
return new KafkaConsumer<>(properties);
}
}
我個人直接從我的消費者那里查詢 jmx 信息。 我只在 Java 中使用,所以 JMX bean : kafka.consumer:type=consumer-fetch-manager-metrics,client-id=*/records-lag-max
可用。
如果 jolokia 在您的類路徑中,您可以使用/jolokia/read/kafka.consumer:type=consumer-fetch-manager-metrics,client-id=*/records-lag-max
上的 GET 檢索值並收集所有結果在一個地方。
還有Burrow很容易配置,但它有點過時了(如果我沒記錯的話,它不適用於 0.10)。
我正在為我的 api 使用 Spring。 使用下面的代碼,您可以通過 java 獲取指標。代碼有效。
@Component
public class Receiver {
private static final Logger LOGGER =
LoggerFactory.getLogger(Receiver.class);
@Autowired
private KafkaListenerEndpointRegistry kafkaListenerEndpointRegistry;
public void testlag() {
for (MessageListenerContainer messageListenerContainer : kafkaListenerEndpointRegistry
.getListenerContainers()) {
Map<String, Map<MetricName, ? extends Metric>> metrics = messageListenerContainer.metrics();
metrics.forEach( (clientid, metricMap) ->{
System.out.println("------------------------For client id : "+clientid);
metricMap.forEach((metricName,metricValue)->{
//if(metricName.name().contains("lag"))
System.out.println("------------Metric name: "+metricName.name()+"-----------Metric value: "+metricValue.metricValue());
});
});
}
}
您可以在創建消費者時設置 SetStatisticsHandler 回調函數。 比如c#代碼如下
var config = new ConsumerConfig()
{
BootstrapServers = entrypoints,
GroupId = groupid,
EnableAutoCommit = false,
StatisticsIntervalMs=1000 // statistics interval time
};
var consumer = new ConsumerBuilder<Ignore, byte[]>( config )
.SetStatisticsHandler((consumer,json)=> {
logger.LogInformation( json ); // statistics metrics, include consumer lag
} )
.Build();
有關詳細信息,請參閱STATISTICS.md 中的統計指標。
嘗試使用 AdminClient#listGroupOffsets(groupID) 來檢索與消費者組關聯的所有主題分區的偏移量。 例如:
AdminClient client = AdminClient.createSimplePlaintext("localhost:9092");
Map<TopicPartition, Object> offsets = JavaConversions.asJavaMap(
client.listGroupOffsets("groupID"));
Long offset = (Long) offsets.get(new TopicPartition("topic", 0));
...
編輯:
上面的片段顯示了如何獲取給定分區的提交偏移量。 下面的代碼顯示了如何檢索分區的 LEO。
public long getLogEndOffset(TopicPartition tp) {
KafkaConsumer consumer = createNewConsumer();
Collections.singletonList(tp);
consumer.assign(Collections.singletonList(tp));
consumer.seekToEnd(Collections.singletonList(tp));
return consumer.position(tp);
}
private KafkaConsumer<String, String> createNewConsumer() {
Properties properties = new Properties();
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
properties.put(ConsumerConfig.GROUP_ID_CONFIG, "g1");
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
properties.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "30000");
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
return new KafkaConsumer(properties);
}
調用getLogEndOffset
返回給定分區的 LEO,然后從中減去提交的偏移量,結果就是滯后。
供您參考,我使用下面的代碼完成了這項工作。 基本上,您必須通過計算當前提交的偏移量和結束偏移量之間的增量來手動計算每個主題分區的滯后。
private static Map<TopicPartition, Long> lagOf(String brokers, String groupId) {
Properties props = new Properties();
props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, brokers);
try (AdminClient client = AdminClient.create(props)) {
ListConsumerGroupOffsetsResult currentOffsets = client.listConsumerGroupOffsets(groupId);
try {
// get current offsets of consuming topic-partitions
Map<TopicPartition, OffsetAndMetadata> consumedOffsets = currentOffsets.partitionsToOffsetAndMetadata()
.get(3, TimeUnit.SECONDS);
final Map<TopicPartition, Long> result = new HashMap<>();
doWithKafkaConsumer(groupId, brokers, (c) -> {
// get latest offsets of consuming topic-partitions
// lag = latest_offset - current_offset
Map<TopicPartition, Long> endOffsets = c.endOffsets(consumedOffsets.keySet());
result.putAll(endOffsets.entrySet().stream().collect(Collectors.toMap(entry -> entry.getKey(),
entry -> entry.getValue() - consumedOffsets.get(entry.getKey()).offset())));
});
return result;
} catch (InterruptedException | ExecutionException | TimeoutException e) {
log.error("", e);
return Collections.emptyMap();
}
}
}
public static void doWithKafkaConsumer(String groupId, String brokers,
Consumer<KafkaConsumer<String, String>> consumerRunner) {
Properties props = new Properties();
props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, brokers);
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
try (final KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props)) {
consumerRunner.accept(consumer);
}
}
請注意,一個消費者組可能同時消費多個主題,因此如果您需要獲取每個主題的延遲,則必須按主題對結果進行分組和聚合。
Map<TopicPartition, Long> lags = lagOf(brokers, group);
Map<String, Long> topicLag = new HashMap<>();
lags.forEach((tp, lag) -> {
topicLag.compute(tp.topic(), (k, v) -> v == null ? lag : v + lag);
});
運行此獨立代碼。 (依賴於 kafka-clients-2.6.0.jar)
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
public class CosumerGroupLag {
static String host = "localhost:9092";
static String topic = "topic02";
static String groupId = "test-group";
public static void main(String... vj) {
CosumerGroupLag cgl = new CosumerGroupLag();
while (true) {
Map<TopicPartition, PartionOffsets> lag = cgl.getConsumerGroupOffsets(host, topic, groupId);
System.out.println("$$LAG = " + lag);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private final String monitoringConsumerGroupID = "monitoring_consumer_" + UUID.randomUUID().toString();
public Map<TopicPartition, PartionOffsets> getConsumerGroupOffsets(String host, String topic, String groupId) {
Map<TopicPartition, Long> logEndOffset = getLogEndOffset(topic, host);
Set<TopicPartition> topicPartitions = new HashSet<>();
for (Entry<TopicPartition, Long> s : logEndOffset.entrySet()) {
topicPartitions.add(s.getKey());
}
KafkaConsumer<String, Object> consumer = createNewConsumer(groupId, host);
Map<TopicPartition, OffsetAndMetadata> comittedOffsetMeta = consumer.committed(topicPartitions);
BinaryOperator<PartionOffsets> mergeFunction = (a, b) -> {
throw new IllegalStateException();
};
Map<TopicPartition, PartionOffsets> result = logEndOffset.entrySet().stream()
.collect(Collectors.toMap(entry -> (entry.getKey()), entry -> {
OffsetAndMetadata committed = comittedOffsetMeta.get(entry.getKey());
long currentOffset = 0;
if(committed != null) { //committed offset will be null for unknown consumer groups
currentOffset = committed.offset();
}
return new PartionOffsets(entry.getValue(), currentOffset, entry.getKey().partition(), topic);
}, mergeFunction));
return result;
}
public Map<TopicPartition, Long> getLogEndOffset(String topic, String host) {
Map<TopicPartition, Long> endOffsets = new ConcurrentHashMap<>();
KafkaConsumer<?, ?> consumer = createNewConsumer(monitoringConsumerGroupID, host);
List<PartitionInfo> partitionInfoList = consumer.partitionsFor(topic);
List<TopicPartition> topicPartitions = partitionInfoList.stream()
.map(pi -> new TopicPartition(topic, pi.partition())).collect(Collectors.toList());
consumer.assign(topicPartitions);
consumer.seekToEnd(topicPartitions);
topicPartitions.forEach(topicPartition -> endOffsets.put(topicPartition, consumer.position(topicPartition)));
consumer.close();
return endOffsets;
}
private static KafkaConsumer<String, Object> createNewConsumer(String groupId, String host) {
Properties properties = new Properties();
properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, host);
properties.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
return new KafkaConsumer<>(properties);
}
private static class PartionOffsets {
private long lag;
private long timestamp = System.currentTimeMillis();
private long endOffset;
private long currentOffset;
private int partion;
private String topic;
public PartionOffsets(long endOffset, long currentOffset, int partion, String topic) {
this.endOffset = endOffset;
this.currentOffset = currentOffset;
this.partion = partion;
this.topic = topic;
this.lag = endOffset - currentOffset;
}
@Override
public String toString() {
return "PartionOffsets [lag=" + lag + ", timestamp=" + timestamp + ", endOffset=" + endOffset
+ ", currentOffset=" + currentOffset + ", partion=" + partion + ", topic=" + topic + "]";
}
}
}
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.