From afd325bf5d43bc6e01ec15d3a0af2978bc1c0ba7 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Mon, 30 May 2022 15:43:16 -0700
Subject: [PATCH 01/30] add bytes/records consumed/produced metrics

---
 docs/ops.html                                 |  4 +-
 .../processor/internals/ClientUtils.java      | 22 +++++
 .../processor/internals/PartitionGroup.java   |  2 +-
 .../processor/internals/ProcessorNode.java    |  6 +-
 .../processor/internals/RecordCollector.java  | 18 ++--
 .../internals/RecordCollectorImpl.java        | 22 +++--
 .../processor/internals/RecordQueue.java      | 46 ++++-----
 .../streams/processor/internals/SinkNode.java | 32 +++++-
 .../processor/internals/SourceNode.java       |  1 -
 .../processor/internals/StreamTask.java       |  2 +-
 .../metrics/ProcessorNodeMetrics.java         | 99 ++++++++++++++++++-
 .../internals/metrics/TaskMetrics.java        |  6 +-
 .../integration/MetricsIntegrationTest.java   | 18 ++--
 .../metrics/ProcessorNodeMetricsTest.java     |  2 +-
 .../internals/metrics/TaskMetricsTest.java    |  2 +-
 .../state/KeyValueStoreTestDriver.java        | 40 ++++----
 .../kafka/test/MockRecordCollector.java       | 44 +++++----
 17 files changed, 259 insertions(+), 107 deletions(-)

diff --git a/docs/ops.html b/docs/ops.html
index 843c5cc59e375..0c1973bd694a3 100644
--- a/docs/ops.html
+++ b/docs/ops.html
@@ -2308,7 +2308,7 @@ <h4 class="anchor-heading"><a id="connect_monitoring" class="anchor-link"></a><a
   <h4 class="anchor-heading"><a id="kafka_streams_monitoring" class="anchor-link"></a><a href="#kafka_streams_monitoring">Streams Monitoring</a></h4>
 
   A Kafka Streams instance contains all the producer and consumer metrics as well as additional metrics specific to Streams.
-  By default Kafka Streams has metrics with three recording levels: <code>info</code>, <code>debug</code>, and <code>trace</code>.
+  The metrics have three recording levels: <code>info</code>, <code>debug</code>, and <code>trace</code>.
 
   <p>
     Note that the metrics have a 4-layer hierarchy. At the top level there are client-level metrics for each started
@@ -2617,7 +2617,7 @@ <h5 class="anchor-heading"><a id="kafka_streams_node_monitoring" class="anchor-l
  </table>
 
  <h5 class="anchor-heading"><a id="kafka_streams_store_monitoring" class="anchor-link"></a><a href="#kafka_streams_store_monitoring">State Store Metrics</a></h5>
-All of the following metrics have a recording level of <code>debug</code>, except for the record-e2e-latency-* metrics which have a recording level <code>trace></code>.
+All of the following metrics have a recording level of <code>debug</code>, except for the record-e2e-latency-* metrics which have a recording level <code>trace</code>.
 Note that the <code>store-scope</code> value is specified in <code>StoreSupplier#metricsScope()</code> for user's customized state stores;
 for built-in state stores, currently we have:
   <ul>
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index b47b68f8c4aa7..14ea6eeee2769 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -21,12 +21,15 @@
 import org.apache.kafka.clients.admin.OffsetSpec;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.KafkaFuture;
 import org.apache.kafka.common.Metric;
 import org.apache.kafka.common.MetricName;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.errors.TimeoutException;
+import org.apache.kafka.common.header.Header;
+import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.StreamsConfig;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.apache.kafka.streams.processor.TaskId;
@@ -166,4 +169,23 @@ public static String extractThreadId(final String fullThreadName) {
         final int index = fullThreadName.indexOf("StreamThread-");
         return fullThreadName.substring(index);
     }
+
+    public static long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
+        long headerSizeInBytes = 0L;
+
+        for (final Header header: record.headers().toArray()) {
+            headerSizeInBytes += Utils.utf8(header.key()).length;
+            if (header.value() != null) {
+                headerSizeInBytes += header.value().length;
+            }
+        }
+
+        return record.serializedKeySize() +
+            record.serializedValueSize() +
+            8L + // timestamp
+            8L + // offset
+            Utils.utf8(record.topic()).length +
+            4L + // partition
+            headerSizeInBytes;
+    }
 }
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
index dd1257f17984f..18f13e441b6f9 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
@@ -268,7 +268,7 @@ StampedRecord nextRecord(final RecordInfo info, final long wallClockTime) {
             // get the buffer size of queue before poll
             final long oldBufferSize = queue.getTotalBytesBuffered();
             // get the first record from this queue.
-            record = queue.poll();
+            record = queue.poll(wallClockTime);
             // After polling, the buffer size would have reduced.
             final long newBufferSize = queue.getTotalBytesBuffered();
 
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
index d5ecfa7ffe504..61660f8af8efe 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
@@ -40,12 +40,12 @@ public class ProcessorNode<KIn, VIn, KOut, VOut> {
     private final Processor<KIn, VIn, KOut, VOut> processor;
     private final FixedKeyProcessor<KIn, VIn, VOut> fixedKeyProcessor;
     private final String name;
-    private final Time time;
+    protected final Time time;
 
     public final Set<String> stateStores;
 
-    private InternalProcessorContext<KOut, VOut> internalProcessorContext;
-    private String threadId;
+    protected InternalProcessorContext<KOut, VOut> internalProcessorContext;
+    protected String threadId;
 
     private boolean closed = true;
 
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
index 8b22f22f8274e..cc3874d5c542f 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
@@ -26,7 +26,7 @@
 
 public interface RecordCollector {
 
-    <K, V> void send(final String topic,
+    <K, V> int send(final String topic,
                      final K key,
                      final V value,
                      final Headers headers,
@@ -35,14 +35,14 @@ <K, V> void send(final String topic,
                      final Serializer<K> keySerializer,
                      final Serializer<V> valueSerializer);
 
-    <K, V> void send(final String topic,
-                     final K key,
-                     final V value,
-                     final Headers headers,
-                     final Long timestamp,
-                     final Serializer<K> keySerializer,
-                     final Serializer<V> valueSerializer,
-                     final StreamPartitioner<? super K, ? super V> partitioner);
+    <K, V> int send(final String topic,
+                    final K key,
+                    final V value,
+                    final Headers headers,
+                    final Long timestamp,
+                    final Serializer<K> keySerializer,
+                    final Serializer<V> valueSerializer,
+                    final StreamPartitioner<? super K, ? super V> partitioner);
 
     /**
      * Initialize the internal {@link Producer}; note this function should be made idempotent
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index f8c9cf9d7d870..ea9a48c206e7a 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -44,6 +44,7 @@
 import org.apache.kafka.streams.errors.TaskMigratedException;
 import org.apache.kafka.streams.processor.StreamPartitioner;
 import org.apache.kafka.streams.processor.TaskId;
+import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.slf4j.Logger;
@@ -99,14 +100,14 @@ public void initialize() {
      * @throws TaskMigratedException recoverable error that would cause the task to be removed
      */
     @Override
-    public <K, V> void send(final String topic,
-                            final K key,
-                            final V value,
-                            final Headers headers,
-                            final Long timestamp,
-                            final Serializer<K> keySerializer,
-                            final Serializer<V> valueSerializer,
-                            final StreamPartitioner<? super K, ? super V> partitioner) {
+    public <K, V> int send(final String topic,
+                           final K key,
+                           final V value,
+                           final Headers headers,
+                           final Long timestamp,
+                           final Serializer<K> keySerializer,
+                           final Serializer<V> valueSerializer,
+                           final StreamPartitioner<? super K, ? super V> partitioner) {
         final Integer partition;
 
         if (partitioner != null) {
@@ -136,11 +137,11 @@ public <K, V> void send(final String topic,
             partition = null;
         }
 
-        send(topic, key, value, headers, partition, timestamp, keySerializer, valueSerializer);
+        return send(topic, key, value, headers, partition, timestamp, keySerializer, valueSerializer);
     }
 
     @Override
-    public <K, V> void send(final String topic,
+    public <K, V> int send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
@@ -199,6 +200,7 @@ public <K, V> void send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
+        return keyBytes.length + valBytes.length;
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index 90d67a7b0fca0..1d6b61d421402 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -18,12 +18,11 @@
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.header.Header;
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.utils.LogContext;
-import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.errors.DeserializationExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
+import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.apache.kafka.streams.processor.api.ProcessorContext;
 import org.apache.kafka.streams.processor.TimestampExtractor;
@@ -31,6 +30,8 @@
 
 import java.util.ArrayDeque;
 
+import static org.apache.kafka.streams.processor.internals.ClientUtils.sizeInBytes;
+
 /**
  * RecordQueue is a FIFO queue of {@link StampedRecord} (ConsumerRecord + timestamp). It also keeps track of the
  * partition timestamp defined as the largest timestamp seen on the partition so far; this is passed to the
@@ -52,6 +53,8 @@ public class RecordQueue {
     private long partitionTime = UNKNOWN;
 
     private final Sensor droppedRecordsSensor;
+    private final Sensor bytesConsumedSensor;
+    private final Sensor recordsConsumedSensor;
     private long totalBytesBuffered;
     private long headRecordSizeInBytes;
 
@@ -71,6 +74,20 @@ public class RecordQueue {
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
+        bytesConsumedSensor = ProcessorNodeMetrics.bytesConsumedSensor(
+            Thread.currentThread().getName(),
+            processorContext.taskId().toString(),
+            source.name(),
+            partition.topic(),
+            processorContext.metrics()
+        );
+        recordsConsumedSensor = ProcessorNodeMetrics.recordsConsumedSensor(
+            Thread.currentThread().getName(),
+            processorContext.taskId().toString(),
+            source.name(),
+            partition.topic(),
+            processorContext.metrics()
+        );
         recordDeserializer = new RecordDeserializer(
             source,
             deserializationExceptionHandler,
@@ -104,25 +121,6 @@ public TopicPartition partition() {
         return partition;
     }
 
-    private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        long headerSizeInBytes = 0L;
-
-        for (final Header header: record.headers().toArray()) {
-            headerSizeInBytes += Utils.utf8(header.key()).length;
-            if (header.value() != null) {
-                headerSizeInBytes += header.value().length;
-            }
-        }
-
-        return record.serializedKeySize() +
-                record.serializedValueSize() +
-                8L + // timestamp
-                8L + // offset
-                Utils.utf8(record.topic()).length +
-                4L + // partition
-                headerSizeInBytes;
-    }
-
     /**
      * Add a batch of {@link ConsumerRecord} into the queue
      *
@@ -145,8 +143,12 @@ int addRawRecords(final Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) {
      *
      * @return StampedRecord
      */
-    public StampedRecord poll() {
+    public StampedRecord poll(final long wallClockTime) {
         final StampedRecord recordToReturn = headRecord;
+
+        bytesConsumedSensor.record(headRecordSizeInBytes, wallClockTime);
+        recordsConsumedSensor.record(1, wallClockTime);
+
         totalBytesBuffered -= headRecordSizeInBytes;
         headRecord = null;
         headRecordSizeInBytes = 0L;
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index f30e2d2847b70..dbf86c255fb92 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -16,10 +16,12 @@
  */
 package org.apache.kafka.streams.processor.internals;
 
+import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.serialization.Serializer;
 import org.apache.kafka.streams.processor.StreamPartitioner;
 import org.apache.kafka.streams.processor.TopicNameExtractor;
 import org.apache.kafka.streams.processor.api.Record;
+import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareKeySerializer;
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareValueSerializer;
@@ -31,6 +33,9 @@ public class SinkNode<KIn, VIn> extends ProcessorNode<KIn, VIn, Void, Void> {
     private final TopicNameExtractor<KIn, VIn> topicExtractor;
     private final StreamPartitioner<? super KIn, ? super VIn> partitioner;
 
+    private Sensor bytesProducedSensor;
+    private Sensor recordsProducedSensor;
+
     private InternalProcessorContext<Void, Void> context;
 
     SinkNode(final String name,
@@ -56,6 +61,26 @@ public void addChild(final ProcessorNode<Void, Void, ?, ?> child) {
 
     @Override
     public void init(final InternalProcessorContext<Void, Void> context) {
+        // It is important to first create the sensor before calling init on the
+        // parent object. Otherwise due to backwards compatibility an empty sensor
+        // without parent is created with the same name.
+        // Once the backwards compatibility is not needed anymore it might be possible to
+        // change this.
+        bytesProducedSensor = ProcessorNodeMetrics.bytesProducedSensor(
+            threadId,
+            internalProcessorContext.taskId().toString(),
+            name(),
+            context.topic(),
+            context.metrics()
+        );
+        recordsProducedSensor = ProcessorNodeMetrics.recordsProducedSensor(
+            threadId,
+            internalProcessorContext.taskId().toString(),
+            name(),
+            context.topic(),
+            context.metrics()
+        );
+
         super.init(context);
         this.context = context;
         keySerializer = prepareKeySerializer(keySerializer, context, this.name());
@@ -82,7 +107,12 @@ public void process(final Record<KIn, VIn> record) {
 
         final String topic = topicExtractor.extract(key, value, contextForExtraction);
 
-        collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
+        final int bytesProduced =
+            collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
+
+        // Just use the cached system time to avoid the clock lookup
+        bytesProducedSensor.record(bytesProduced, context.currentSystemTimeMs());
+        recordsProducedSensor.record(1, context.currentSystemTimeMs());
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
index 5d0c04b96a89f..81098d8a1b314 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
@@ -78,7 +78,6 @@ public void init(final InternalProcessorContext<KIn, VIn> context) {
         valDeserializer = prepareValueDeserializer(valDeserializer, context, name());
     }
 
-
     @Override
     public void process(final Record<KIn, VIn> record) {
         context.forward(record);
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
index 3e6513cf7be20..b02904a19984c 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
@@ -184,7 +184,7 @@ public StreamTask(final TaskId id,
             createPartitionQueues(),
             mainConsumer::currentLag,
             TaskMetrics.recordLatenessSensor(threadId, taskId, streamsMetrics),
-            TaskMetrics.totalBytesSensor(threadId, taskId, streamsMetrics),
+            TaskMetrics.totalInputBufferBytesSensor(threadId, taskId, streamsMetrics),
             enforcedProcessingSensor,
             maxTaskIdleMs
         );
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 8dcd265a244ac..9087205ca8441 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -36,6 +36,7 @@
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addInvocationRateAndCountToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addRateOfSumAndSumMetricsToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addAvgAndMaxToSensor;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addSumMetricToSensor;
 
 public class ProcessorNodeMetrics {
     private ProcessorNodeMetrics() {}
@@ -61,6 +62,22 @@ private ProcessorNodeMetrics() {}
     private static final String PROCESS_RATE_DESCRIPTION =
         RATE_DESCRIPTION_PREFIX + PROCESS_DESCRIPTION + RATE_DESCRIPTION_SUFFIX;
 
+    private static final String BYTES_CONSUMED = "bytes-consumed";
+    private static final String BYTES_CONSUMED_DESCRIPTION = "bytes consumed from this topic";
+    private static final String BYTES_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_CONSUMED_DESCRIPTION;
+
+    private static final String RECORDS_CONSUMED = "records-consumed";
+    private static final String RECORDS_CONSUMED_DESCRIPTION = "records consumed from this topic";
+    private static final String RECORDS_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_CONSUMED_DESCRIPTION;
+
+    private static final String BYTES_PRODUCED = "bytes-produced";
+    private static final String BYTES_PRODUCED_DESCRIPTION = "bytes produced to this topic";
+    private static final String BYTES_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_PRODUCED_DESCRIPTION;
+
+    private static final String RECORDS_PRODUCED = "records-produced";
+    private static final String RECORDS_PRODUCED_DESCRIPTION = "records produced to this topic";
+    private static final String RECORDS_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_PRODUCED_DESCRIPTION;
+
     private static final String FORWARD = "forward";
     private static final String FORWARD_DESCRIPTION = "calls to forward";
     private static final String FORWARD_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + FORWARD_DESCRIPTION;
@@ -95,9 +112,9 @@ public static Sensor suppressionEmitSensor(final String threadId,
     }
 
     public static Sensor skippedIdempotentUpdatesSensor(final String threadId,
-            final String taskId,
-            final String processorNodeId,
-            final StreamsMetricsImpl streamsMetrics) {
+                                                        final String taskId,
+                                                        final String processorNodeId,
+                                                        final StreamsMetricsImpl streamsMetrics) {
         return throughputSensor(
             threadId,
             taskId,
@@ -136,6 +153,82 @@ public static Sensor processAtSourceSensor(final String threadId,
         );
     }
 
+    public static Sensor bytesConsumedSensor(final String threadId,
+                                             final String taskId,
+                                             final String processorNodeId,
+                                             final String topic,
+                                             final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor =
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_CONSUMED, RecordingLevel.INFO);
+        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        tagMap.put("topic", topic);
+        addSumMetricToSensor(
+            sensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            tagMap,
+            BYTES_CONSUMED,
+            BYTES_CONSUMED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
+    public static Sensor recordsConsumedSensor(final String threadId,
+                                               final String taskId,
+                                               final String processorNodeId,
+                                               final String topic,
+                                               final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor =
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
+        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        tagMap.put("topic", topic);
+        addSumMetricToSensor(
+            sensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            tagMap,
+            RECORDS_CONSUMED,
+            RECORDS_CONSUMED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
+    public static Sensor bytesProducedSensor(final String threadId,
+                                             final String taskId,
+                                             final String processorNodeId,
+                                             final String topic,
+                                             final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor =
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_PRODUCED, RecordingLevel.INFO);
+        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        tagMap.put("topic", topic);
+        addSumMetricToSensor(
+            sensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            tagMap,
+            BYTES_PRODUCED,
+            BYTES_PRODUCED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
+    public static Sensor recordsProducedSensor(final String threadId,
+                                               final String taskId,
+                                               final String processorNodeId,
+                                               final String topic,
+                                               final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor =
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
+        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        tagMap.put("topic", topic);
+        addSumMetricToSensor(
+            sensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            tagMap,
+            RECORDS_PRODUCED,
+            RECORDS_PRODUCED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
     public static Sensor forwardSensor(final String threadId,
                                        final String taskId,
                                        final String processorNodeId,
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetrics.java
index f173bac403991..8949390e7f015 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetrics.java
@@ -133,9 +133,9 @@ public static Sensor activeBufferedRecordsSensor(final String threadId,
         return sensor;
     }
 
-    public static Sensor totalBytesSensor(final String threadId,
-                                          final String taskId,
-                                          final StreamsMetricsImpl streamsMetrics) {
+    public static Sensor totalInputBufferBytesSensor(final String threadId,
+                                                     final String taskId,
+                                                     final StreamsMetricsImpl streamsMetrics) {
         final String name = INPUT_BUFFER_BYTES_TOTAL;
         final Sensor sensor = streamsMetrics.taskLevelSensor(threadId, taskId, name, RecordingLevel.INFO);
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
index 0da0ac9eef603..756544f44ec72 100644
--- a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
@@ -156,10 +156,6 @@ public static void closeCluster() {
     private static final String PROCESS_LATENCY_MAX = "process-latency-max";
     private static final String PUNCTUATE_LATENCY_AVG = "punctuate-latency-avg";
     private static final String PUNCTUATE_LATENCY_MAX = "punctuate-latency-max";
-    private static final String CREATE_LATENCY_AVG = "create-latency-avg";
-    private static final String CREATE_LATENCY_MAX = "create-latency-max";
-    private static final String DESTROY_LATENCY_AVG = "destroy-latency-avg";
-    private static final String DESTROY_LATENCY_MAX = "destroy-latency-max";
     private static final String PROCESS_RATE = "process-rate";
     private static final String PROCESS_TOTAL = "process-total";
     private static final String PROCESS_RATIO = "process-ratio";
@@ -168,12 +164,6 @@ public static void closeCluster() {
     private static final String PUNCTUATE_RATE = "punctuate-rate";
     private static final String PUNCTUATE_TOTAL = "punctuate-total";
     private static final String PUNCTUATE_RATIO = "punctuate-ratio";
-    private static final String CREATE_RATE = "create-rate";
-    private static final String CREATE_TOTAL = "create-total";
-    private static final String DESTROY_RATE = "destroy-rate";
-    private static final String DESTROY_TOTAL = "destroy-total";
-    private static final String FORWARD_TOTAL = "forward-total";
-    private static final String FORWARD_RATE = "forward-rate";
     private static final String STREAM_STRING = "stream";
     private static final String COMMIT_LATENCY_AVG = "commit-latency-avg";
     private static final String COMMIT_LATENCY_MAX = "commit-latency-max";
@@ -217,6 +207,10 @@ public static void closeCluster() {
     private static final String RECORD_E2E_LATENCY_AVG = "record-e2e-latency-avg";
     private static final String RECORD_E2E_LATENCY_MIN = "record-e2e-latency-min";
     private static final String RECORD_E2E_LATENCY_MAX = "record-e2e-latency-max";
+    private static final String BYTES_CONSUMED_TOTAL = "bytes-consumed-total";
+    private static final String RECORDS_CONSUMED_TOTAL = "records-consumed-total";
+    private static final String BYTES_PRODUCED_TOTAL = "bytes-produced-total";
+    private static final String RECORDS_PRODUCED_TOTAL = "records-produced-total";
 
     // stores name
     private static final String TIME_WINDOWED_AGGREGATED_STREAM_STORE = "time-windowed-aggregated-stream-store";
@@ -546,6 +540,10 @@ private void checkProcessorNodeLevelMetrics() {
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_AVG, numberOfSourceNodes + numberOfTerminalNodes);
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_MIN, numberOfSourceNodes + numberOfTerminalNodes);
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_MAX, numberOfSourceNodes + numberOfTerminalNodes);
+        checkMetricByName(listMetricProcessor, BYTES_CONSUMED_TOTAL, numberOfSourceNodes);
+        checkMetricByName(listMetricProcessor, RECORDS_CONSUMED_TOTAL, numberOfSourceNodes);
+        checkMetricByName(listMetricProcessor, BYTES_PRODUCED_TOTAL, numberOfTerminalNodes);
+        checkMetricByName(listMetricProcessor, RECORDS_PRODUCED_TOTAL, numberOfTerminalNodes);
     }
 
     private void checkKeyValueStoreMetrics(final String tagKey) {
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
index 0ae1a99e6f53a..b448e0aca93d3 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
@@ -111,7 +111,7 @@ public void shouldGetProcessAtSourceSensor() {
                 expectedParentSensor
         );
 
-        verifySensor(() -> ProcessorNodeMetrics.processAtSourceSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, streamsMetrics));
+        verifySensor(() -> ProcessorNodeMetrics.recordsProcessedAtSourceSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, streamsMetrics));
     }
 
     @Test
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetricsTest.java
index cababb1c3190b..9f697759b7dfb 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TaskMetricsTest.java
@@ -100,7 +100,7 @@ public void shouldGetTotalBytesSensor() {
         );
 
 
-        final Sensor sensor = TaskMetrics.totalBytesSensor(THREAD_ID, TASK_ID, streamsMetrics);
+        final Sensor sensor = TaskMetrics.totalInputBufferBytesSensor(THREAD_ID, TASK_ID, streamsMetrics);
 
         assertThat(sensor, is(expectedSensor));
     }
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 6a95ccbd08a2a..67391801e3340 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -215,31 +215,35 @@ private KeyValueStoreTestDriver(final StateSerdes<K, V> serdes) {
             new MockStreamsMetrics(new Metrics())
         ) {
             @Override
-            public <K1, V1> void send(final String topic,
-                                      final K1 key,
-                                      final V1 value,
-                                      final Headers headers,
-                                      final Integer partition,
-                                      final Long timestamp,
-                                      final Serializer<K1> keySerializer,
-                                      final Serializer<V1> valueSerializer) {
+            public <K1, V1> int send(final String topic,
+                                     final K1 key,
+                                     final V1 value,
+                                     final Headers headers,
+                                     final Integer partition,
+                                     final Long timestamp,
+                                     final Serializer<K1> keySerializer,
+                                     final Serializer<V1> valueSerializer) {
                 // for byte arrays we need to wrap it for comparison
 
-                final K keyTest = serdes.keyFrom(keySerializer.serialize(topic, headers, key));
-                final V valueTest = serdes.valueFrom(valueSerializer.serialize(topic, headers, value));
+                final byte[] keyBytes = keySerializer.serialize(topic, headers, key);
+                final byte[] valueBytes = valueSerializer.serialize(topic, headers, value);
+
+                final K keyTest = serdes.keyFrom(keyBytes);
+                final V valueTest = serdes.valueFrom(valueBytes);
 
                 recordFlushed(keyTest, valueTest);
+                return keyBytes.length + valueBytes.length;
             }
 
             @Override
-            public <K1, V1> void send(final String topic,
-                                      final K1 key,
-                                      final V1 value,
-                                      final Headers headers,
-                                      final Long timestamp,
-                                      final Serializer<K1> keySerializer,
-                                      final Serializer<V1> valueSerializer,
-                                      final StreamPartitioner<? super K1, ? super V1> partitioner) {
+            public <K1, V1> int send(final String topic,
+                                     final K1 key,
+                                     final V1 value,
+                                     final Headers headers,
+                                     final Long timestamp,
+                                     final Serializer<K1> keySerializer,
+                                     final Serializer<V1> valueSerializer,
+                                     final StreamPartitioner<? super K1, ? super V1> partitioner) {
                 throw new UnsupportedOperationException();
             }
         };
diff --git a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
index 505ee6858a7cd..3476e97e7c262 100644
--- a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
+++ b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
@@ -39,37 +39,39 @@ public class MockRecordCollector implements RecordCollector {
     private boolean flushed = false;
 
     @Override
-    public <K, V> void send(final String topic,
-                            final K key,
-                            final V value,
-                            final Headers headers,
-                            final Integer partition,
-                            final Long timestamp,
-                            final Serializer<K> keySerializer,
-                            final Serializer<V> valueSerializer) {
+    public <K, V> int send(final String topic,
+                           final K key,
+                           final V value,
+                           final Headers headers,
+                           final Integer partition,
+                           final Long timestamp,
+                           final Serializer<K> keySerializer,
+                           final Serializer<V> valueSerializer) {
         collected.add(new ProducerRecord<>(topic,
-            partition,
-            timestamp,
-            key,
-            value,
-            headers));
+                                           partition,
+                                           timestamp,
+                                           key,
+                                           value,
+                                           headers));
+        return 0;
     }
 
     @Override
-    public <K, V> void send(final String topic,
-                            final K key,
-                            final V value,
-                            final Headers headers,
-                            final Long timestamp,
-                            final Serializer<K> keySerializer,
-                            final Serializer<V> valueSerializer,
-                            final StreamPartitioner<? super K, ? super V> partitioner) {
+    public <K, V> int send(final String topic,
+                           final K key,
+                           final V value,
+                           final Headers headers,
+                           final Long timestamp,
+                           final Serializer<K> keySerializer,
+                           final Serializer<V> valueSerializer,
+                           final StreamPartitioner<? super K, ? super V> partitioner) {
         collected.add(new ProducerRecord<>(topic,
             0, // partition id
             timestamp,
             key,
             value,
             headers));
+        return 0;
     }
 
     @Override

From 6ab8c5442a1cee9bd30a1acfc00a7f68d43907fe Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 05:24:21 -0700
Subject: [PATCH 02/30] checkstyle

---
 .../kafka/streams/processor/internals/RecordCollectorImpl.java   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index ea9a48c206e7a..571c90d1cac70 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -44,7 +44,6 @@
 import org.apache.kafka.streams.errors.TaskMigratedException;
 import org.apache.kafka.streams.processor.StreamPartitioner;
 import org.apache.kafka.streams.processor.TaskId;
-import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.slf4j.Logger;

From 6a4eb80b2482891be78d7de6bacd9da1ef711f83 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 05:27:02 -0700
Subject: [PATCH 03/30] undo backed out changes

---
 .../processor/internals/ClientUtils.java      | 19 --------
 .../processor/internals/RecordQueue.java      | 46 +++++++++----------
 2 files changed, 22 insertions(+), 43 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index 14ea6eeee2769..b9f325efaf02a 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -169,23 +169,4 @@ public static String extractThreadId(final String fullThreadName) {
         final int index = fullThreadName.indexOf("StreamThread-");
         return fullThreadName.substring(index);
     }
-
-    public static long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        long headerSizeInBytes = 0L;
-
-        for (final Header header: record.headers().toArray()) {
-            headerSizeInBytes += Utils.utf8(header.key()).length;
-            if (header.value() != null) {
-                headerSizeInBytes += header.value().length;
-            }
-        }
-
-        return record.serializedKeySize() +
-            record.serializedValueSize() +
-            8L + // timestamp
-            8L + // offset
-            Utils.utf8(record.topic()).length +
-            4L + // partition
-            headerSizeInBytes;
-    }
 }
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index 1d6b61d421402..90d67a7b0fca0 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -18,11 +18,12 @@
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.header.Header;
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.utils.LogContext;
+import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.errors.DeserializationExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
-import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.apache.kafka.streams.processor.api.ProcessorContext;
 import org.apache.kafka.streams.processor.TimestampExtractor;
@@ -30,8 +31,6 @@
 
 import java.util.ArrayDeque;
 
-import static org.apache.kafka.streams.processor.internals.ClientUtils.sizeInBytes;
-
 /**
  * RecordQueue is a FIFO queue of {@link StampedRecord} (ConsumerRecord + timestamp). It also keeps track of the
  * partition timestamp defined as the largest timestamp seen on the partition so far; this is passed to the
@@ -53,8 +52,6 @@ public class RecordQueue {
     private long partitionTime = UNKNOWN;
 
     private final Sensor droppedRecordsSensor;
-    private final Sensor bytesConsumedSensor;
-    private final Sensor recordsConsumedSensor;
     private long totalBytesBuffered;
     private long headRecordSizeInBytes;
 
@@ -74,20 +71,6 @@ public class RecordQueue {
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
-        bytesConsumedSensor = ProcessorNodeMetrics.bytesConsumedSensor(
-            Thread.currentThread().getName(),
-            processorContext.taskId().toString(),
-            source.name(),
-            partition.topic(),
-            processorContext.metrics()
-        );
-        recordsConsumedSensor = ProcessorNodeMetrics.recordsConsumedSensor(
-            Thread.currentThread().getName(),
-            processorContext.taskId().toString(),
-            source.name(),
-            partition.topic(),
-            processorContext.metrics()
-        );
         recordDeserializer = new RecordDeserializer(
             source,
             deserializationExceptionHandler,
@@ -121,6 +104,25 @@ public TopicPartition partition() {
         return partition;
     }
 
+    private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
+        long headerSizeInBytes = 0L;
+
+        for (final Header header: record.headers().toArray()) {
+            headerSizeInBytes += Utils.utf8(header.key()).length;
+            if (header.value() != null) {
+                headerSizeInBytes += header.value().length;
+            }
+        }
+
+        return record.serializedKeySize() +
+                record.serializedValueSize() +
+                8L + // timestamp
+                8L + // offset
+                Utils.utf8(record.topic()).length +
+                4L + // partition
+                headerSizeInBytes;
+    }
+
     /**
      * Add a batch of {@link ConsumerRecord} into the queue
      *
@@ -143,12 +145,8 @@ int addRawRecords(final Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) {
      *
      * @return StampedRecord
      */
-    public StampedRecord poll(final long wallClockTime) {
+    public StampedRecord poll() {
         final StampedRecord recordToReturn = headRecord;
-
-        bytesConsumedSensor.record(headRecordSizeInBytes, wallClockTime);
-        recordsConsumedSensor.record(1, wallClockTime);
-
         totalBytesBuffered -= headRecordSizeInBytes;
         headRecord = null;
         headRecordSizeInBytes = 0L;

From f69fa86161476f628ac18acf38a34477329bbdb5 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 05:32:51 -0700
Subject: [PATCH 04/30] reapply sensor recordings

---
 .../processor/internals/RecordQueue.java      | 23 ++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index 90d67a7b0fca0..d6f419cfcbe9e 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -24,6 +24,7 @@
 import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.errors.DeserializationExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
+import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.apache.kafka.streams.processor.api.ProcessorContext;
 import org.apache.kafka.streams.processor.TimestampExtractor;
@@ -52,6 +53,8 @@ public class RecordQueue {
     private long partitionTime = UNKNOWN;
 
     private final Sensor droppedRecordsSensor;
+    private final Sensor bytesConsumedSensor;
+    private final Sensor recordsConsumedSensor;
     private long totalBytesBuffered;
     private long headRecordSizeInBytes;
 
@@ -71,6 +74,20 @@ public class RecordQueue {
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
+        bytesConsumedSensor = ProcessorNodeMetrics.bytesConsumedSensor(
+            Thread.currentThread().getName(),
+            processorContext.taskId().toString(),
+            source.name(),
+            partition.topic(),
+            processorContext.metrics()
+        );
+        recordsConsumedSensor = ProcessorNodeMetrics.recordsConsumedSensor(
+            Thread.currentThread().getName(),
+            processorContext.taskId().toString(),
+            source.name(),
+            partition.topic(),
+            processorContext.metrics()
+        );
         recordDeserializer = new RecordDeserializer(
             source,
             deserializationExceptionHandler,
@@ -145,8 +162,12 @@ int addRawRecords(final Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) {
      *
      * @return StampedRecord
      */
-    public StampedRecord poll() {
+    public StampedRecord poll(final long wallClockTime) {
         final StampedRecord recordToReturn = headRecord;
+
+        bytesConsumedSensor.record(headRecordSizeInBytes, wallClockTime);
+        recordsConsumedSensor.record(1, wallClockTime);
+
         totalBytesBuffered -= headRecordSizeInBytes;
         headRecord = null;
         headRecordSizeInBytes = 0L;

From 70da1e226d6d7f25262764ba5f96c8d90f5adc98 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 05:41:06 -0700
Subject: [PATCH 05/30] more checkstyle

---
 .../apache/kafka/streams/processor/internals/ClientUtils.java  | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index b9f325efaf02a..b47b68f8c4aa7 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -21,15 +21,12 @@
 import org.apache.kafka.clients.admin.OffsetSpec;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.ConsumerConfig;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.KafkaFuture;
 import org.apache.kafka.common.Metric;
 import org.apache.kafka.common.MetricName;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.errors.TimeoutException;
-import org.apache.kafka.common.header.Header;
-import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.StreamsConfig;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.apache.kafka.streams.processor.TaskId;

From c89d21b796f54bbcdc3cfeaac76acb46eff155c7 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 16:15:42 -0700
Subject: [PATCH 06/30] review feedback

---
 .../processor/internals/ProcessorNode.java    |  6 +-
 .../processor/internals/RecordQueue.java      |  8 +-
 .../streams/processor/internals/SinkNode.java | 15 +--
 .../processor/internals/SourceNode.java       |  1 +
 .../processor/internals/RecordQueueTest.java  | 34 +++----
 .../metrics/ProcessorNodeMetricsTest.java     | 92 ++++++++++++++++++-
 6 files changed, 122 insertions(+), 34 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
index 61660f8af8efe..d5ecfa7ffe504 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorNode.java
@@ -40,12 +40,12 @@ public class ProcessorNode<KIn, VIn, KOut, VOut> {
     private final Processor<KIn, VIn, KOut, VOut> processor;
     private final FixedKeyProcessor<KIn, VIn, VOut> fixedKeyProcessor;
     private final String name;
-    protected final Time time;
+    private final Time time;
 
     public final Set<String> stateStores;
 
-    protected InternalProcessorContext<KOut, VOut> internalProcessorContext;
-    protected String threadId;
+    private InternalProcessorContext<KOut, VOut> internalProcessorContext;
+    private String threadId;
 
     private boolean closed = true;
 
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index d6f419cfcbe9e..b7caf76b976a0 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -69,20 +69,22 @@ public class RecordQueue {
         this.fifoQueue = new ArrayDeque<>();
         this.timestampExtractor = timestampExtractor;
         this.processorContext = processorContext;
+
+        final String threadName = Thread.currentThread().getName();
         droppedRecordsSensor = TaskMetrics.droppedRecordsSensor(
-            Thread.currentThread().getName(),
+            threadName,
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
         bytesConsumedSensor = ProcessorNodeMetrics.bytesConsumedSensor(
-            Thread.currentThread().getName(),
+            threadName,
             processorContext.taskId().toString(),
             source.name(),
             partition.topic(),
             processorContext.metrics()
         );
         recordsConsumedSensor = ProcessorNodeMetrics.recordsConsumedSensor(
-            Thread.currentThread().getName(),
+            threadName,
             processorContext.taskId().toString(),
             source.name(),
             partition.topic(),
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index dbf86c255fb92..e8d5430fa6a48 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -61,21 +61,17 @@ public void addChild(final ProcessorNode<Void, Void, ?, ?> child) {
 
     @Override
     public void init(final InternalProcessorContext<Void, Void> context) {
-        // It is important to first create the sensor before calling init on the
-        // parent object. Otherwise due to backwards compatibility an empty sensor
-        // without parent is created with the same name.
-        // Once the backwards compatibility is not needed anymore it might be possible to
-        // change this.
+        final String threadName = Thread.currentThread().getName();
         bytesProducedSensor = ProcessorNodeMetrics.bytesProducedSensor(
-            threadId,
-            internalProcessorContext.taskId().toString(),
+            threadName,
+            context.taskId().toString(),
             name(),
             context.topic(),
             context.metrics()
         );
         recordsProducedSensor = ProcessorNodeMetrics.recordsProducedSensor(
-            threadId,
-            internalProcessorContext.taskId().toString(),
+            threadName,
+            context.taskId().toString(),
             name(),
             context.topic(),
             context.metrics()
@@ -110,7 +106,6 @@ public void process(final Record<KIn, VIn> record) {
         final int bytesProduced =
             collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
 
-        // Just use the cached system time to avoid the clock lookup
         bytesProducedSensor.record(bytesProduced, context.currentSystemTimeMs());
         recordsProducedSensor.record(1, context.currentSystemTimeMs());
     }
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
index 81098d8a1b314..5d0c04b96a89f 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SourceNode.java
@@ -78,6 +78,7 @@ public void init(final InternalProcessorContext<KIn, VIn> context) {
         valDeserializer = prepareValueDeserializer(valDeserializer, context, name());
     }
 
+
     @Override
     public void process(final Record<KIn, VIn> record) {
         context.forward(record);
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
index bea7a057003dc..efb42c0c28006 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
@@ -118,13 +118,13 @@ public void testTimeTracking() {
         assertEquals(2L, queue.headRecordOffset().longValue());
 
         // poll the first record, now with 1, 3
-        assertEquals(2L, queue.poll().timestamp);
+        assertEquals(2L, queue.poll(0).timestamp);
         assertEquals(2, queue.size());
         assertEquals(1L, queue.headRecordTimestamp());
         assertEquals(1L, queue.headRecordOffset().longValue());
 
         // poll the second record, now with 3
-        assertEquals(1L, queue.poll().timestamp);
+        assertEquals(1L, queue.poll(0).timestamp);
         assertEquals(1, queue.size());
         assertEquals(3L, queue.headRecordTimestamp());
         assertEquals(3L, queue.headRecordOffset().longValue());
@@ -143,21 +143,21 @@ public void testTimeTracking() {
         assertEquals(3L, queue.headRecordOffset().longValue());
 
         // poll the third record, now with 4, 1, 2
-        assertEquals(3L, queue.poll().timestamp);
+        assertEquals(3L, queue.poll(0).timestamp);
         assertEquals(3, queue.size());
         assertEquals(4L, queue.headRecordTimestamp());
         assertEquals(4L, queue.headRecordOffset().longValue());
 
         // poll the rest records
-        assertEquals(4L, queue.poll().timestamp);
+        assertEquals(4L, queue.poll(0).timestamp);
         assertEquals(1L, queue.headRecordTimestamp());
         assertEquals(1L, queue.headRecordOffset().longValue());
 
-        assertEquals(1L, queue.poll().timestamp);
+        assertEquals(1L, queue.poll(0).timestamp);
         assertEquals(2L, queue.headRecordTimestamp());
         assertEquals(2L, queue.headRecordOffset().longValue());
 
-        assertEquals(2L, queue.poll().timestamp);
+        assertEquals(2L, queue.poll(0).timestamp);
         assertTrue(queue.isEmpty());
         assertEquals(0, queue.size());
         assertEquals(RecordQueue.UNKNOWN, queue.headRecordTimestamp());
@@ -176,7 +176,7 @@ public void testTimeTracking() {
         assertEquals(4L, queue.headRecordOffset().longValue());
 
         // poll one record again, the timestamp should advance now
-        assertEquals(4L, queue.poll().timestamp);
+        assertEquals(4L, queue.poll(0).timestamp);
         assertEquals(2, queue.size());
         assertEquals(5L, queue.headRecordTimestamp());
         assertEquals(5L, queue.headRecordOffset().longValue());
@@ -218,13 +218,13 @@ public void shouldTrackPartitionTimeAsMaxProcessedTimestamp() {
         queue.addRawRecords(list1);
         assertThat(queue.partitionTime(), is(RecordQueue.UNKNOWN));
 
-        queue.poll();
+        queue.poll(0);
         assertThat(queue.partitionTime(), is(2L));
 
-        queue.poll();
+        queue.poll(0);
         assertThat(queue.partitionTime(), is(2L));
 
-        queue.poll();
+        queue.poll(0);
         assertThat(queue.partitionTime(), is(3L));
     }
 
@@ -251,13 +251,13 @@ public void shouldSetTimestampAndRespectMaxTimestampPolicy() {
         queue.addRawRecords(list1);
         assertThat(queue.partitionTime(), is(150L));
 
-        queue.poll();
+        queue.poll(0);
         assertThat(queue.partitionTime(), is(200L));
 
         queue.setPartitionTime(500L);
         assertThat(queue.partitionTime(), is(500L));
 
-        queue.poll();
+        queue.poll(0);
         assertThat(queue.partitionTime(), is(500L));
     }
 
@@ -299,7 +299,7 @@ public void shouldNotThrowStreamsExceptionWhenKeyDeserializationFailsWithSkipHan
 
         queueThatSkipsDeserializeErrors.addRawRecords(records);
         assertEquals(1, queueThatSkipsDeserializeErrors.size());
-        assertEquals(new CorruptedRecord(record), queueThatSkipsDeserializeErrors.poll());
+        assertEquals(new CorruptedRecord(record), queueThatSkipsDeserializeErrors.poll(0));
     }
 
     @Test
@@ -313,7 +313,7 @@ public void shouldNotThrowStreamsExceptionWhenValueDeserializationFailsWithSkipH
 
         queueThatSkipsDeserializeErrors.addRawRecords(records);
         assertEquals(1, queueThatSkipsDeserializeErrors.size());
-        assertEquals(new CorruptedRecord(record), queueThatSkipsDeserializeErrors.poll());
+        assertEquals(new CorruptedRecord(record), queueThatSkipsDeserializeErrors.poll(0));
     }
 
     @Test
@@ -394,13 +394,13 @@ public void shouldPassPartitionTimeToTimestampExtractor() {
         // no (known) timestamp has yet been passed to the timestamp extractor
         assertEquals(RecordQueue.UNKNOWN, timestampExtractor.partitionTime);
 
-        queue.poll();
+        queue.poll(0);
         assertEquals(2L, timestampExtractor.partitionTime);
 
-        queue.poll();
+        queue.poll(0);
         assertEquals(2L, timestampExtractor.partitionTime);
 
-        queue.poll();
+        queue.poll(0);
         assertEquals(3L, timestampExtractor.partitionTime);
 
     }
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
index b448e0aca93d3..0889ab9b06379 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
@@ -24,6 +24,7 @@
 
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Supplier;
 
@@ -36,6 +37,7 @@ public class ProcessorNodeMetricsTest {
     private static final String THREAD_ID = "test-thread";
     private static final String TASK_ID = "test-task";
     private static final String PROCESSOR_NODE_ID = "test-processor";
+    private static final String TOPIC_NAME = "topic";
 
     private final Map<String, String> tagMap = Collections.singletonMap("hello", "world");
     private final Map<String, String> parentTagMap = Collections.singletonMap("hi", "universe");
@@ -111,7 +113,95 @@ public void shouldGetProcessAtSourceSensor() {
                 expectedParentSensor
         );
 
-        verifySensor(() -> ProcessorNodeMetrics.recordsProcessedAtSourceSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, streamsMetrics));
+        verifySensor(() -> ProcessorNodeMetrics.processAtSourceSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, streamsMetrics));
+    }
+
+    @Test
+    public void shouldGetBytesConsumedSensor() {
+        final String metricNamePrefix = "bytes-consumed";
+        final String descriptionOfTotal = "The total number of bytes consumed from this topic";
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
+
+        final Map<String, String> bytesConsumedTagMap = new HashMap<>(tagMap);
+        bytesConsumedTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addSumMetricToSensor(
+            expectedSensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            bytesConsumedTagMap,
+            metricNamePrefix,
+            descriptionOfTotal
+        );
+        verifySensor(
+            () -> ProcessorNodeMetrics.bytesConsumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+        );
+    }
+
+    @Test
+    public void shouldGetRecordsConsumedSensor() {
+        final String metricNamePrefix = "records-consumed";
+        final String descriptionOfTotal = "The total number of records consumed from this topic";
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
+
+        final Map<String, String> recordsConsumedTagMap = new HashMap<>(tagMap);
+        recordsConsumedTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addSumMetricToSensor(
+            expectedSensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            recordsConsumedTagMap,
+            metricNamePrefix,
+            descriptionOfTotal
+        );
+        verifySensor(
+            () -> ProcessorNodeMetrics.recordsConsumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+        );
+    }
+
+    @Test
+    public void shouldGetBytesProducedSensor() {
+        final String metricNamePrefix = "bytes-produced";
+        final String descriptionOfTotal = "The total number of bytes produced to this topic";
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
+
+        final Map<String, String> bytesProducedTagMap = new HashMap<>(tagMap);
+        bytesProducedTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addSumMetricToSensor(
+            expectedSensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            bytesProducedTagMap,
+            metricNamePrefix,
+            descriptionOfTotal
+        );
+        verifySensor(
+            () -> ProcessorNodeMetrics.bytesProducedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+        );
+    }
+
+    @Test
+    public void shouldGetRecordsProducedSensor() {
+        final String metricNamePrefix = "bytes-produced";
+        final String descriptionOfTotal = "The total number of records produced to this topic";
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
+
+        final Map<String, String> bytesRecordsTagMap = new HashMap<>(tagMap);
+        bytesRecordsTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addSumMetricToSensor(
+            expectedSensor,
+            PROCESSOR_NODE_LEVEL_GROUP,
+            bytesRecordsTagMap,
+            metricNamePrefix,
+            descriptionOfTotal
+        );
+        verifySensor(
+            () -> ProcessorNodeMetrics.recordsProducedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+        );
     }
 
     @Test

From edba70fc4c895e7d889db556e37391a3f0f60337 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 17:00:37 -0700
Subject: [PATCH 07/30] include all producer bytes

---
 .../processor/internals/ClientUtils.java      | 25 +++++++++++++++
 .../processor/internals/RecordCollector.java  | 18 +++++------
 .../internals/RecordCollectorImpl.java        |  8 +++--
 .../processor/internals/RecordQueue.java      | 21 ++----------
 .../streams/processor/internals/SinkNode.java |  2 +-
 .../metrics/ProcessorNodeMetrics.java         |  9 +++---
 .../state/KeyValueStoreTestDriver.java        | 32 +++++++++----------
 .../kafka/test/MockRecordCollector.java       | 32 +++++++++----------
 8 files changed, 80 insertions(+), 67 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index b47b68f8c4aa7..dad7ea4b65ccd 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -27,6 +27,9 @@
 import org.apache.kafka.common.MetricName;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.errors.TimeoutException;
+import org.apache.kafka.common.header.Header;
+import org.apache.kafka.common.header.Headers;
+import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.StreamsConfig;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.apache.kafka.streams.processor.TaskId;
@@ -166,4 +169,26 @@ public static String extractThreadId(final String fullThreadName) {
         final int index = fullThreadName.indexOf("StreamThread-");
         return fullThreadName.substring(index);
     }
+
+    public static long recordSizeInBytes(final long keyBytes,
+                                         final long valueBytes,
+                                         final String topic,
+                                         final Headers headers) {
+        long headerSizeInBytes = 0L;
+
+        for (final Header header: headers.toArray()) {
+            headerSizeInBytes += Utils.utf8(header.key()).length;
+            if (header.value() != null) {
+                headerSizeInBytes += header.value().length;
+            }
+        }
+
+        return keyBytes +
+            valueBytes +
+            8L + // timestamp
+            8L + // offset
+            Utils.utf8(topic).length +
+            4L + // partition
+            headerSizeInBytes;
+    }
 }
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
index cc3874d5c542f..3933f38dd5a48 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
@@ -26,7 +26,7 @@
 
 public interface RecordCollector {
 
-    <K, V> int send(final String topic,
+    <K, V> long send(final String topic,
                      final K key,
                      final V value,
                      final Headers headers,
@@ -35,14 +35,14 @@ <K, V> int send(final String topic,
                      final Serializer<K> keySerializer,
                      final Serializer<V> valueSerializer);
 
-    <K, V> int send(final String topic,
-                    final K key,
-                    final V value,
-                    final Headers headers,
-                    final Long timestamp,
-                    final Serializer<K> keySerializer,
-                    final Serializer<V> valueSerializer,
-                    final StreamPartitioner<? super K, ? super V> partitioner);
+    <K, V> long send(final String topic,
+                     final K key,
+                     final V value,
+                     final Headers headers,
+                     final Long timestamp,
+                     final Serializer<K> keySerializer,
+                     final Serializer<V> valueSerializer,
+                     final StreamPartitioner<? super K, ? super V> partitioner);
 
     /**
      * Initialize the internal {@link Producer}; note this function should be made idempotent
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index 571c90d1cac70..b7789f7020f7f 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -54,6 +54,8 @@
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 
+import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+
 public class RecordCollectorImpl implements RecordCollector {
     private final static String SEND_EXCEPTION_MESSAGE = "Error encountered sending record to topic %s for task %s due to:%n%s";
 
@@ -99,7 +101,7 @@ public void initialize() {
      * @throws TaskMigratedException recoverable error that would cause the task to be removed
      */
     @Override
-    public <K, V> int send(final String topic,
+    public <K, V> long send(final String topic,
                            final K key,
                            final V value,
                            final Headers headers,
@@ -140,7 +142,7 @@ public <K, V> int send(final String topic,
     }
 
     @Override
-    public <K, V> int send(final String topic,
+    public <K, V> long send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
@@ -199,7 +201,7 @@ public <K, V> int send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
-        return keyBytes.length + valBytes.length;
+        return recordSizeInBytes(keyBytes.length, valBytes.length, topic, headers);
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index b7caf76b976a0..cce2c6e0a28cb 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -18,10 +18,8 @@
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.header.Header;
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.utils.LogContext;
-import org.apache.kafka.common.utils.Utils;
 import org.apache.kafka.streams.errors.DeserializationExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
@@ -32,6 +30,8 @@
 
 import java.util.ArrayDeque;
 
+import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+
 /**
  * RecordQueue is a FIFO queue of {@link StampedRecord} (ConsumerRecord + timestamp). It also keeps track of the
  * partition timestamp defined as the largest timestamp seen on the partition so far; this is passed to the
@@ -124,22 +124,7 @@ public TopicPartition partition() {
     }
 
     private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        long headerSizeInBytes = 0L;
-
-        for (final Header header: record.headers().toArray()) {
-            headerSizeInBytes += Utils.utf8(header.key()).length;
-            if (header.value() != null) {
-                headerSizeInBytes += header.value().length;
-            }
-        }
-
-        return record.serializedKeySize() +
-                record.serializedValueSize() +
-                8L + // timestamp
-                8L + // offset
-                Utils.utf8(record.topic()).length +
-                4L + // partition
-                headerSizeInBytes;
+        return recordSizeInBytes(record.key().length, record.value().length, record.topic(), record.headers());
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index e8d5430fa6a48..a21aad2bc6030 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -103,7 +103,7 @@ public void process(final Record<KIn, VIn> record) {
 
         final String topic = topicExtractor.extract(key, value, contextForExtraction);
 
-        final int bytesProduced =
+        final long bytesProduced =
             collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
 
         bytesProducedSensor.record(bytesProduced, context.currentSystemTimeMs());
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 9087205ca8441..0d1de3a2b8b43 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -19,6 +19,7 @@
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.metrics.Sensor.RecordingLevel;
 
+import java.util.HashMap;
 import java.util.Map;
 
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.AVG_LATENCY_DESCRIPTION;
@@ -160,7 +161,7 @@ public static Sensor bytesConsumedSensor(final String threadId,
                                              final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_CONSUMED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
             sensor,
@@ -179,7 +180,7 @@ public static Sensor recordsConsumedSensor(final String threadId,
                                                final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
             sensor,
@@ -198,7 +199,7 @@ public static Sensor bytesProducedSensor(final String threadId,
                                              final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_PRODUCED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
             sensor,
@@ -217,7 +218,7 @@ public static Sensor recordsProducedSensor(final String threadId,
                                                final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId);
+        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
             sensor,
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 67391801e3340..865e0ec71a8d7 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -215,14 +215,14 @@ private KeyValueStoreTestDriver(final StateSerdes<K, V> serdes) {
             new MockStreamsMetrics(new Metrics())
         ) {
             @Override
-            public <K1, V1> int send(final String topic,
-                                     final K1 key,
-                                     final V1 value,
-                                     final Headers headers,
-                                     final Integer partition,
-                                     final Long timestamp,
-                                     final Serializer<K1> keySerializer,
-                                     final Serializer<V1> valueSerializer) {
+            public <K1, V1> long send(final String topic,
+                                      final K1 key,
+                                      final V1 value,
+                                      final Headers headers,
+                                      final Integer partition,
+                                      final Long timestamp,
+                                      final Serializer<K1> keySerializer,
+                                      final Serializer<V1> valueSerializer) {
                 // for byte arrays we need to wrap it for comparison
 
                 final byte[] keyBytes = keySerializer.serialize(topic, headers, key);
@@ -236,14 +236,14 @@ public <K1, V1> int send(final String topic,
             }
 
             @Override
-            public <K1, V1> int send(final String topic,
-                                     final K1 key,
-                                     final V1 value,
-                                     final Headers headers,
-                                     final Long timestamp,
-                                     final Serializer<K1> keySerializer,
-                                     final Serializer<V1> valueSerializer,
-                                     final StreamPartitioner<? super K1, ? super V1> partitioner) {
+            public <K1, V1> long send(final String topic,
+                                      final K1 key,
+                                      final V1 value,
+                                      final Headers headers,
+                                      final Long timestamp,
+                                      final Serializer<K1> keySerializer,
+                                      final Serializer<V1> valueSerializer,
+                                      final StreamPartitioner<? super K1, ? super V1> partitioner) {
                 throw new UnsupportedOperationException();
             }
         };
diff --git a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
index 3476e97e7c262..96dfa60dd29ef 100644
--- a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
+++ b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
@@ -39,14 +39,14 @@ public class MockRecordCollector implements RecordCollector {
     private boolean flushed = false;
 
     @Override
-    public <K, V> int send(final String topic,
-                           final K key,
-                           final V value,
-                           final Headers headers,
-                           final Integer partition,
-                           final Long timestamp,
-                           final Serializer<K> keySerializer,
-                           final Serializer<V> valueSerializer) {
+    public <K, V> long send(final String topic,
+                            final K key,
+                            final V value,
+                            final Headers headers,
+                            final Integer partition,
+                            final Long timestamp,
+                            final Serializer<K> keySerializer,
+                            final Serializer<V> valueSerializer) {
         collected.add(new ProducerRecord<>(topic,
                                            partition,
                                            timestamp,
@@ -57,14 +57,14 @@ public <K, V> int send(final String topic,
     }
 
     @Override
-    public <K, V> int send(final String topic,
-                           final K key,
-                           final V value,
-                           final Headers headers,
-                           final Long timestamp,
-                           final Serializer<K> keySerializer,
-                           final Serializer<V> valueSerializer,
-                           final StreamPartitioner<? super K, ? super V> partitioner) {
+    public <K, V> long send(final String topic,
+                            final K key,
+                            final V value,
+                            final Headers headers,
+                            final Long timestamp,
+                            final Serializer<K> keySerializer,
+                            final Serializer<V> valueSerializer,
+                            final StreamPartitioner<? super K, ? super V> partitioner) {
         collected.add(new ProducerRecord<>(topic,
             0, // partition id
             timestamp,

From 7a4dad32a9e8df2151653a4fe17a46d55324bcd7 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 17:17:57 -0700
Subject: [PATCH 08/30] null check for headers

---
 .../streams/processor/internals/ClientUtils.java   | 10 ++++++----
 .../processor/internals/RecordCollectorImpl.java   | 14 +++++++-------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index dad7ea4b65ccd..d98f61f944f7b 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -176,10 +176,12 @@ public static long recordSizeInBytes(final long keyBytes,
                                          final Headers headers) {
         long headerSizeInBytes = 0L;
 
-        for (final Header header: headers.toArray()) {
-            headerSizeInBytes += Utils.utf8(header.key()).length;
-            if (header.value() != null) {
-                headerSizeInBytes += header.value().length;
+        if (headers != null) {
+            for (final Header header : headers.toArray()) {
+                headerSizeInBytes += Utils.utf8(header.key()).length;
+                if (header.value() != null) {
+                    headerSizeInBytes += header.value().length;
+                }
             }
         }
 
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index b7789f7020f7f..d809cdd868747 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -102,13 +102,13 @@ public void initialize() {
      */
     @Override
     public <K, V> long send(final String topic,
-                           final K key,
-                           final V value,
-                           final Headers headers,
-                           final Long timestamp,
-                           final Serializer<K> keySerializer,
-                           final Serializer<V> valueSerializer,
-                           final StreamPartitioner<? super K, ? super V> partitioner) {
+                            final K key,
+                            final V value,
+                            final Headers headers,
+                            final Long timestamp,
+                            final Serializer<K> keySerializer,
+                            final Serializer<V> valueSerializer,
+                            final StreamPartitioner<? super K, ? super V> partitioner) {
         final Integer partition;
 
         if (partitioner != null) {

From 0761f0db0c3066fdbc83e49175b14a9a2f365572 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 17:25:06 -0700
Subject: [PATCH 09/30] fix name

---
 .../internals/metrics/ProcessorNodeMetrics.java      | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 0d1de3a2b8b43..32cc627edcc8c 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -159,8 +159,9 @@ public static Sensor bytesConsumedSensor(final String threadId,
                                              final String processorNodeId,
                                              final String topic,
                                              final StreamsMetricsImpl streamsMetrics) {
+        final String sensorName = processorNodeId + "-" + BYTES_CONSUMED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_CONSUMED, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -178,8 +179,9 @@ public static Sensor recordsConsumedSensor(final String threadId,
                                                final String processorNodeId,
                                                final String topic,
                                                final StreamsMetricsImpl streamsMetrics) {
+        final String sensorName = processorNodeId + "-" + RECORDS_CONSUMED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -197,8 +199,9 @@ public static Sensor bytesProducedSensor(final String threadId,
                                              final String processorNodeId,
                                              final String topic,
                                              final StreamsMetricsImpl streamsMetrics) {
+        final String sensorName = processorNodeId + "-" + BYTES_PRODUCED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_PRODUCED, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -216,8 +219,9 @@ public static Sensor recordsProducedSensor(final String threadId,
                                                final String processorNodeId,
                                                final String topic,
                                                final StreamsMetricsImpl streamsMetrics) {
+        final String sensorName = processorNodeId + "-" + RECORDS_PRODUCED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(

From 5ed377d91976a88d307485a40845be36cd53802c Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 19:12:43 -0700
Subject: [PATCH 10/30] fix up tests

---
 .../internals/metrics/ProcessorNodeMetrics.java      | 12 ++++--------
 .../internals/metrics/ProcessorNodeMetricsTest.java  |  8 ++++----
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 32cc627edcc8c..0d1de3a2b8b43 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -159,9 +159,8 @@ public static Sensor bytesConsumedSensor(final String threadId,
                                              final String processorNodeId,
                                              final String topic,
                                              final StreamsMetricsImpl streamsMetrics) {
-        final String sensorName = processorNodeId + "-" + BYTES_CONSUMED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_CONSUMED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -179,9 +178,8 @@ public static Sensor recordsConsumedSensor(final String threadId,
                                                final String processorNodeId,
                                                final String topic,
                                                final StreamsMetricsImpl streamsMetrics) {
-        final String sensorName = processorNodeId + "-" + RECORDS_CONSUMED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -199,9 +197,8 @@ public static Sensor bytesProducedSensor(final String threadId,
                                              final String processorNodeId,
                                              final String topic,
                                              final StreamsMetricsImpl streamsMetrics) {
-        final String sensorName = processorNodeId + "-" + BYTES_PRODUCED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_PRODUCED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
@@ -219,9 +216,8 @@ public static Sensor recordsProducedSensor(final String threadId,
                                                final String processorNodeId,
                                                final String topic,
                                                final StreamsMetricsImpl streamsMetrics) {
-        final String sensorName = processorNodeId + "-" + RECORDS_PRODUCED;
         final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, sensorName, RecordingLevel.INFO);
+            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
         addSumMetricToSensor(
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
index 0889ab9b06379..2cfec55bb534b 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
@@ -184,18 +184,18 @@ public void shouldGetBytesProducedSensor() {
 
     @Test
     public void shouldGetRecordsProducedSensor() {
-        final String metricNamePrefix = "bytes-produced";
+        final String metricNamePrefix = "records-produced";
         final String descriptionOfTotal = "The total number of records produced to this topic";
         when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
             .thenReturn(expectedSensor);
         when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
 
-        final Map<String, String> bytesRecordsTagMap = new HashMap<>(tagMap);
-        bytesRecordsTagMap.put("topic", TOPIC_NAME);
+        final Map<String, String> recordsProducedTagMap = new HashMap<>(tagMap);
+        recordsProducedTagMap.put("topic", TOPIC_NAME);
         StreamsMetricsImpl.addSumMetricToSensor(
             expectedSensor,
             PROCESSOR_NODE_LEVEL_GROUP,
-            bytesRecordsTagMap,
+            recordsProducedTagMap,
             metricNamePrefix,
             descriptionOfTotal
         );

From a03f9264a79921a23e10db53c36c1b51985ad2a5 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 21:18:13 -0700
Subject: [PATCH 11/30] review feedback: consolidate to one sensor

---
 .../internals/RecordCollectorImpl.java        |  4 +-
 .../processor/internals/RecordQueue.java      | 15 +--
 .../streams/processor/internals/SinkNode.java | 15 +--
 .../metrics/ProcessorNodeMetrics.java         | 72 ++++----------
 .../internals/metrics/StreamsMetricsImpl.java | 17 ++++
 .../internals/PartitionGroupTest.java         | 21 ++--
 .../metrics/ProcessorNodeMetricsTest.java     | 97 +++++++------------
 7 files changed, 85 insertions(+), 156 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index d809cdd868747..f160faadaa44b 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -124,7 +124,7 @@ public <K, V> long send(final String topic,
                 // here we cannot drop the message on the floor even if it is a transient timeout exception,
                 // so we treat everything the same as a fatal exception
                 throw new StreamsException("Could not determine the number of partitions for topic '" + topic +
-                    "' for task " + taskId + " due to " + fatal.toString(),
+                    "' for task " + taskId + " due to " + fatal,
                     fatal
                 );
             }
@@ -175,7 +175,7 @@ public <K, V> long send(final String topic,
                     valueClass),
                 exception);
         } catch (final RuntimeException exception) {
-            final String errorMessage = String.format(SEND_EXCEPTION_MESSAGE, topic, taskId, exception.toString());
+            final String errorMessage = String.format(SEND_EXCEPTION_MESSAGE, topic, taskId, exception);
             throw new StreamsException(errorMessage, exception);
         }
 
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index cce2c6e0a28cb..383a7459ba88b 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -53,8 +53,7 @@ public class RecordQueue {
     private long partitionTime = UNKNOWN;
 
     private final Sensor droppedRecordsSensor;
-    private final Sensor bytesConsumedSensor;
-    private final Sensor recordsConsumedSensor;
+    private final Sensor consumedSensor;
     private long totalBytesBuffered;
     private long headRecordSizeInBytes;
 
@@ -76,14 +75,7 @@ public class RecordQueue {
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
-        bytesConsumedSensor = ProcessorNodeMetrics.bytesConsumedSensor(
-            threadName,
-            processorContext.taskId().toString(),
-            source.name(),
-            partition.topic(),
-            processorContext.metrics()
-        );
-        recordsConsumedSensor = ProcessorNodeMetrics.recordsConsumedSensor(
+        consumedSensor = ProcessorNodeMetrics.consumedSensor(
             threadName,
             processorContext.taskId().toString(),
             source.name(),
@@ -152,8 +144,7 @@ int addRawRecords(final Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) {
     public StampedRecord poll(final long wallClockTime) {
         final StampedRecord recordToReturn = headRecord;
 
-        bytesConsumedSensor.record(headRecordSizeInBytes, wallClockTime);
-        recordsConsumedSensor.record(1, wallClockTime);
+        consumedSensor.record(headRecordSizeInBytes, wallClockTime);
 
         totalBytesBuffered -= headRecordSizeInBytes;
         headRecord = null;
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index a21aad2bc6030..f5a22665b9a86 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -33,8 +33,7 @@ public class SinkNode<KIn, VIn> extends ProcessorNode<KIn, VIn, Void, Void> {
     private final TopicNameExtractor<KIn, VIn> topicExtractor;
     private final StreamPartitioner<? super KIn, ? super VIn> partitioner;
 
-    private Sensor bytesProducedSensor;
-    private Sensor recordsProducedSensor;
+    private Sensor producedSensor;
 
     private InternalProcessorContext<Void, Void> context;
 
@@ -62,14 +61,7 @@ public void addChild(final ProcessorNode<Void, Void, ?, ?> child) {
     @Override
     public void init(final InternalProcessorContext<Void, Void> context) {
         final String threadName = Thread.currentThread().getName();
-        bytesProducedSensor = ProcessorNodeMetrics.bytesProducedSensor(
-            threadName,
-            context.taskId().toString(),
-            name(),
-            context.topic(),
-            context.metrics()
-        );
-        recordsProducedSensor = ProcessorNodeMetrics.recordsProducedSensor(
+        producedSensor = ProcessorNodeMetrics.producedSensor(
             threadName,
             context.taskId().toString(),
             name(),
@@ -106,8 +98,7 @@ public void process(final Record<KIn, VIn> record) {
         final long bytesProduced =
             collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
 
-        bytesProducedSensor.record(bytesProduced, context.currentSystemTimeMs());
-        recordsProducedSensor.record(1, context.currentSystemTimeMs());
+        producedSensor.record(bytesProduced, context.currentSystemTimeMs());
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 0d1de3a2b8b43..a98fd6d2941a7 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -37,7 +37,7 @@
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addInvocationRateAndCountToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addRateOfSumAndSumMetricsToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addAvgAndMaxToSensor;
-import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addSumMetricToSensor;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor;
 
 public class ProcessorNodeMetrics {
     private ProcessorNodeMetrics() {}
@@ -154,78 +154,44 @@ public static Sensor processAtSourceSensor(final String threadId,
         );
     }
 
-    public static Sensor bytesConsumedSensor(final String threadId,
-                                             final String taskId,
-                                             final String processorNodeId,
-                                             final String topic,
-                                             final StreamsMetricsImpl streamsMetrics) {
-        final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_CONSUMED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
-        tagMap.put("topic", topic);
-        addSumMetricToSensor(
-            sensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            tagMap,
-            BYTES_CONSUMED,
-            BYTES_CONSUMED_TOTAL_DESCRIPTION
-        );
-        return sensor;
-    }
-
-    public static Sensor recordsConsumedSensor(final String threadId,
-                                               final String taskId,
-                                               final String processorNodeId,
-                                               final String topic,
-                                               final StreamsMetricsImpl streamsMetrics) {
+    public static Sensor consumedSensor(final String threadId,
+                                        final String taskId,
+                                        final String processorNodeId,
+                                        final String topic,
+                                        final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
-        addSumMetricToSensor(
+        addTotalCountAndSumMetricsToSensor(
             sensor,
             PROCESSOR_NODE_LEVEL_GROUP,
             tagMap,
             RECORDS_CONSUMED,
-            RECORDS_CONSUMED_TOTAL_DESCRIPTION
-        );
-        return sensor;
-    }
-
-    public static Sensor bytesProducedSensor(final String threadId,
-                                             final String taskId,
-                                             final String processorNodeId,
-                                             final String topic,
-                                             final StreamsMetricsImpl streamsMetrics) {
-        final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, BYTES_PRODUCED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
-        tagMap.put("topic", topic);
-        addSumMetricToSensor(
-            sensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            tagMap,
-            BYTES_PRODUCED,
-            BYTES_PRODUCED_TOTAL_DESCRIPTION
+            BYTES_CONSUMED,
+            RECORDS_CONSUMED_TOTAL_DESCRIPTION,
+            BYTES_CONSUMED_TOTAL_DESCRIPTION
         );
         return sensor;
     }
 
-    public static Sensor recordsProducedSensor(final String threadId,
-                                               final String taskId,
-                                               final String processorNodeId,
-                                               final String topic,
-                                               final StreamsMetricsImpl streamsMetrics) {
+    public static Sensor producedSensor(final String threadId,
+                                        final String taskId,
+                                        final String processorNodeId,
+                                        final String topic,
+                                        final StreamsMetricsImpl streamsMetrics) {
         final Sensor sensor =
             streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
         final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
         tagMap.put("topic", topic);
-        addSumMetricToSensor(
+        addTotalCountAndSumMetricsToSensor(
             sensor,
             PROCESSOR_NODE_LEVEL_GROUP,
             tagMap,
             RECORDS_PRODUCED,
-            RECORDS_PRODUCED_TOTAL_DESCRIPTION
+            BYTES_PRODUCED,
+            RECORDS_PRODUCED_TOTAL_DESCRIPTION,
+            BYTES_PRODUCED_TOTAL_DESCRIPTION
         );
         return sensor;
     }
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
index dea23993d23a2..4527765146c5b 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
@@ -795,6 +795,23 @@ public static void addAvgAndSumMetricsToSensor(final Sensor sensor,
         );
     }
 
+    public static void addTotalCountAndSumMetricsToSensor(final Sensor sensor,
+                                                          final String group,
+                                                          final Map<String, String> tags,
+                                                          final String countMetricNamePrefix,
+                                                          final String sumMetricNamePrefix,
+                                                          final String descriptionOfCount,
+                                                          final String descriptionOfTotal) {
+        sensor.add(
+            new MetricName(countMetricNamePrefix + TOTAL_SUFFIX, group, descriptionOfCount, tags),
+            new CumulativeCount()
+        );
+        sensor.add(
+            new MetricName(sumMetricNamePrefix + TOTAL_SUFFIX, group, descriptionOfTotal, tags),
+            new CumulativeSum()
+        );
+    }
+
     public static void maybeMeasureLatency(final Runnable actionToMeasure,
                                            final Time time,
                                            final Sensor sensor) {
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
index 389d0d58c8d7f..16e3337ccd436 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
@@ -53,6 +53,8 @@
 import static org.apache.kafka.common.utils.Utils.mkEntry;
 import static org.apache.kafka.common.utils.Utils.mkMap;
 import static org.apache.kafka.common.utils.Utils.mkSet;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
@@ -846,19 +848,12 @@ record = group.nextRecord(info, time.milliseconds());
     private long getBytesBufferedForRawRecords(final List<ConsumerRecord<byte[], byte[]>> rawRecords) {
         long rawRecordsSizeInBytes = 0L;
         for (final ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) {
-            long headerSizeInBytes = 0L;
-
-            for (final Header header: rawRecord.headers().toArray()) {
-                headerSizeInBytes += header.key().getBytes().length + header.value().length;
-            }
-
-            rawRecordsSizeInBytes += rawRecord.serializedKeySize() +
-                    rawRecord.serializedValueSize() +
-                    8L + // timestamp
-                    8L + // offset
-                    rawRecord.topic().getBytes().length +
-                    4L + // partition
-                    headerSizeInBytes;
+            rawRecordsSizeInBytes += recordSizeInBytes(
+                rawRecord.key().length,
+                rawRecord.value().length,
+                rawRecord.topic(),
+                rawRecord.headers()
+            );
         }
         return rawRecordsSizeInBytes;
     }
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
index 2cfec55bb534b..34f32d715eb75 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
@@ -117,90 +117,59 @@ public void shouldGetProcessAtSourceSensor() {
     }
 
     @Test
-    public void shouldGetBytesConsumedSensor() {
-        final String metricNamePrefix = "bytes-consumed";
-        final String descriptionOfTotal = "The total number of bytes consumed from this topic";
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+    public void shouldGetRecordsAndBytesConsumedSensor() {
+        final String recordsMetricNamePrefix = "records-consumed";
+        final String bytesMetricNamePrefix = "bytes-consumed";
+        final String descriptionOfRecordsTotal = "The total number of records consumed from this topic";
+        final String descriptionOfBytesTotal = "The total number of bytes consumed from this topic";
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, recordsMetricNamePrefix, RecordingLevel.INFO))
             .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
-
-        final Map<String, String> bytesConsumedTagMap = new HashMap<>(tagMap);
-        bytesConsumedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addSumMetricToSensor(
-            expectedSensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            bytesConsumedTagMap,
-            metricNamePrefix,
-            descriptionOfTotal
-        );
-        verifySensor(
-            () -> ProcessorNodeMetrics.bytesConsumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
-        );
-    }
-
-    @Test
-    public void shouldGetRecordsConsumedSensor() {
-        final String metricNamePrefix = "records-consumed";
-        final String descriptionOfTotal = "The total number of records consumed from this topic";
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, bytesMetricNamePrefix, RecordingLevel.INFO))
             .thenReturn(expectedSensor);
         when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
 
-        final Map<String, String> recordsConsumedTagMap = new HashMap<>(tagMap);
-        recordsConsumedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addSumMetricToSensor(
+        final Map<String, String> consumedTagMap = new HashMap<>(tagMap);
+        consumedTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
             expectedSensor,
             PROCESSOR_NODE_LEVEL_GROUP,
-            recordsConsumedTagMap,
-            metricNamePrefix,
-            descriptionOfTotal
+            consumedTagMap,
+            recordsMetricNamePrefix,
+            bytesMetricNamePrefix,
+            descriptionOfRecordsTotal,
+            descriptionOfBytesTotal
         );
         verifySensor(
-            () -> ProcessorNodeMetrics.recordsConsumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+            () -> ProcessorNodeMetrics.consumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
         );
     }
 
     @Test
-    public void shouldGetBytesProducedSensor() {
-        final String metricNamePrefix = "bytes-produced";
-        final String descriptionOfTotal = "The total number of bytes produced to this topic";
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
-            .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
-
-        final Map<String, String> bytesProducedTagMap = new HashMap<>(tagMap);
-        bytesProducedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addSumMetricToSensor(
-            expectedSensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            bytesProducedTagMap,
-            metricNamePrefix,
-            descriptionOfTotal
-        );
-        verifySensor(
-            () -> ProcessorNodeMetrics.bytesProducedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
-        );
-    }
+    public void shouldGetRecordsAndBytesProducedSensor() {
+        final String recordsMetricNamePrefix = "records-produced";
+        final String bytesMetricNamePrefix = "bytes-produced";
+        final String descriptionOfRecordsTotal = "The total number of records produced to this topic";
+        final String descriptionOfBytesTotal = "The total number of bytes produced to this topic";
 
-    @Test
-    public void shouldGetRecordsProducedSensor() {
-        final String metricNamePrefix = "records-produced";
-        final String descriptionOfTotal = "The total number of records produced to this topic";
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, metricNamePrefix, RecordingLevel.INFO))
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, recordsMetricNamePrefix, RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, bytesMetricNamePrefix, RecordingLevel.INFO))
             .thenReturn(expectedSensor);
         when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
 
-        final Map<String, String> recordsProducedTagMap = new HashMap<>(tagMap);
-        recordsProducedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addSumMetricToSensor(
+        final Map<String, String> producedTagMap = new HashMap<>(tagMap);
+        producedTagMap.put("topic", TOPIC_NAME);
+        StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
             expectedSensor,
             PROCESSOR_NODE_LEVEL_GROUP,
-            recordsProducedTagMap,
-            metricNamePrefix,
-            descriptionOfTotal
+            producedTagMap,
+            recordsMetricNamePrefix,
+            bytesMetricNamePrefix,
+            descriptionOfRecordsTotal,
+            descriptionOfBytesTotal
         );
         verifySensor(
-            () -> ProcessorNodeMetrics.recordsProducedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+            () -> ProcessorNodeMetrics.producedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
         );
     }
 

From b8d8f0c19d8a71d19e5130b22ad9f9e254302a38 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 21:22:40 -0700
Subject: [PATCH 12/30] checkstyle & value null check

---
 .../streams/processor/internals/ClientUtils.java      | 11 +++++++----
 .../processor/internals/RecordCollectorImpl.java      |  2 +-
 .../streams/processor/internals/RecordQueue.java      |  2 +-
 .../processor/internals/PartitionGroupTest.java       |  5 ++---
 4 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index d98f61f944f7b..54b40108e568d 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -170,8 +170,8 @@ public static String extractThreadId(final String fullThreadName) {
         return fullThreadName.substring(index);
     }
 
-    public static long recordSizeInBytes(final long keyBytes,
-                                         final long valueBytes,
+    public static long recordSizeInBytes(final byte[] keyBytes,
+                                         final byte[] valueBytes,
                                          final String topic,
                                          final Headers headers) {
         long headerSizeInBytes = 0L;
@@ -185,8 +185,11 @@ public static long recordSizeInBytes(final long keyBytes,
             }
         }
 
-        return keyBytes +
-            valueBytes +
+        final long keyLength = keyBytes.length;;
+        final long valueLength = valueBytes == null ? 0 : valueBytes.length;
+
+        return keyLength +
+            valueLength +
             8L + // timestamp
             8L + // offset
             Utils.utf8(topic).length +
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index f160faadaa44b..ae2f7f3c8caf2 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -201,7 +201,7 @@ public <K, V> long send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
-        return recordSizeInBytes(keyBytes.length, valBytes.length, topic, headers);
+        return recordSizeInBytes(keyBytes, valBytes, topic, headers);
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index 383a7459ba88b..ba651aacc6a6d 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -116,7 +116,7 @@ public TopicPartition partition() {
     }
 
     private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        return recordSizeInBytes(record.key().length, record.value().length, record.topic(), record.headers());
+        return recordSizeInBytes(record.key(), record.value(), record.topic(), record.headers());
     }
 
     /**
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
index 16e3337ccd436..867038fe7b667 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
@@ -19,7 +19,6 @@
 import org.apache.kafka.clients.consumer.ConsumerRecord;
 import org.apache.kafka.common.MetricName;
 import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.header.Header;
 import org.apache.kafka.common.header.internals.RecordHeaders;
 import org.apache.kafka.common.metrics.Metrics;
 import org.apache.kafka.common.metrics.Sensor;
@@ -849,8 +848,8 @@ private long getBytesBufferedForRawRecords(final List<ConsumerRecord<byte[], byt
         long rawRecordsSizeInBytes = 0L;
         for (final ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) {
             rawRecordsSizeInBytes += recordSizeInBytes(
-                rawRecord.key().length,
-                rawRecord.value().length,
+                rawRecord.key(),
+                rawRecord.value(),
                 rawRecord.topic(),
                 rawRecord.headers()
             );

From 9a0cfd1b19547ec355e6c9764c07d4534fdfa238 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 21:23:23 -0700
Subject: [PATCH 13/30] extra ;

---
 .../apache/kafka/streams/processor/internals/ClientUtils.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index 54b40108e568d..8602d2169281e 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -185,7 +185,7 @@ public static long recordSizeInBytes(final byte[] keyBytes,
             }
         }
 
-        final long keyLength = keyBytes.length;;
+        final long keyLength = keyBytes.length;
         final long valueLength = valueBytes == null ? 0 : valueBytes.length;
 
         return keyLength +

From 0df6c10dc1ea8c8ea896c0b25072ecfc5c45c7e4 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 22:00:12 -0700
Subject: [PATCH 14/30] use util method in kvstore test driver

---
 .../apache/kafka/streams/state/KeyValueStoreTestDriver.java   | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 865e0ec71a8d7..16034ffd8f83b 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -54,6 +54,8 @@
 import java.util.Properties;
 import java.util.Set;
 
+import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+
 /**
  * A component that provides a {@link #context() ProcessingContext} that can be supplied to a {@link KeyValueStore} so that
  * all entries written to the Kafka topic by the store during {@link KeyValueStore#flush()} are captured for testing purposes.
@@ -232,7 +234,7 @@ public <K1, V1> long send(final String topic,
                 final V valueTest = serdes.valueFrom(valueBytes);
 
                 recordFlushed(keyTest, valueTest);
-                return keyBytes.length + valueBytes.length;
+                return recordSizeInBytes(keyBytes, valueBytes, topic, headers);
             }
 
             @Override

From a8681d1966545b73f08b84ba1bfb83fb93b55eda Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Wed, 1 Jun 2022 23:58:17 -0700
Subject: [PATCH 15/30] use topic name extractor

---
 .../streams/processor/internals/ClientUtils.java      | 11 ++++-------
 .../processor/internals/RecordCollectorImpl.java      |  2 +-
 .../streams/processor/internals/RecordQueue.java      |  2 +-
 .../kafka/streams/processor/internals/SinkNode.java   |  2 +-
 .../processor/internals/PartitionGroupTest.java       |  4 ++--
 .../kafka/streams/state/KeyValueStoreTestDriver.java  |  2 +-
 6 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index 8602d2169281e..d98f61f944f7b 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -170,8 +170,8 @@ public static String extractThreadId(final String fullThreadName) {
         return fullThreadName.substring(index);
     }
 
-    public static long recordSizeInBytes(final byte[] keyBytes,
-                                         final byte[] valueBytes,
+    public static long recordSizeInBytes(final long keyBytes,
+                                         final long valueBytes,
                                          final String topic,
                                          final Headers headers) {
         long headerSizeInBytes = 0L;
@@ -185,11 +185,8 @@ public static long recordSizeInBytes(final byte[] keyBytes,
             }
         }
 
-        final long keyLength = keyBytes.length;
-        final long valueLength = valueBytes == null ? 0 : valueBytes.length;
-
-        return keyLength +
-            valueLength +
+        return keyBytes +
+            valueBytes +
             8L + // timestamp
             8L + // offset
             Utils.utf8(topic).length +
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index ae2f7f3c8caf2..ae5866ad6fc56 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -201,7 +201,7 @@ public <K, V> long send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
-        return recordSizeInBytes(keyBytes, valBytes, topic, headers);
+        return recordSizeInBytes(keyBytes.length, valBytes == null ? 0 : valBytes.length, topic, headers);
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index ba651aacc6a6d..688e852e62854 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -116,7 +116,7 @@ public TopicPartition partition() {
     }
 
     private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        return recordSizeInBytes(record.key(), record.value(), record.topic(), record.headers());
+        return recordSizeInBytes(record.serializedKeySize(), record.serializedValueSize(), record.topic(), record.headers());
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index f5a22665b9a86..a8d3ee8f77638 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -65,7 +65,7 @@ public void init(final InternalProcessorContext<Void, Void> context) {
             threadName,
             context.taskId().toString(),
             name(),
-            context.topic(),
+            topicExtractor.extract(null, null, null),
             context.metrics()
         );
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
index 867038fe7b667..e5d1b0fe769df 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
@@ -848,8 +848,8 @@ private long getBytesBufferedForRawRecords(final List<ConsumerRecord<byte[], byt
         long rawRecordsSizeInBytes = 0L;
         for (final ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) {
             rawRecordsSizeInBytes += recordSizeInBytes(
-                rawRecord.key(),
-                rawRecord.value(),
+                rawRecord.serializedKeySize(),
+                rawRecord.serializedValueSize(),
                 rawRecord.topic(),
                 rawRecord.headers()
             );
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 16034ffd8f83b..6e58f48d9e11f 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -234,7 +234,7 @@ public <K1, V1> long send(final String topic,
                 final V valueTest = serdes.valueFrom(valueBytes);
 
                 recordFlushed(keyTest, valueTest);
-                return recordSizeInBytes(keyBytes, valueBytes, topic, headers);
+                return recordSizeInBytes(keyBytes.length, valueBytes.length, topic, headers);
             }
 
             @Override

From 31d10f8e0843977b7714b4f3307e9956e62b8fc7 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Thu, 2 Jun 2022 00:01:24 -0700
Subject: [PATCH 16/30] also nullcheck key

---
 .../kafka/streams/processor/internals/RecordCollectorImpl.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index ae5866ad6fc56..9b7c66eeb64bc 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -201,7 +201,7 @@ public <K, V> long send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
-        return recordSizeInBytes(keyBytes.length, valBytes == null ? 0 : valBytes.length, topic, headers);
+        return recordSizeInBytes(keyBytes == null ? 0 : keyBytes.length, valBytes == null ? 0 : valBytes.length, topic, headers);
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {

From 7dea1aed7fb21a7f069363bfb14b84b682460502 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Thu, 2 Jun 2022 00:49:35 -0700
Subject: [PATCH 17/30] nullcheck for test driver

---
 .../org/apache/kafka/streams/state/KeyValueStoreTestDriver.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 6e58f48d9e11f..8624497ef9081 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -234,7 +234,7 @@ public <K1, V1> long send(final String topic,
                 final V valueTest = serdes.valueFrom(valueBytes);
 
                 recordFlushed(keyTest, valueTest);
-                return recordSizeInBytes(keyBytes.length, valueBytes.length, topic, headers);
+                return recordSizeInBytes(keyBytes.length, valueBytes == null ? 0 : valueBytes.length, topic, headers);
             }
 
             @Override

From 5745fe998ff677af7c7fb97ebda77fd2ec71de5a Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Thu, 2 Jun 2022 03:03:35 -0700
Subject: [PATCH 18/30] fixin up some last tests

---
 .../streams/processor/internals/SinkNode.java | 25 +++++++++--------
 .../internals/ProcessorContextImplTest.java   | 28 ++++++++++---------
 .../internals/WriteConsistencyVectorTest.java | 21 +++++++-------
 3 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index a8d3ee8f77638..cc5927a30d0eb 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -23,6 +23,9 @@
 import org.apache.kafka.streams.processor.api.Record;
 import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareKeySerializer;
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareValueSerializer;
 
@@ -33,7 +36,7 @@ public class SinkNode<KIn, VIn> extends ProcessorNode<KIn, VIn, Void, Void> {
     private final TopicNameExtractor<KIn, VIn> topicExtractor;
     private final StreamPartitioner<? super KIn, ? super VIn> partitioner;
 
-    private Sensor producedSensor;
+    private final Map<String, Sensor> producedSensorByTopic = new HashMap<>();
 
     private InternalProcessorContext<Void, Void> context;
 
@@ -60,15 +63,6 @@ public void addChild(final ProcessorNode<Void, Void, ?, ?> child) {
 
     @Override
     public void init(final InternalProcessorContext<Void, Void> context) {
-        final String threadName = Thread.currentThread().getName();
-        producedSensor = ProcessorNodeMetrics.producedSensor(
-            threadName,
-            context.taskId().toString(),
-            name(),
-            topicExtractor.extract(null, null, null),
-            context.metrics()
-        );
-
         super.init(context);
         this.context = context;
         keySerializer = prepareKeySerializer(keySerializer, context, this.name());
@@ -98,7 +92,16 @@ public void process(final Record<KIn, VIn> record) {
         final long bytesProduced =
             collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
 
-        producedSensor.record(bytesProduced, context.currentSystemTimeMs());
+        producedSensorByTopic.putIfAbsent(
+            topic,
+            ProcessorNodeMetrics.producedSensor(
+                Thread.currentThread().getName(),
+                context.taskId().toString(),
+                name(),
+                topicExtractor.extract(null, null, null),
+                context.metrics()
+        ));
+        producedSensorByTopic.get(topic).record(bytesProduced, context.currentSystemTimeMs());
     }
 
     /**
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
index b6cc7a789ebec..73dda3c1a5611 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
@@ -396,16 +396,18 @@ public void localSessionStoreShouldNotAllowInitOrClose() {
 
     @Test
     public void shouldNotSendRecordHeadersToChangelogTopic() {
-        recordCollector.send(
-                CHANGELOG_PARTITION.topic(),
-                KEY_BYTES,
-                VALUE_BYTES,
-                null,
-                CHANGELOG_PARTITION.partition(),
-                TIMESTAMP,
-                BYTES_KEY_SERIALIZER,
-                BYTEARRAY_VALUE_SERIALIZER
-        );
+        EasyMock.expect(
+                recordCollector.send(
+                    CHANGELOG_PARTITION.topic(),
+                    KEY_BYTES,
+                    VALUE_BYTES,
+                    null,
+                    CHANGELOG_PARTITION.partition(),
+                    TIMESTAMP,
+                    BYTES_KEY_SERIALIZER,
+                    BYTEARRAY_VALUE_SERIALIZER))
+            .andStubReturn(0L);
+        
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 
         replay(recordCollector, task);
@@ -422,7 +424,7 @@ public void shouldSendRecordHeadersToChangelogTopicWhenConsistencyEnabled() {
         headers.add(ChangelogRecordDeserializationHelper.CHANGELOG_VERSION_HEADER_RECORD_CONSISTENCY);
         headers.add(new RecordHeader(ChangelogRecordDeserializationHelper.CHANGELOG_POSITION_HEADER_KEY,
                 PositionSerde.serialize(position).array()));
-        recordCollector.send(
+        EasyMock.expect(recordCollector.send(
                 CHANGELOG_PARTITION.topic(),
                 KEY_BYTES,
                 VALUE_BYTES,
@@ -430,8 +432,8 @@ public void shouldSendRecordHeadersToChangelogTopicWhenConsistencyEnabled() {
                 CHANGELOG_PARTITION.partition(),
                 TIMESTAMP,
                 BYTES_KEY_SERIALIZER,
-                BYTEARRAY_VALUE_SERIALIZER
-        );
+                BYTEARRAY_VALUE_SERIALIZER))
+            .andStubReturn(0L);
 
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
index 1ca19d896368a..1c806bdc07c0e 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
@@ -114,16 +114,17 @@ public void shouldSendConsistencyVectorToChangelogTopic() {
         headers.add(new RecordHeader(
                 ChangelogRecordDeserializationHelper.CHANGELOG_POSITION_HEADER_KEY,
                 PositionSerde.serialize(position).array()));
-        recordCollector.send(
-                CHANGELOG_PARTITION.topic(),
-                KEY_BYTES,
-                VALUE_BYTES,
-                headers,
-                CHANGELOG_PARTITION.partition(),
-                TIMESTAMP,
-                BYTES_KEY_SERIALIZER,
-                BYTEARRAY_VALUE_SERIALIZER
-        );
+        EasyMock.expect(
+                recordCollector.send(
+                    CHANGELOG_PARTITION.topic(),
+                    KEY_BYTES,
+                    VALUE_BYTES,
+                    headers,
+                    CHANGELOG_PARTITION.partition(),
+                    TIMESTAMP,
+                    BYTES_KEY_SERIALIZER,
+                    BYTEARRAY_VALUE_SERIALIZER))
+            .andStubReturn(0L);
 
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 

From 511b5bcffe2d37604eb2cc7306ba144bc3863d3b Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Thu, 2 Jun 2022 03:59:13 -0700
Subject: [PATCH 19/30] use local topic

---
 .../org/apache/kafka/streams/processor/internals/SinkNode.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index cc5927a30d0eb..eb18d01dcf004 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -98,7 +98,7 @@ public void process(final Record<KIn, VIn> record) {
                 Thread.currentThread().getName(),
                 context.taskId().toString(),
                 name(),
-                topicExtractor.extract(null, null, null),
+                topic,
                 context.metrics()
         ));
         producedSensorByTopic.get(topic).record(bytesProduced, context.currentSystemTimeMs());

From a5756c11f5f2d79f32c5cbc602fb5cc17d9d7e91 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 02:24:41 -0700
Subject: [PATCH 20/30] add TopicMetrics

---
 checkstyle/suppressions.xml                   |   2 +-
 .../internals/ActiveTaskCreator.java          |   3 +-
 .../processor/internals/ClientUtils.java      |  20 ++
 .../processor/internals/PartitionGroup.java   |   6 +
 .../internals/ProcessorContextImpl.java       |   5 +-
 .../processor/internals/RecordCollector.java  |  10 +-
 .../internals/RecordCollectorImpl.java        |  70 ++++-
 .../processor/internals/RecordQueue.java      |  19 +-
 .../streams/processor/internals/SinkNode.java |  29 +-
 .../processor/internals/StreamTask.java       |   7 +
 .../metrics/ProcessorNodeMetrics.java         |  60 ----
 .../internals/metrics/StreamsMetricsImpl.java |  47 +++
 .../internals/metrics/TopicMetrics.java       |  92 ++++++
 .../InMemoryTimeOrderedKeyValueBuffer.java    |  10 +-
 .../integration/MetricsIntegrationTest.java   |  18 +-
 .../processor/internals/ClientUtilsTest.java  | 114 ++++++-
 .../internals/PartitionGroupTest.java         |   9 +-
 .../internals/ProcessorContextImplTest.java   |  45 +--
 .../internals/RecordCollectorTest.java        | 279 +++++++++++++-----
 .../processor/internals/RecordQueueTest.java  |  67 ++++-
 .../internals/WriteConsistencyVectorTest.java |  22 +-
 .../metrics/ProcessorNodeMetricsTest.java     |  59 ----
 .../metrics/StreamsMetricsImplTest.java       |  82 ++++-
 .../internals/metrics/TopicMetricsTest.java   | 112 +++++++
 .../state/KeyValueStoreTestDriver.java        |  23 +-
 .../StreamThreadStateStoreProviderTest.java   |   4 +-
 .../test/InternalMockProcessorContext.java    |   4 +-
 .../kafka/test/MockRecordCollector.java       |  13 +-
 .../kafka/streams/TopologyTestDriver.java     |   3 +-
 29 files changed, 923 insertions(+), 311 deletions(-)
 create mode 100644 streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetrics.java
 create mode 100644 streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java

diff --git a/checkstyle/suppressions.xml b/checkstyle/suppressions.xml
index a111ce74cf660..4ce484dd2c747 100644
--- a/checkstyle/suppressions.xml
+++ b/checkstyle/suppressions.xml
@@ -213,7 +213,7 @@
 
     <!-- Streams tests -->
     <suppress checks="ClassFanOutComplexity"
-              files="(StreamsPartitionAssignorTest|StreamThreadTest|StreamTaskTest|TaskManagerTest|TopologyTestDriverTest).java"/>
+              files="(RecordCollectorTest|StreamsPartitionAssignorTest|StreamThreadTest|StreamTaskTest|TaskManagerTest|TopologyTestDriverTest).java"/>
 
     <suppress checks="MethodLength"
               files="(EosIntegrationTest|EosV2UpgradeIntegrationTest|KStreamKStreamJoinTest|RocksDBWindowStoreTest).java"/>
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreator.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreator.java
index d5545eafece7e..d90266dbf4dc1 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreator.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreator.java
@@ -260,7 +260,8 @@ private StreamTask createActiveTask(final TaskId taskId,
             taskId,
             streamsProducer,
             applicationConfig.defaultProductionExceptionHandler(),
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
         final StreamTask task = new StreamTask(
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
index d98f61f944f7b..ea48c6461732a 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ClientUtils.java
@@ -21,6 +21,8 @@
 import org.apache.kafka.clients.admin.OffsetSpec;
 import org.apache.kafka.clients.consumer.Consumer;
 import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.KafkaFuture;
 import org.apache.kafka.common.Metric;
@@ -170,6 +172,24 @@ public static String extractThreadId(final String fullThreadName) {
         return fullThreadName.substring(index);
     }
 
+    public static long producerRecordSizeInBytes(final ProducerRecord<byte[], byte[]> record) {
+        return recordSizeInBytes(
+            record.key().length,
+            record.value() == null ? 0 : record.value().length,
+            record.topic(),
+            record.headers()
+        );
+    }
+
+    public static long consumerRecordSizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
+        return recordSizeInBytes(
+            record.serializedKeySize(),
+            record.serializedValueSize(),
+            record.topic(),
+            record.headers()
+        );
+    }
+
     public static long recordSizeInBytes(final long keyBytes,
                                          final long valueBytes,
                                          final String topic,
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
index 18f13e441b6f9..21d3cbfa3f436 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/PartitionGroup.java
@@ -392,6 +392,12 @@ void clear() {
         streamTime = RecordQueue.UNKNOWN;
     }
 
+    void close() {
+        for (final RecordQueue queue : partitionQueues.values()) {
+            queue.close();
+        }
+    }
+
     // Below methods are for only testing.
 
     boolean allPartitionsBufferedLocally() {
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorContextImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorContextImpl.java
index 5a548aba97225..ffa5dcaf73bc7 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorContextImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/ProcessorContextImpl.java
@@ -147,8 +147,9 @@ public void logChange(final String storeName,
             changelogPartition.partition(),
             timestamp,
             BYTES_KEY_SERIALIZER,
-            BYTEARRAY_VALUE_SERIALIZER
-        );
+            BYTEARRAY_VALUE_SERIALIZER,
+            null,
+            null);
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
index 3933f38dd5a48..a48a671d46091 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollector.java
@@ -26,22 +26,26 @@
 
 public interface RecordCollector {
 
-    <K, V> long send(final String topic,
+    <K, V> void send(final String topic,
                      final K key,
                      final V value,
                      final Headers headers,
                      final Integer partition,
                      final Long timestamp,
                      final Serializer<K> keySerializer,
-                     final Serializer<V> valueSerializer);
+                     final Serializer<V> valueSerializer,
+                     final String processorNodeId,
+                     final InternalProcessorContext<Void, Void> context);
 
-    <K, V> long send(final String topic,
+    <K, V> void send(final String topic,
                      final K key,
                      final V value,
                      final Headers headers,
                      final Long timestamp,
                      final Serializer<K> keySerializer,
                      final Serializer<V> valueSerializer,
+                     final String processorNodeId,
+                     final InternalProcessorContext<Void, Void> context,
                      final StreamPartitioner<? super K, ? super V> partitioner);
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
index 9b7c66eeb64bc..358af6b1b3aed 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordCollectorImpl.java
@@ -46,6 +46,8 @@
 import org.apache.kafka.streams.processor.TaskId;
 import org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
+import org.apache.kafka.streams.processor.internals.metrics.TopicMetrics;
+
 import org.slf4j.Logger;
 
 import java.util.Collections;
@@ -54,7 +56,7 @@
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.producerRecordSizeInBytes;
 
 public class RecordCollectorImpl implements RecordCollector {
     private final static String SEND_EXCEPTION_MESSAGE = "Error encountered sending record to topic %s for task %s due to:%n%s";
@@ -63,10 +65,13 @@ public class RecordCollectorImpl implements RecordCollector {
     private final TaskId taskId;
     private final StreamsProducer streamsProducer;
     private final ProductionExceptionHandler productionExceptionHandler;
-    private final Sensor droppedRecordsSensor;
     private final boolean eosEnabled;
     private final Map<TopicPartition, Long> offsets;
 
+    private final StreamsMetricsImpl streamsMetrics;
+    private final Sensor droppedRecordsSensor;
+    private final Map<String, Map<String, Sensor>> sinkNodeToProducedSensorByTopic = new HashMap<>();
+
     private final AtomicReference<KafkaException> sendException = new AtomicReference<>(null);
 
     /**
@@ -76,15 +81,29 @@ public RecordCollectorImpl(final LogContext logContext,
                                final TaskId taskId,
                                final StreamsProducer streamsProducer,
                                final ProductionExceptionHandler productionExceptionHandler,
-                               final StreamsMetricsImpl streamsMetrics) {
+                               final StreamsMetricsImpl streamsMetrics,
+                               final ProcessorTopology topology) {
         this.log = logContext.logger(getClass());
         this.taskId = taskId;
         this.streamsProducer = streamsProducer;
         this.productionExceptionHandler = productionExceptionHandler;
         this.eosEnabled = streamsProducer.eosEnabled();
+        this.streamsMetrics = streamsMetrics;
 
         final String threadId = Thread.currentThread().getName();
         this.droppedRecordsSensor = TaskMetrics.droppedRecordsSensor(threadId, taskId.toString(), streamsMetrics);
+        for (final String topic : topology.sinkTopics()) {
+            final String processorNodeId = topology.sink(topic).name();
+            sinkNodeToProducedSensorByTopic.computeIfAbsent(processorNodeId, t -> new HashMap<>()).put(
+                topic,
+                TopicMetrics.producedSensor(
+                    threadId,
+                    taskId.toString(),
+                    processorNodeId,
+                    topic,
+                    streamsMetrics
+                ));
+        }
 
         this.offsets = new HashMap<>();
     }
@@ -101,13 +120,15 @@ public void initialize() {
      * @throws TaskMigratedException recoverable error that would cause the task to be removed
      */
     @Override
-    public <K, V> long send(final String topic,
+    public <K, V> void send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
                             final Long timestamp,
                             final Serializer<K> keySerializer,
                             final Serializer<V> valueSerializer,
+                            final String processorNodeId,
+                            final InternalProcessorContext<Void, Void> context,
                             final StreamPartitioner<? super K, ? super V> partitioner) {
         final Integer partition;
 
@@ -138,18 +159,20 @@ public <K, V> long send(final String topic,
             partition = null;
         }
 
-        return send(topic, key, value, headers, partition, timestamp, keySerializer, valueSerializer);
+        send(topic, key, value, headers, partition, timestamp, keySerializer, valueSerializer, processorNodeId, context);
     }
 
     @Override
-    public <K, V> long send(final String topic,
+    public <K, V> void send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
                             final Integer partition,
                             final Long timestamp,
                             final Serializer<K> keySerializer,
-                            final Serializer<V> valueSerializer) {
+                            final Serializer<V> valueSerializer,
+                            final String processorNodeId,
+                            final InternalProcessorContext<Void, Void> context) {
         checkForException();
 
         final byte[] keyBytes;
@@ -194,6 +217,28 @@ public <K, V> long send(final String topic,
                 } else {
                     log.warn("Received offset={} in produce response for {}", metadata.offset(), tp);
                 }
+
+                if (!topic.endsWith("-changelog")) {
+                    // we may not have created a sensor yet if the node uses dynamic topic routing
+                    final Map<String, Sensor> producedSensorByTopic = sinkNodeToProducedSensorByTopic.get(processorNodeId);
+                    if (producedSensorByTopic == null) {
+                        log.error("Unable to records bytes produced to topic {} by sink node {} as the node is not recognized.\n"
+                                      + "Known sink nodes are {}.", topic, processorNodeId, sinkNodeToProducedSensorByTopic.keySet());
+                    } else {
+                        final Sensor topicProducedSensor = producedSensorByTopic.computeIfAbsent(
+                            topic,
+                            t -> TopicMetrics.producedSensor(
+                                Thread.currentThread().getName(),
+                                taskId.toString(),
+                                processorNodeId,
+                                topic,
+                                context.metrics()
+                            )
+                        );
+                        final long bytesProduced = producerRecordSizeInBytes(serializedRecord);
+                        topicProducedSensor.record(bytesProduced, context.currentSystemTimeMs());
+                    }
+                }
             } else {
                 recordSendError(topic, exception, serializedRecord);
 
@@ -201,7 +246,6 @@ public <K, V> long send(final String topic,
                 log.trace("Failed record: (key {} value {} timestamp {}) topic=[{}] partition=[{}]", key, value, timestamp, topic, partition);
             }
         });
-        return recordSizeInBytes(keyBytes == null ? 0 : keyBytes.length, valBytes == null ? 0 : valBytes.length, topic, headers);
     }
 
     private void recordSendError(final String topic, final Exception exception, final ProducerRecord<byte[], byte[]> serializedRecord) {
@@ -270,6 +314,8 @@ public void flush() {
     public void closeClean() {
         log.info("Closing record collector clean");
 
+        removeAllProducedSensors();
+
         // No need to abort transaction during a clean close: either we have successfully committed the ongoing
         // transaction during handleRevocation and thus there is no transaction in flight, or else none of the revoked
         // tasks had any data in the current transaction and therefore there is no need to commit or abort it.
@@ -293,6 +339,14 @@ public void closeDirty() {
         checkForException();
     }
 
+    private void removeAllProducedSensors() {
+        for (final Map<String, Sensor> nodeMap : sinkNodeToProducedSensorByTopic.values()) {
+            for (final Sensor sensor : nodeMap.values()) {
+                streamsMetrics.removeSensor(sensor);
+            }
+        }
+    }
+
     @Override
     public Map<TopicPartition, Long> offsets() {
         return Collections.unmodifiableMap(new HashMap<>(offsets));
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
index 688e852e62854..8aa58414a9d4f 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/RecordQueue.java
@@ -22,15 +22,16 @@
 import org.apache.kafka.common.utils.LogContext;
 import org.apache.kafka.streams.errors.DeserializationExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
-import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
 import org.apache.kafka.streams.processor.internals.metrics.TaskMetrics;
 import org.apache.kafka.streams.processor.api.ProcessorContext;
 import org.apache.kafka.streams.processor.TimestampExtractor;
+import org.apache.kafka.streams.processor.internals.metrics.TopicMetrics;
+
 import org.slf4j.Logger;
 
 import java.util.ArrayDeque;
 
-import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.consumerRecordSizeInBytes;
 
 /**
  * RecordQueue is a FIFO queue of {@link StampedRecord} (ConsumerRecord + timestamp). It also keeps track of the
@@ -75,7 +76,7 @@ public class RecordQueue {
             processorContext.taskId().toString(),
             processorContext.metrics()
         );
-        consumedSensor = ProcessorNodeMetrics.consumedSensor(
+        consumedSensor = TopicMetrics.consumedSensor(
             threadName,
             processorContext.taskId().toString(),
             source.name(),
@@ -115,10 +116,6 @@ public TopicPartition partition() {
         return partition;
     }
 
-    private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
-        return recordSizeInBytes(record.serializedKeySize(), record.serializedValueSize(), record.topic(), record.headers());
-    }
-
     /**
      * Add a batch of {@link ConsumerRecord} into the queue
      *
@@ -128,7 +125,7 @@ private long sizeInBytes(final ConsumerRecord<byte[], byte[]> record) {
     int addRawRecords(final Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) {
         for (final ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) {
             fifoQueue.addLast(rawRecord);
-            this.totalBytesBuffered += sizeInBytes(rawRecord);
+            this.totalBytesBuffered += consumerRecordSizeInBytes(rawRecord);
         }
 
         updateHead();
@@ -198,6 +195,10 @@ public void clear() {
         partitionTime = UNKNOWN;
     }
 
+    public void close() {
+        processorContext.metrics().removeSensor(consumedSensor);
+    }
+
     private void updateHead() {
         ConsumerRecord<byte[], byte[]> lastCorruptedRecord = null;
 
@@ -234,7 +235,7 @@ private void updateHead() {
                 continue;
             }
             headRecord = new StampedRecord(deserialized, timestamp);
-            headRecordSizeInBytes = sizeInBytes(raw);
+            headRecordSizeInBytes = consumerRecordSizeInBytes(raw);
         }
 
         // if all records in the FIFO queue are corrupted, make the last one the headRecord
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
index eb18d01dcf004..6f508eff2792a 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/SinkNode.java
@@ -16,15 +16,10 @@
  */
 package org.apache.kafka.streams.processor.internals;
 
-import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.serialization.Serializer;
 import org.apache.kafka.streams.processor.StreamPartitioner;
 import org.apache.kafka.streams.processor.TopicNameExtractor;
 import org.apache.kafka.streams.processor.api.Record;
-import org.apache.kafka.streams.processor.internals.metrics.ProcessorNodeMetrics;
-
-import java.util.HashMap;
-import java.util.Map;
 
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareKeySerializer;
 import static org.apache.kafka.streams.kstream.internals.WrappingNullableUtils.prepareValueSerializer;
@@ -36,8 +31,6 @@ public class SinkNode<KIn, VIn> extends ProcessorNode<KIn, VIn, Void, Void> {
     private final TopicNameExtractor<KIn, VIn> topicExtractor;
     private final StreamPartitioner<? super KIn, ? super VIn> partitioner;
 
-    private final Map<String, Sensor> producedSensorByTopic = new HashMap<>();
-
     private InternalProcessorContext<Void, Void> context;
 
     SinkNode(final String name,
@@ -89,19 +82,17 @@ public void process(final Record<KIn, VIn> record) {
 
         final String topic = topicExtractor.extract(key, value, contextForExtraction);
 
-        final long bytesProduced =
-            collector.send(topic, key, value, record.headers(), timestamp, keySerializer, valSerializer, partitioner);
-
-        producedSensorByTopic.putIfAbsent(
+        collector.send(
             topic,
-            ProcessorNodeMetrics.producedSensor(
-                Thread.currentThread().getName(),
-                context.taskId().toString(),
-                name(),
-                topic,
-                context.metrics()
-        ));
-        producedSensorByTopic.get(topic).record(bytesProduced, context.currentSystemTimeMs());
+            key,
+            value,
+            record.headers(),
+            timestamp,
+            keySerializer,
+            valSerializer,
+            name(),
+            context,
+            partitioner);
     }
 
     /**
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
index b02904a19984c..e7ebfdb900e38 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
@@ -637,6 +637,13 @@ private void close(final boolean clean) {
                     log
                 );
 
+                TaskManager.executeAndMaybeSwallow(
+                    clean,
+                    partitionGroup::close,
+                    "partition group close",
+                    log
+                );
+
                 break;
 
             case CLOSED:
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index a98fd6d2941a7..0a39b223dda84 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -19,7 +19,6 @@
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.metrics.Sensor.RecordingLevel;
 
-import java.util.HashMap;
 import java.util.Map;
 
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.AVG_LATENCY_DESCRIPTION;
@@ -37,7 +36,6 @@
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addInvocationRateAndCountToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addRateOfSumAndSumMetricsToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addAvgAndMaxToSensor;
-import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor;
 
 public class ProcessorNodeMetrics {
     private ProcessorNodeMetrics() {}
@@ -63,22 +61,6 @@ private ProcessorNodeMetrics() {}
     private static final String PROCESS_RATE_DESCRIPTION =
         RATE_DESCRIPTION_PREFIX + PROCESS_DESCRIPTION + RATE_DESCRIPTION_SUFFIX;
 
-    private static final String BYTES_CONSUMED = "bytes-consumed";
-    private static final String BYTES_CONSUMED_DESCRIPTION = "bytes consumed from this topic";
-    private static final String BYTES_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_CONSUMED_DESCRIPTION;
-
-    private static final String RECORDS_CONSUMED = "records-consumed";
-    private static final String RECORDS_CONSUMED_DESCRIPTION = "records consumed from this topic";
-    private static final String RECORDS_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_CONSUMED_DESCRIPTION;
-
-    private static final String BYTES_PRODUCED = "bytes-produced";
-    private static final String BYTES_PRODUCED_DESCRIPTION = "bytes produced to this topic";
-    private static final String BYTES_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_PRODUCED_DESCRIPTION;
-
-    private static final String RECORDS_PRODUCED = "records-produced";
-    private static final String RECORDS_PRODUCED_DESCRIPTION = "records produced to this topic";
-    private static final String RECORDS_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_PRODUCED_DESCRIPTION;
-
     private static final String FORWARD = "forward";
     private static final String FORWARD_DESCRIPTION = "calls to forward";
     private static final String FORWARD_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + FORWARD_DESCRIPTION;
@@ -154,48 +136,6 @@ public static Sensor processAtSourceSensor(final String threadId,
         );
     }
 
-    public static Sensor consumedSensor(final String threadId,
-                                        final String taskId,
-                                        final String processorNodeId,
-                                        final String topic,
-                                        final StreamsMetricsImpl streamsMetrics) {
-        final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_CONSUMED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
-        tagMap.put("topic", topic);
-        addTotalCountAndSumMetricsToSensor(
-            sensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            tagMap,
-            RECORDS_CONSUMED,
-            BYTES_CONSUMED,
-            RECORDS_CONSUMED_TOTAL_DESCRIPTION,
-            BYTES_CONSUMED_TOTAL_DESCRIPTION
-        );
-        return sensor;
-    }
-
-    public static Sensor producedSensor(final String threadId,
-                                        final String taskId,
-                                        final String processorNodeId,
-                                        final String topic,
-                                        final StreamsMetricsImpl streamsMetrics) {
-        final Sensor sensor =
-            streamsMetrics.nodeLevelSensor(threadId, taskId, processorNodeId, RECORDS_PRODUCED, RecordingLevel.INFO);
-        final Map<String, String> tagMap = new HashMap<>(streamsMetrics.nodeLevelTagMap(threadId, taskId, processorNodeId));
-        tagMap.put("topic", topic);
-        addTotalCountAndSumMetricsToSensor(
-            sensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            tagMap,
-            RECORDS_PRODUCED,
-            BYTES_PRODUCED,
-            RECORDS_PRODUCED_TOTAL_DESCRIPTION,
-            BYTES_PRODUCED_TOTAL_DESCRIPTION
-        );
-        return sensor;
-    }
-
     public static Sensor forwardSensor(final String threadId,
                                        final String taskId,
                                        final String processorNodeId,
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
index 4527765146c5b..4bfd96265b3aa 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImpl.java
@@ -95,6 +95,7 @@ public int hashCode() {
     private final Map<String, Deque<String>> threadLevelSensors = new HashMap<>();
     private final Map<String, Deque<String>> taskLevelSensors = new HashMap<>();
     private final Map<String, Deque<String>> nodeLevelSensors = new HashMap<>();
+    private final Map<String, Deque<String>> topicLevelSensors = new HashMap<>();
     private final Map<String, Deque<String>> cacheLevelSensors = new HashMap<>();
     private final ConcurrentMap<String, Deque<String>> storeLevelSensors = new ConcurrentHashMap<>();
     private final ConcurrentMap<String, Deque<MetricName>> storeLevelMetrics = new ConcurrentHashMap<>();
@@ -105,6 +106,7 @@ public int hashCode() {
     private static final String SENSOR_NAME_DELIMITER = ".s.";
     private static final String SENSOR_TASK_LABEL = "task";
     private static final String SENSOR_NODE_LABEL = "node";
+    private static final String SENSOR_TOPIC_LABEL = "topic";
     private static final String SENSOR_CACHE_LABEL = "cache";
     private static final String SENSOR_STORE_LABEL = "store";
     private static final String SENSOR_ENTITY_LABEL = "entity";
@@ -115,6 +117,7 @@ public int hashCode() {
     public static final String THREAD_ID_TAG = "thread-id";
     public static final String TASK_ID_TAG = "task-id";
     public static final String PROCESSOR_NODE_ID_TAG = "processor-node-id";
+    public static final String TOPIC_NAME_TAG = "topic-name";
     public static final String STORE_ID_TAG = "state-id";
     public static final String RECORD_CACHE_ID_TAG = "record-cache-id";
 
@@ -136,6 +139,7 @@ public int hashCode() {
     public static final String THREAD_LEVEL_GROUP = GROUP_PREFIX + "thread" + GROUP_SUFFIX;
     public static final String TASK_LEVEL_GROUP = GROUP_PREFIX + "task" + GROUP_SUFFIX;
     public static final String PROCESSOR_NODE_LEVEL_GROUP = GROUP_PREFIX + "processor-node" + GROUP_SUFFIX;
+    public static final String TOPIC_LEVEL_GROUP = GROUP_PREFIX + "topic" + GROUP_SUFFIX;
     public static final String STATE_STORE_LEVEL_GROUP = GROUP_PREFIX + "state" + GROUP_SUFFIX;
     public static final String CACHE_LEVEL_GROUP = GROUP_PREFIX + "record-cache" + GROUP_SUFFIX;
 
@@ -325,6 +329,15 @@ public Map<String, String> nodeLevelTagMap(final String threadId,
         return tagMap;
     }
 
+    public Map<String, String> topicLevelTagMap(final String threadId,
+                                                final String taskName,
+                                                final String processorNodeName,
+                                                final String topicName) {
+        final Map<String, String> tagMap = nodeLevelTagMap(threadId, taskName, processorNodeName);
+        tagMap.put(TOPIC_NAME_TAG, topicName);
+        return tagMap;
+    }
+
     public Map<String, String> storeLevelTagMap(final String taskName,
                                                 final String storeType,
                                                 final String storeName) {
@@ -388,6 +401,40 @@ private String nodeSensorPrefix(final String threadId, final String taskId, fina
             + SENSOR_PREFIX_DELIMITER + SENSOR_NODE_LABEL + SENSOR_PREFIX_DELIMITER + processorNodeName;
     }
 
+    public Sensor topicLevelSensor(final String threadId,
+                                   final String taskId,
+                                   final String processorNodeName,
+                                   final String topicName,
+                                   final String sensorName,
+                                   final Sensor.RecordingLevel recordingLevel,
+                                   final Sensor... parents) {
+        final String key = topicSensorPrefix(threadId, taskId, processorNodeName, topicName);
+        synchronized (topicLevelSensors) {
+            return getSensors(topicLevelSensors, sensorName, key, recordingLevel, parents);
+        }
+    }
+
+    public final void removeAllTopicLevelSensors(final String threadId,
+                                                 final String taskId,
+                                                 final String processorNodeName,
+                                                 final String topicName) {
+        final String key = topicSensorPrefix(threadId, taskId, processorNodeName, topicName);
+        synchronized (topicLevelSensors) {
+            final Deque<String> sensors = topicLevelSensors.remove(key);
+            while (sensors != null && !sensors.isEmpty()) {
+                metrics.removeSensor(sensors.pop());
+            }
+        }
+    }
+
+    private String topicSensorPrefix(final String threadId,
+                                     final String taskId,
+                                     final String processorNodeName,
+                                     final String topicName) {
+        return nodeSensorPrefix(threadId, taskId, processorNodeName)
+            + SENSOR_PREFIX_DELIMITER + SENSOR_TOPIC_LABEL + SENSOR_PREFIX_DELIMITER + topicName;
+    }
+
     public Sensor cacheLevelSensor(final String threadId,
                                    final String taskName,
                                    final String storeName,
diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetrics.java
new file mode 100644
index 0000000000000..85b438d969618
--- /dev/null
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetrics.java
@@ -0,0 +1,92 @@
+/*
+ * 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.kafka.streams.processor.internals.metrics;
+
+import org.apache.kafka.common.metrics.Sensor;
+import org.apache.kafka.common.metrics.Sensor.RecordingLevel;
+
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOPIC_LEVEL_GROUP;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOTAL_DESCRIPTION;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor;
+
+public class TopicMetrics {
+
+    private static final String CONSUMED = "consumed";
+    private static final String BYTES_CONSUMED = "bytes-consumed";
+    private static final String BYTES_CONSUMED_DESCRIPTION = "bytes consumed from this topic";
+    private static final String BYTES_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_CONSUMED_DESCRIPTION;
+    private static final String RECORDS_CONSUMED = "records-consumed";
+    private static final String RECORDS_CONSUMED_DESCRIPTION = "records consumed from this topic";
+    private static final String RECORDS_CONSUMED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_CONSUMED_DESCRIPTION;
+
+    private static final String PRODUCED = "produced";
+    private static final String BYTES_PRODUCED = "bytes-produced";
+    private static final String BYTES_PRODUCED_DESCRIPTION = "bytes produced to this topic";
+    private static final String BYTES_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + BYTES_PRODUCED_DESCRIPTION;
+    private static final String RECORDS_PRODUCED = "records-produced";
+    private static final String RECORDS_PRODUCED_DESCRIPTION = "records produced to this topic";
+    private static final String RECORDS_PRODUCED_TOTAL_DESCRIPTION = TOTAL_DESCRIPTION + RECORDS_PRODUCED_DESCRIPTION;
+
+    public static Sensor consumedSensor(final String threadId,
+                                        final String taskId,
+                                        final String processorNodeId,
+                                        final String topic,
+                                        final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor = streamsMetrics.topicLevelSensor(
+            threadId,
+            taskId,
+            processorNodeId,
+            topic,
+            CONSUMED,
+            RecordingLevel.INFO);
+        addTotalCountAndSumMetricsToSensor(
+            sensor,
+            TOPIC_LEVEL_GROUP,
+            streamsMetrics.topicLevelTagMap(threadId, taskId, processorNodeId, topic),
+            RECORDS_CONSUMED,
+            BYTES_CONSUMED,
+            RECORDS_CONSUMED_TOTAL_DESCRIPTION,
+            BYTES_CONSUMED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
+    public static Sensor producedSensor(final String threadId,
+                                        final String taskId,
+                                        final String processorNodeId,
+                                        final String topic,
+                                        final StreamsMetricsImpl streamsMetrics) {
+        final Sensor sensor = streamsMetrics.topicLevelSensor(
+            threadId,
+            taskId,
+            processorNodeId,
+            topic,
+            PRODUCED,
+            RecordingLevel.INFO);
+        addTotalCountAndSumMetricsToSensor(
+            sensor,
+            TOPIC_LEVEL_GROUP,
+            streamsMetrics.topicLevelTagMap(threadId, taskId, processorNodeId, topic),
+            RECORDS_PRODUCED,
+            BYTES_PRODUCED,
+            RECORDS_PRODUCED_TOTAL_DESCRIPTION,
+            BYTES_PRODUCED_TOTAL_DESCRIPTION
+        );
+        return sensor;
+    }
+
+}
diff --git a/streams/src/main/java/org/apache/kafka/streams/state/internals/InMemoryTimeOrderedKeyValueBuffer.java b/streams/src/main/java/org/apache/kafka/streams/state/internals/InMemoryTimeOrderedKeyValueBuffer.java
index a861da6469b47..5894023bbe1a5 100644
--- a/streams/src/main/java/org/apache/kafka/streams/state/internals/InMemoryTimeOrderedKeyValueBuffer.java
+++ b/streams/src/main/java/org/apache/kafka/streams/state/internals/InMemoryTimeOrderedKeyValueBuffer.java
@@ -292,8 +292,9 @@ private void logValue(final Bytes key, final BufferKey bufferKey, final BufferVa
             partition,
             null,
             KEY_SERIALIZER,
-            VALUE_SERIALIZER
-        );
+            VALUE_SERIALIZER,
+            null,
+            null);
     }
 
     private void logTombstone(final Bytes key) {
@@ -305,8 +306,9 @@ private void logTombstone(final Bytes key) {
             partition,
             null,
             KEY_SERIALIZER,
-            VALUE_SERIALIZER
-        );
+            VALUE_SERIALIZER,
+            null,
+            null);
     }
 
     private void restoreBatch(final Collection<ConsumerRecord<byte[], byte[]>> batch) {
diff --git a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
index 756544f44ec72..50c37bfcdcfd7 100644
--- a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
@@ -93,6 +93,7 @@ public static void closeCluster() {
     private static final String STREAM_THREAD_NODE_METRICS = "stream-thread-metrics";
     private static final String STREAM_TASK_NODE_METRICS = "stream-task-metrics";
     private static final String STREAM_PROCESSOR_NODE_METRICS = "stream-processor-node-metrics";
+    private static final String STREAM_TOPIC_METRICS = "stream-topic-metrics";
     private static final String STREAM_CACHE_NODE_METRICS = "stream-record-cache-metrics";
 
     private static final String IN_MEMORY_KVSTORE_TAG_KEY = "in-memory-state-id";
@@ -354,6 +355,7 @@ public void shouldAddMetricsOnAllLevels() throws Exception {
         checkThreadLevelMetrics();
         checkTaskLevelMetrics();
         checkProcessorNodeLevelMetrics();
+        checkTopicLevelMetrics();
         checkKeyValueStoreMetrics(IN_MEMORY_KVSTORE_TAG_KEY);
         checkKeyValueStoreMetrics(ROCKSDB_KVSTORE_TAG_KEY);
         checkKeyValueStoreMetrics(IN_MEMORY_LRUCACHE_TAG_KEY);
@@ -540,10 +542,18 @@ private void checkProcessorNodeLevelMetrics() {
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_AVG, numberOfSourceNodes + numberOfTerminalNodes);
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_MIN, numberOfSourceNodes + numberOfTerminalNodes);
         checkMetricByName(listMetricProcessor, RECORD_E2E_LATENCY_MAX, numberOfSourceNodes + numberOfTerminalNodes);
-        checkMetricByName(listMetricProcessor, BYTES_CONSUMED_TOTAL, numberOfSourceNodes);
-        checkMetricByName(listMetricProcessor, RECORDS_CONSUMED_TOTAL, numberOfSourceNodes);
-        checkMetricByName(listMetricProcessor, BYTES_PRODUCED_TOTAL, numberOfTerminalNodes);
-        checkMetricByName(listMetricProcessor, RECORDS_PRODUCED_TOTAL, numberOfTerminalNodes);
+    }
+
+    private void checkTopicLevelMetrics() {
+        final List<Metric> listMetricProcessor = new ArrayList<Metric>(kafkaStreams.metrics().values()).stream()
+            .filter(m -> m.metricName().group().equals(STREAM_TOPIC_METRICS))
+            .collect(Collectors.toList());
+        final int numberOfSourceTopics = 4;
+        final int numberOfSinkTopics = 4;
+        checkMetricByName(listMetricProcessor, BYTES_CONSUMED_TOTAL, numberOfSourceTopics);
+        checkMetricByName(listMetricProcessor, RECORDS_CONSUMED_TOTAL, numberOfSourceTopics);
+        checkMetricByName(listMetricProcessor, BYTES_PRODUCED_TOTAL, numberOfSinkTopics);
+        checkMetricByName(listMetricProcessor, RECORDS_PRODUCED_TOTAL, numberOfSinkTopics);
     }
 
     private void checkKeyValueStoreMetrics(final String tagKey) {
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ClientUtilsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ClientUtilsTest.java
index a6c5e3d0b4d31..775268496e518 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ClientUtilsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ClientUtilsTest.java
@@ -17,6 +17,7 @@
 package org.apache.kafka.streams.processor.internals;
 
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import org.apache.kafka.clients.admin.Admin;
@@ -24,29 +25,76 @@
 import org.apache.kafka.clients.admin.ListOffsetsResult;
 import org.apache.kafka.clients.admin.ListOffsetsResult.ListOffsetsResultInfo;
 import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.producer.ProducerRecord;
 import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.KafkaFuture;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.errors.TimeoutException;
+import org.apache.kafka.common.header.Headers;
+import org.apache.kafka.common.header.internals.RecordHeader;
+import org.apache.kafka.common.header.internals.RecordHeaders;
+import org.apache.kafka.common.record.TimestampType;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.easymock.EasyMock;
 import org.junit.Test;
 
+import static java.util.Arrays.asList;
 import static java.util.Collections.emptySet;
 import static org.apache.kafka.common.utils.Utils.mkSet;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.consumerRecordSizeInBytes;
 import static org.apache.kafka.streams.processor.internals.ClientUtils.fetchCommittedOffsets;
 import static org.apache.kafka.streams.processor.internals.ClientUtils.fetchEndOffsets;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.producerRecordSizeInBytes;
+
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.verify;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 public class ClientUtilsTest {
 
+    // consumer and producer records use utf8 encoding for topic name, header keys, etc
+    private static final String TOPIC = "topic";
+    private static final int TOPIC_BYTES = 5;
+
+    private static final byte[] KEY = "key".getBytes();
+    private static final int KEY_BYTES = 3;
+
+    private static final byte[] VALUE = "value".getBytes();
+    private static final int VALUE_BYTES = 5;
+
+    private static final Headers HEADERS = new RecordHeaders(asList(
+        new RecordHeader("h1", "headerVal1".getBytes()),   // 2 + 10 --> 12 bytes
+        new RecordHeader("h2", "headerVal2".getBytes())
+    ));    // 2 + 10 --> 12 bytes
+    private static final int HEADERS_BYTES = 24;
+
+    private static final int RECORD_METADATA_BYTES =
+        8 + // timestamp
+        8 + // offset
+        4;  // partition
+
+    // 57 bytes
+    private static final long SIZE_IN_BYTES =
+        KEY_BYTES +
+        VALUE_BYTES +
+        TOPIC_BYTES +
+        HEADERS_BYTES +
+        RECORD_METADATA_BYTES;
+
+    private static final long TOMBSTONE_SIZE_IN_BYTES =
+        KEY_BYTES +
+        TOPIC_BYTES +
+        HEADERS_BYTES +
+        RECORD_METADATA_BYTES;
+
     private static final Set<TopicPartition> PARTITIONS = mkSet(
-        new TopicPartition("topic", 1),
-        new TopicPartition("topic", 2)
+        new TopicPartition(TOPIC, 1),
+        new TopicPartition(TOPIC, 2)
     );
 
     @Test
@@ -121,5 +169,67 @@ public void fetchEndOffsetsShouldRethrowExecutionExceptionAsStreamsException() t
         assertThrows(StreamsException.class, () -> fetchEndOffsets(PARTITIONS, adminClient));
         verify(adminClient);
     }
+    
+    @Test
+    public void shouldComputeSizeInBytesForConsumerRecord() {
+        final ConsumerRecord<byte[], byte[]> record = new ConsumerRecord<>(
+            TOPIC,
+            1,
+            0L,
+            0L,
+            TimestampType.CREATE_TIME,
+            KEY_BYTES,
+            VALUE_BYTES,
+            KEY,
+            VALUE,
+            HEADERS,
+            Optional.empty()
+        );
+
+        assertThat(consumerRecordSizeInBytes(record), equalTo(SIZE_IN_BYTES));
+    }
+
+    @Test
+    public void shouldComputeSizeInBytesForProducerRecord() {
+        final ProducerRecord<byte[], byte[]> record = new ProducerRecord<>(
+            TOPIC,
+            1,
+            0L,
+            KEY,
+            VALUE,
+            HEADERS
+        );
+        assertThat(producerRecordSizeInBytes(record), equalTo(SIZE_IN_BYTES));
+    }
+
+    @Test
+    public void shouldComputeSizeInBytesForConsumerRecordWithNullValue() {
+        final ConsumerRecord<byte[], byte[]> record = new ConsumerRecord<>(
+            TOPIC,
+            1,
+            0,
+            0L,
+            TimestampType.CREATE_TIME,
+            KEY_BYTES,
+            0,
+            KEY,
+            null,
+            HEADERS,
+            Optional.empty()
+        );
+        assertThat(consumerRecordSizeInBytes(record), equalTo(TOMBSTONE_SIZE_IN_BYTES));
+    }
 
+    @Test
+    public void shouldComputeSizeInBytesForProducerRecordWithNullValue() {
+        final ProducerRecord<byte[], byte[]> record = new ProducerRecord<>(
+            TOPIC,
+            1,
+            0L,
+            KEY,
+            null,
+            HEADERS
+        );
+        assertThat(producerRecordSizeInBytes(record), equalTo(TOMBSTONE_SIZE_IN_BYTES));
+    }
 }
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
index e5d1b0fe769df..012373607e8f8 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/PartitionGroupTest.java
@@ -52,7 +52,7 @@
 import static org.apache.kafka.common.utils.Utils.mkEntry;
 import static org.apache.kafka.common.utils.Utils.mkMap;
 import static org.apache.kafka.common.utils.Utils.mkSet;
-import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.consumerRecordSizeInBytes;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -847,12 +847,7 @@ record = group.nextRecord(info, time.milliseconds());
     private long getBytesBufferedForRawRecords(final List<ConsumerRecord<byte[], byte[]>> rawRecords) {
         long rawRecordsSizeInBytes = 0L;
         for (final ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) {
-            rawRecordsSizeInBytes += recordSizeInBytes(
-                rawRecord.serializedKeySize(),
-                rawRecord.serializedValueSize(),
-                rawRecord.topic(),
-                rawRecord.headers()
-            );
+            rawRecordsSizeInBytes += consumerRecordSizeInBytes(rawRecord);
         }
         return rawRecordsSizeInBytes;
     }
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
index 73dda3c1a5611..3e1832048d917 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ProcessorContextImplTest.java
@@ -396,18 +396,18 @@ public void localSessionStoreShouldNotAllowInitOrClose() {
 
     @Test
     public void shouldNotSendRecordHeadersToChangelogTopic() {
-        EasyMock.expect(
-                recordCollector.send(
-                    CHANGELOG_PARTITION.topic(),
-                    KEY_BYTES,
-                    VALUE_BYTES,
-                    null,
-                    CHANGELOG_PARTITION.partition(),
-                    TIMESTAMP,
-                    BYTES_KEY_SERIALIZER,
-                    BYTEARRAY_VALUE_SERIALIZER))
-            .andStubReturn(0L);
-        
+        recordCollector.send(
+            CHANGELOG_PARTITION.topic(),
+            KEY_BYTES,
+            VALUE_BYTES,
+            null,
+            CHANGELOG_PARTITION.partition(),
+            TIMESTAMP,
+            BYTES_KEY_SERIALIZER,
+            BYTEARRAY_VALUE_SERIALIZER,
+            null,
+            null);
+
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 
         replay(recordCollector, task);
@@ -424,16 +424,17 @@ public void shouldSendRecordHeadersToChangelogTopicWhenConsistencyEnabled() {
         headers.add(ChangelogRecordDeserializationHelper.CHANGELOG_VERSION_HEADER_RECORD_CONSISTENCY);
         headers.add(new RecordHeader(ChangelogRecordDeserializationHelper.CHANGELOG_POSITION_HEADER_KEY,
                 PositionSerde.serialize(position).array()));
-        EasyMock.expect(recordCollector.send(
-                CHANGELOG_PARTITION.topic(),
-                KEY_BYTES,
-                VALUE_BYTES,
-                headers,
-                CHANGELOG_PARTITION.partition(),
-                TIMESTAMP,
-                BYTES_KEY_SERIALIZER,
-                BYTEARRAY_VALUE_SERIALIZER))
-            .andStubReturn(0L);
+        recordCollector.send(
+            CHANGELOG_PARTITION.topic(),
+            KEY_BYTES,
+            VALUE_BYTES,
+            headers,
+            CHANGELOG_PARTITION.partition(),
+            TIMESTAMP,
+            BYTES_KEY_SERIALIZER,
+            BYTEARRAY_VALUE_SERIALIZER,
+            null,
+            null);
 
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordCollectorTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordCollectorTest.java
index 2da9b397e512e..b3fa516a3f7e6 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordCollectorTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordCollectorTest.java
@@ -53,6 +53,7 @@
 import org.apache.kafka.streams.processor.TaskId;
 import org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl;
 import org.apache.kafka.streams.processor.internals.testutil.LogCaptureAppender;
+import org.apache.kafka.test.InternalMockProcessorContext;
 import org.apache.kafka.test.MockClientSupplier;
 
 import java.util.UUID;
@@ -69,6 +70,9 @@
 
 import static org.apache.kafka.common.utils.Utils.mkEntry;
 import static org.apache.kafka.common.utils.Utils.mkMap;
+import static org.apache.kafka.streams.processor.internals.ClientUtils.producerRecordSizeInBytes;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOPIC_LEVEL_GROUP;
+
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.expectLastCall;
 import static org.easymock.EasyMock.mock;
@@ -81,6 +85,10 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singletonMap;
 
 public class RecordCollectorTest {
 
@@ -99,6 +107,7 @@ public class RecordCollectorTest {
     ));
 
     private final String topic = "topic";
+    private final String sinkNodeName = "output-node";
     private final Cluster cluster = new Cluster(
         "cluster",
         Collections.singletonList(Node.noNode()),
@@ -120,6 +129,8 @@ public class RecordCollectorTest {
 
     private MockProducer<byte[], byte[]> mockProducer;
     private StreamsProducer streamsProducer;
+    private ProcessorTopology topology;
+    private final InternalProcessorContext<Void, Void> context = new InternalMockProcessorContext<>();
 
     private RecordCollectorImpl collector;
 
@@ -137,12 +148,29 @@ public void setup() {
             Time.SYSTEM
         );
         mockProducer = clientSupplier.producers.get(0);
+        final SinkNode<?, ?> sinkNode = new SinkNode<>(
+            sinkNodeName,
+            new StaticTopicNameExtractor<>(topic),
+            stringSerializer,
+            byteArraySerializer,
+            streamPartitioner);
+        topology = new ProcessorTopology(
+            emptyList(),
+            emptyMap(),
+            singletonMap(topic, sinkNode),
+            emptyList(),
+            emptyList(),
+            emptyMap(),
+            emptySet()
+        );
         collector = new RecordCollectorImpl(
             logContext,
             taskId,
             streamsProducer,
             productionExceptionHandler,
-            streamsMetrics);
+            streamsMetrics,
+            topology
+        );
     }
 
     @After
@@ -150,16 +178,73 @@ public void cleanup() {
         collector.closeClean();
     }
 
+    @Test
+    public void shouldRecordRecordsAndBytesProduced() {
+        final Headers headers = new RecordHeaders(new Header[]{new RecordHeader("key", "value".getBytes())});
+
+        final String threadId = Thread.currentThread().getName();
+        final String processorNodeId = sinkNodeName;
+        final String topic = "topic";
+        final Metric recordsProduced = streamsMetrics.metrics().get(
+            new MetricName("records-produced-total",
+                           TOPIC_LEVEL_GROUP,
+                           "The total number of records produced from this topic",
+                           streamsMetrics.topicLevelTagMap(threadId, taskId.toString(), processorNodeId, topic))
+        );
+        final Metric bytesProduced = streamsMetrics.metrics().get(
+            new MetricName("bytes-produced-total",
+                           TOPIC_LEVEL_GROUP,
+                           "The total number of bytes produced from this topic",
+                           streamsMetrics.topicLevelTagMap(threadId, taskId.toString(), processorNodeId, topic))
+        );
+
+        double totalRecords = 0D;
+        double totalBytes = 0D;
+
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, sinkNodeName, context);
+        ++totalRecords;
+        totalBytes += producerRecordSizeInBytes(mockProducer.history().get(0));
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+
+        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer, sinkNodeName, context);
+        ++totalRecords;
+        totalBytes += producerRecordSizeInBytes(mockProducer.history().get(1));
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, sinkNodeName, context);
+        ++totalRecords;
+        totalBytes += producerRecordSizeInBytes(mockProducer.history().get(2));
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+
+        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer, sinkNodeName, context);
+        ++totalRecords;
+        totalBytes += producerRecordSizeInBytes(mockProducer.history().get(3));
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, sinkNodeName, context);
+        ++totalRecords;
+        totalBytes += producerRecordSizeInBytes(mockProducer.history().get(4));
+        assertThat(recordsProduced.metricValue(), equalTo(totalRecords));
+        assertThat(bytesProduced.metricValue(), equalTo(totalBytes));
+    }
+
     @Test
     public void shouldSendToSpecificPartition() {
         final Headers headers = new RecordHeaders(new Header[] {new RecordHeader("key", "value".getBytes())});
 
-        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", headers, 2, null, stringSerializer, stringSerializer);
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", headers, 1, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", headers, 2, null, stringSerializer, stringSerializer, null, null);
 
         Map<TopicPartition, Long> offsets = collector.offsets();
 
@@ -168,9 +253,9 @@ public void shouldSendToSpecificPartition() {
         assertEquals(0L, (long) offsets.get(new TopicPartition(topic, 2)));
         assertEquals(6, mockProducer.history().size());
 
-        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", null, 1, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", headers, 2, null, stringSerializer, stringSerializer);
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", null, 1, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", headers, 2, null, stringSerializer, stringSerializer, null, null);
 
         offsets = collector.offsets();
 
@@ -184,15 +269,15 @@ public void shouldSendToSpecificPartition() {
     public void shouldSendWithPartitioner() {
         final Headers headers = new RecordHeaders(new Header[] {new RecordHeader("key", "value".getBytes())});
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "9", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "27", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "81", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "243", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "28", "0", headers, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "82", "0", headers, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "244", "0", headers, null, stringSerializer, stringSerializer, streamPartitioner);
-        collector.send(topic, "245", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "9", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "27", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "81", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "243", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "28", "0", headers, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "82", "0", headers, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "244", "0", headers, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
+        collector.send(topic, "245", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final Map<TopicPartition, Long> offsets = collector.offsets();
 
@@ -210,15 +295,15 @@ public void shouldSendWithPartitioner() {
     public void shouldSendWithNoPartition() {
         final Headers headers = new RecordHeaders(new Header[] {new RecordHeader("key", "value".getBytes())});
 
-        collector.send(topic, "3", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "9", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "27", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "81", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "243", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "28", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "82", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "244", "0", headers, null, null, stringSerializer, stringSerializer);
-        collector.send(topic, "245", "0", headers, null, null, stringSerializer, stringSerializer);
+        collector.send(topic, "3", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "9", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "27", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "81", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "243", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "28", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "82", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "244", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "245", "0", headers, null, null, stringSerializer, stringSerializer, null, null);
 
         final Map<TopicPartition, Long> offsets = collector.offsets();
 
@@ -233,9 +318,9 @@ public void shouldSendWithNoPartition() {
     public void shouldUpdateOffsetsUponCompletion() {
         Map<TopicPartition, Long> offsets = collector.offsets();
 
-        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", null, 1, null, stringSerializer, stringSerializer);
-        collector.send(topic, "999", "0", null, 2, null, stringSerializer, stringSerializer);
+        collector.send(topic, "999", "0", null, 0, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", null, 1, null, stringSerializer, stringSerializer, null, null);
+        collector.send(topic, "999", "0", null, 2, null, stringSerializer, stringSerializer, null, null);
 
         assertEquals(Collections.<TopicPartition, Long>emptyMap(), offsets);
 
@@ -253,7 +338,7 @@ public void shouldPassThroughRecordHeaderToSerializer() {
         final CustomStringSerializer valueSerializer = new CustomStringSerializer();
         keySerializer.configure(Collections.emptyMap(), true);
 
-        collector.send(topic, "3", "0", new RecordHeaders(), null, keySerializer, valueSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", new RecordHeaders(), null, keySerializer, valueSerializer, null, null, streamPartitioner);
 
         final List<ProducerRecord<byte[], byte[]>> recordHistory = mockProducer.history();
         for (final ProducerRecord<byte[], byte[]> sentRecord : recordHistory) {
@@ -270,14 +355,19 @@ public void shouldForwardFlushToStreamsProducer() {
         expect(streamsProducer.eosEnabled()).andReturn(false);
         streamsProducer.flush();
         expectLastCall();
-        replay(streamsProducer);
+
+        final ProcessorTopology topology = mock(ProcessorTopology.class);
+        expect(topology.sinkTopics()).andStubReturn(Collections.emptySet());
+        replay(streamsProducer, topology);
 
         final RecordCollector collector = new RecordCollectorImpl(
             logContext,
             taskId,
             streamsProducer,
             productionExceptionHandler,
-            streamsMetrics);
+            streamsMetrics, 
+            topology
+        );
 
         collector.flush();
 
@@ -290,14 +380,18 @@ public void shouldForwardFlushToStreamsProducerEosEnabled() {
         expect(streamsProducer.eosEnabled()).andReturn(true);
         streamsProducer.flush();
         expectLastCall();
-        replay(streamsProducer);
-
+        final ProcessorTopology topology = mock(ProcessorTopology.class);
+        expect(topology.sinkTopics()).andStubReturn(Collections.emptySet());
+        replay(streamsProducer, topology);
+        
         final RecordCollector collector = new RecordCollectorImpl(
             logContext,
             taskId,
             streamsProducer,
             productionExceptionHandler,
-            streamsMetrics);
+            streamsMetrics,
+            topology
+        );
 
         collector.flush();
 
@@ -308,15 +402,20 @@ public void shouldForwardFlushToStreamsProducerEosEnabled() {
     public void shouldNotAbortTxOnCloseCleanIfEosEnabled() {
         final StreamsProducer streamsProducer = mock(StreamsProducer.class);
         expect(streamsProducer.eosEnabled()).andReturn(true);
-        replay(streamsProducer);
-
+        
+        final ProcessorTopology topology = mock(ProcessorTopology.class);
+        expect(topology.sinkTopics()).andStubReturn(Collections.emptySet());
+        replay(streamsProducer, topology);
+        
         final RecordCollector collector = new RecordCollectorImpl(
             logContext,
             taskId,
             streamsProducer,
             productionExceptionHandler,
-            streamsMetrics);
-
+            streamsMetrics,
+            topology
+        );
+       
         collector.closeClean();
 
         verify(streamsProducer);
@@ -327,14 +426,19 @@ public void shouldAbortTxOnCloseDirtyIfEosEnabled() {
         final StreamsProducer streamsProducer = mock(StreamsProducer.class);
         expect(streamsProducer.eosEnabled()).andReturn(true);
         streamsProducer.abortTransaction();
-        replay(streamsProducer);
-
+        
+        final ProcessorTopology topology = mock(ProcessorTopology.class);
+        expect(topology.sinkTopics()).andStubReturn(Collections.emptySet());
+        replay(streamsProducer, topology);
+        
         final RecordCollector collector = new RecordCollectorImpl(
             logContext,
             taskId,
             streamsProducer,
             productionExceptionHandler,
-            streamsMetrics);
+            streamsMetrics,
+            topology
+        );
 
         collector.closeDirty();
 
@@ -354,7 +458,7 @@ public void shouldThrowInformativeStreamsExceptionOnKeyClassCastException() {
                 0,
                 0L,
                 (Serializer) new LongSerializer(), // need to add cast to trigger `ClassCastException`
-                new StringSerializer())
+                new StringSerializer(), null, null)
         );
 
         assertThat(expected.getCause(), instanceOf(ClassCastException.class));
@@ -382,7 +486,7 @@ public void shouldThrowInformativeStreamsExceptionOnKeyAndNullValueClassCastExce
                 0,
                 0L,
                 (Serializer) new LongSerializer(), // need to add cast to trigger `ClassCastException`
-                new StringSerializer())
+                new StringSerializer(), null, null)
         );
 
         assertThat(expected.getCause(), instanceOf(ClassCastException.class));
@@ -410,7 +514,7 @@ public void shouldThrowInformativeStreamsExceptionOnValueClassCastException() {
                 0,
                 0L,
                 new StringSerializer(),
-                (Serializer) new LongSerializer()) // need to add cast to trigger `ClassCastException`
+                (Serializer) new LongSerializer(), null, null) // need to add cast to trigger `ClassCastException`
         );
 
         assertThat(expected.getCause(), instanceOf(ClassCastException.class));
@@ -438,7 +542,7 @@ public void shouldThrowInformativeStreamsExceptionOnValueAndNullKeyClassCastExce
                 0,
                 0L,
                 new StringSerializer(),
-                (Serializer) new LongSerializer()) // need to add cast to trigger `ClassCastException`
+                (Serializer) new LongSerializer(), null, null) // need to add cast to trigger `ClassCastException`
         );
 
         assertThat(expected.getCause(), instanceOf(ClassCastException.class));
@@ -460,13 +564,14 @@ public void shouldThrowInformativeStreamsExceptionOnKafkaExceptionFromStreamPart
             taskId,
             getExceptionalStreamProducerOnPartitionsFor(new KafkaException("Kaboom!")),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
         final StreamsException exception = assertThrows(
             StreamsException.class,
-            () -> collector.send(topic, "0", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "0", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertThat(
             exception.getMessage(),
@@ -491,13 +596,14 @@ private <E extends RuntimeException> void shouldForwardExceptionWithoutWrappingI
             taskId,
             getExceptionalStreamProducerOnPartitionsFor(runtimeException),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
         final RuntimeException exception = assertThrows(
             runtimeException.getClass(),
-            () -> collector.send(topic, "0", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "0", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertThat(exception.getMessage(), equalTo("Kaboom!"));
     }
@@ -518,15 +624,16 @@ private void testThrowTaskMigratedExceptionOnSubsequentSend(final RuntimeExcepti
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final TaskMigratedException thrown = assertThrows(
             TaskMigratedException.class,
-            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertEquals(exception, thrown.getCause());
     }
@@ -547,11 +654,12 @@ private void testThrowTaskMigratedExceptionOnSubsequentFlush(final RuntimeExcept
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final TaskMigratedException thrown = assertThrows(TaskMigratedException.class, collector::flush);
         assertEquals(exception, thrown.getCause());
@@ -573,11 +681,12 @@ private void testThrowTaskMigratedExceptionOnSubsequentClose(final RuntimeExcept
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final TaskMigratedException thrown = assertThrows(TaskMigratedException.class, collector::closeClean);
         assertEquals(exception, thrown.getCause());
@@ -591,14 +700,15 @@ public void shouldThrowStreamsExceptionOnSubsequentSendIfASendFailsWithDefaultEx
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(
             StreamsException.class,
-            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertEquals(exception, thrown.getCause());
         assertThat(
@@ -617,10 +727,11 @@ public void shouldThrowStreamsExceptionOnSubsequentFlushIfASendFailsWithDefaultE
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(StreamsException.class, collector::flush);
         assertEquals(exception, thrown.getCause());
@@ -640,10 +751,11 @@ public void shouldThrowStreamsExceptionOnSubsequentCloseIfASendFailsWithDefaultE
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(StreamsException.class, collector::closeClean);
         assertEquals(exception, thrown.getCause());
@@ -663,14 +775,15 @@ public void shouldThrowStreamsExceptionOnSubsequentSendIfFatalEvenWithContinueEx
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             new AlwaysContinueProductionExceptionHandler(),
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(
             StreamsException.class,
-            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertEquals(exception, thrown.getCause());
         assertThat(
@@ -689,10 +802,11 @@ public void shouldThrowStreamsExceptionOnSubsequentFlushIfFatalEvenWithContinueE
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             new AlwaysContinueProductionExceptionHandler(),
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(StreamsException.class, collector::flush);
         assertEquals(exception, thrown.getCause());
@@ -712,10 +826,11 @@ public void shouldThrowStreamsExceptionOnSubsequentCloseIfFatalEvenWithContinueE
             taskId,
             getExceptionalStreamsProducerOnSend(exception),
             new AlwaysContinueProductionExceptionHandler(),
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
 
         final StreamsException thrown = assertThrows(StreamsException.class, collector::closeClean);
         assertEquals(exception, thrown.getCause());
@@ -734,13 +849,14 @@ public void shouldNotThrowStreamsExceptionOnSubsequentCallIfASendFailsWithContin
             taskId,
             getExceptionalStreamsProducerOnSend(new Exception()),
             new AlwaysContinueProductionExceptionHandler(),
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
         try (final LogCaptureAppender logCaptureAppender =
                  LogCaptureAppender.createAndRegister(RecordCollectorImpl.class)) {
 
-            collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+            collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
             collector.flush();
 
             final List<String> messages = logCaptureAppender.getMessages();
@@ -766,7 +882,7 @@ public void shouldNotThrowStreamsExceptionOnSubsequentCallIfASendFailsWithContin
         ));
         assertEquals(1.0, metric.metricValue());
 
-        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner);
+        collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner);
         collector.flush();
         collector.closeClean();
     }
@@ -797,7 +913,8 @@ public void abortTransaction() {
                 Time.SYSTEM
             ),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
         collector.closeDirty();
@@ -829,13 +946,14 @@ public List<PartitionInfo> partitionsFor(final String topic) {
                 Time.SYSTEM
             ),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
         collector.initialize();
 
         final StreamsException thrown = assertThrows(
             StreamsException.class,
-            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, streamPartitioner)
+            () -> collector.send(topic, "3", "0", null, null, stringSerializer, stringSerializer, null, null, streamPartitioner)
         );
         assertThat(
             thrown.getMessage(),
@@ -864,7 +982,8 @@ public Producer<byte[], byte[]> getProducer(final Map<String, Object> config) {
                 Time.SYSTEM
             ),
             productionExceptionHandler,
-            streamsMetrics
+            streamsMetrics,
+            topology
         );
 
         collector.closeClean();
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
index efb42c0c28006..9741ba1c17e99 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/RecordQueueTest.java
@@ -17,9 +17,12 @@
 package org.apache.kafka.streams.processor.internals;
 
 import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.common.Metric;
+import org.apache.kafka.common.MetricName;
 import org.apache.kafka.common.TopicPartition;
 import org.apache.kafka.common.errors.SerializationException;
 import org.apache.kafka.common.header.internals.RecordHeaders;
+import org.apache.kafka.common.metrics.Metrics;
 import org.apache.kafka.common.record.TimestampType;
 import org.apache.kafka.common.serialization.Deserializer;
 import org.apache.kafka.common.serialization.IntegerDeserializer;
@@ -28,12 +31,15 @@
 import org.apache.kafka.common.serialization.Serializer;
 import org.apache.kafka.common.utils.Bytes;
 import org.apache.kafka.common.utils.LogContext;
+import org.apache.kafka.common.utils.MockTime;
+import org.apache.kafka.streams.StreamsConfig;
 import org.apache.kafka.streams.errors.LogAndContinueExceptionHandler;
 import org.apache.kafka.streams.errors.LogAndFailExceptionHandler;
 import org.apache.kafka.streams.errors.StreamsException;
 import org.apache.kafka.streams.processor.FailOnInvalidTimestamp;
 import org.apache.kafka.streams.processor.LogAndSkipOnInvalidTimestamp;
 import org.apache.kafka.streams.processor.TimestampExtractor;
+import org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl;
 import org.apache.kafka.streams.state.StateSerdes;
 import org.apache.kafka.test.InternalMockProcessorContext;
 import org.apache.kafka.test.MockRecordCollector;
@@ -48,6 +54,9 @@
 import java.util.List;
 import java.util.Optional;
 
+import static org.apache.kafka.streams.processor.internals.ClientUtils.consumerRecordSizeInBytes;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOPIC_LEVEL_GROUP;
+
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.equalTo;
@@ -62,10 +71,15 @@ public class RecordQueueTest {
     private final Deserializer<Integer> intDeserializer = new IntegerDeserializer();
     private final TimestampExtractor timestampExtractor = new MockTimestampExtractor();
 
+    private final Metrics metrics = new Metrics();
+    private final StreamsMetricsImpl streamsMetrics =
+        new StreamsMetricsImpl(metrics, "mock", StreamsConfig.METRICS_LATEST, new MockTime());
+
     @SuppressWarnings("rawtypes")
     final InternalMockProcessorContext context = new InternalMockProcessorContext<>(
         StateSerdes.withBuiltinTypes("anyName", Bytes.class, Bytes.class),
-        new MockRecordCollector()
+        new MockRecordCollector(),
+        metrics
     );
     private final MockSourceNode<Integer, Integer> mockSourceNodeWithMetrics
         = new MockSourceNode<>(intDeserializer, intDeserializer);
@@ -98,6 +112,57 @@ public void after() {
         mockSourceNodeWithMetrics.close();
     }
 
+    @Test
+    public void testConsumedSensor() {
+        final List<ConsumerRecord<byte[], byte[]>> records = Arrays.asList(
+            new ConsumerRecord<>("topic", 1, 1, 0L, TimestampType.CREATE_TIME, 0, 0, recordKey, recordValue, new RecordHeaders(), Optional.empty()),
+            new ConsumerRecord<>("topic", 1, 2, 0L, TimestampType.CREATE_TIME, 0, 0, recordKey, recordValue, new RecordHeaders(), Optional.empty()),
+            new ConsumerRecord<>("topic", 1, 3, 0L, TimestampType.CREATE_TIME, 0, 0, recordKey, recordValue, new RecordHeaders(), Optional.empty()));
+
+        queue.addRawRecords(records);
+
+        final String threadId = Thread.currentThread().getName();
+        final String taskId = context.taskId().toString();
+        final String processorNodeId = mockSourceNodeWithMetrics.name();
+        final String topic = "topic";
+        final Metric recordsConsumed = context.metrics().metrics().get(
+            new MetricName("records-consumed-total",
+                           TOPIC_LEVEL_GROUP,
+                           "The total number of records consumed from this topic",
+                           streamsMetrics.topicLevelTagMap(threadId, taskId, processorNodeId, topic))
+        );
+        final Metric bytesConsumed = context.metrics().metrics().get(
+            new MetricName("bytes-consumed-total",
+                           TOPIC_LEVEL_GROUP,
+                           "The total number of bytes consumed from this topic",
+                           streamsMetrics.topicLevelTagMap(threadId, taskId, processorNodeId, topic))
+        );
+
+        double totalBytes = 0D;
+        double totalRecords = 0D;
+
+        queue.poll(5L);
+        ++totalRecords;
+        totalBytes += consumerRecordSizeInBytes(records.get(0));
+
+        assertThat(bytesConsumed.metricValue(), equalTo(totalBytes));
+        assertThat(recordsConsumed.metricValue(), equalTo(totalRecords));
+
+        queue.poll(6L);
+        ++totalRecords;
+        totalBytes += consumerRecordSizeInBytes(records.get(1));
+
+        assertThat(bytesConsumed.metricValue(), equalTo(totalBytes));
+        assertThat(recordsConsumed.metricValue(), equalTo(totalRecords));
+
+        queue.poll(7L);
+        ++totalRecords;
+        totalBytes += consumerRecordSizeInBytes(records.get(2));
+
+        assertThat(bytesConsumed.metricValue(), equalTo(totalBytes));
+        assertThat(recordsConsumed.metricValue(), equalTo(totalRecords));
+    }
+
     @Test
     public void testTimeTracking() {
         assertTrue(queue.isEmpty());
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
index 1c806bdc07c0e..d9a68a81b6d52 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/WriteConsistencyVectorTest.java
@@ -114,17 +114,17 @@ public void shouldSendConsistencyVectorToChangelogTopic() {
         headers.add(new RecordHeader(
                 ChangelogRecordDeserializationHelper.CHANGELOG_POSITION_HEADER_KEY,
                 PositionSerde.serialize(position).array()));
-        EasyMock.expect(
-                recordCollector.send(
-                    CHANGELOG_PARTITION.topic(),
-                    KEY_BYTES,
-                    VALUE_BYTES,
-                    headers,
-                    CHANGELOG_PARTITION.partition(),
-                    TIMESTAMP,
-                    BYTES_KEY_SERIALIZER,
-                    BYTEARRAY_VALUE_SERIALIZER))
-            .andStubReturn(0L);
+        recordCollector.send(
+            CHANGELOG_PARTITION.topic(),
+            KEY_BYTES,
+            VALUE_BYTES,
+            headers,
+            CHANGELOG_PARTITION.partition(),
+            TIMESTAMP,
+            BYTES_KEY_SERIALIZER,
+            BYTEARRAY_VALUE_SERIALIZER,
+            null,
+            null);
 
         final StreamTask task = EasyMock.createNiceMock(StreamTask.class);
 
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
index 34f32d715eb75..0ae1a99e6f53a 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetricsTest.java
@@ -24,7 +24,6 @@
 
 
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Supplier;
 
@@ -37,7 +36,6 @@ public class ProcessorNodeMetricsTest {
     private static final String THREAD_ID = "test-thread";
     private static final String TASK_ID = "test-task";
     private static final String PROCESSOR_NODE_ID = "test-processor";
-    private static final String TOPIC_NAME = "topic";
 
     private final Map<String, String> tagMap = Collections.singletonMap("hello", "world");
     private final Map<String, String> parentTagMap = Collections.singletonMap("hi", "universe");
@@ -116,63 +114,6 @@ public void shouldGetProcessAtSourceSensor() {
         verifySensor(() -> ProcessorNodeMetrics.processAtSourceSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, streamsMetrics));
     }
 
-    @Test
-    public void shouldGetRecordsAndBytesConsumedSensor() {
-        final String recordsMetricNamePrefix = "records-consumed";
-        final String bytesMetricNamePrefix = "bytes-consumed";
-        final String descriptionOfRecordsTotal = "The total number of records consumed from this topic";
-        final String descriptionOfBytesTotal = "The total number of bytes consumed from this topic";
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, recordsMetricNamePrefix, RecordingLevel.INFO))
-            .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, bytesMetricNamePrefix, RecordingLevel.INFO))
-            .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
-
-        final Map<String, String> consumedTagMap = new HashMap<>(tagMap);
-        consumedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
-            expectedSensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            consumedTagMap,
-            recordsMetricNamePrefix,
-            bytesMetricNamePrefix,
-            descriptionOfRecordsTotal,
-            descriptionOfBytesTotal
-        );
-        verifySensor(
-            () -> ProcessorNodeMetrics.consumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
-        );
-    }
-
-    @Test
-    public void shouldGetRecordsAndBytesProducedSensor() {
-        final String recordsMetricNamePrefix = "records-produced";
-        final String bytesMetricNamePrefix = "bytes-produced";
-        final String descriptionOfRecordsTotal = "The total number of records produced to this topic";
-        final String descriptionOfBytesTotal = "The total number of bytes produced to this topic";
-
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, recordsMetricNamePrefix, RecordingLevel.INFO))
-            .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, bytesMetricNamePrefix, RecordingLevel.INFO))
-            .thenReturn(expectedSensor);
-        when(streamsMetrics.nodeLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID)).thenReturn(tagMap);
-
-        final Map<String, String> producedTagMap = new HashMap<>(tagMap);
-        producedTagMap.put("topic", TOPIC_NAME);
-        StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
-            expectedSensor,
-            PROCESSOR_NODE_LEVEL_GROUP,
-            producedTagMap,
-            recordsMetricNamePrefix,
-            bytesMetricNamePrefix,
-            descriptionOfRecordsTotal,
-            descriptionOfBytesTotal
-        );
-        verifySensor(
-            () -> ProcessorNodeMetrics.producedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
-        );
-    }
-
     @Test
     public void shouldGetForwardSensor() {
         final String metricNamePrefix = "forward";
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
index 24cf8c7f1cc65..fb6654255bd77 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
@@ -58,6 +58,7 @@
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.ROLLUP_VALUE;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.STATE_STORE_LEVEL_GROUP;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.THREAD_LEVEL_GROUP;
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOPIC_LEVEL_GROUP;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOTAL_SUFFIX;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addAvgAndMaxLatencyToSensor;
 import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.addInvocationRateAndCountToSensor;
@@ -99,6 +100,10 @@ public class StreamsMetricsImplTest {
     private final static String THREAD_ID1 = "test-thread-1";
     private final static String TASK_ID1 = "test-task-1";
     private final static String TASK_ID2 = "test-task-2";
+    private final static String NODE_ID1 = "test-node-1";
+    private final static String NODE_ID2 = "test-node-2";
+    private final static String TOPIC_ID1 = "test-topic-1";
+    private final static String TOPIC_ID2 = "test-topic-2";
     private final static String METRIC_NAME1 = "test-metric1";
     private final static String METRIC_NAME2 = "test-metric2";
     private final static String THREAD_ID_TAG = "thread-id";
@@ -319,6 +324,46 @@ public void shouldGetExistingTaskLevelSensor() {
         assertThat(actualSensor, is(equalToObject(sensor)));
     }
 
+    @Test
+    public void shouldGetNewTopicLevelSensor() {
+        final Metrics metrics = mock(Metrics.class);
+        final RecordingLevel recordingLevel = RecordingLevel.INFO;
+        setupGetNewSensorTest(metrics, recordingLevel);
+        final StreamsMetricsImpl streamsMetrics = new StreamsMetricsImpl(metrics, CLIENT_ID, VERSION, time);
+
+        final Sensor actualSensor = streamsMetrics.topicLevelSensor(
+            THREAD_ID1,
+            TASK_ID1,
+            NODE_ID1,
+            TOPIC_ID1,
+            SENSOR_NAME_1,
+            recordingLevel
+        );
+
+        verify(metrics);
+        assertThat(actualSensor, is(equalToObject(sensor)));
+    }
+
+    @Test
+    public void shouldGetExistingTopicLevelSensor() {
+        final Metrics metrics = mock(Metrics.class);
+        final RecordingLevel recordingLevel = RecordingLevel.INFO;
+        setupGetExistingSensorTest(metrics);
+        final StreamsMetricsImpl streamsMetrics = new StreamsMetricsImpl(metrics, CLIENT_ID, VERSION, time);
+
+        final Sensor actualSensor = streamsMetrics.topicLevelSensor(
+            THREAD_ID1,
+            TASK_ID1,
+            NODE_ID1,
+            TOPIC_ID1,
+            SENSOR_NAME_1,
+            recordingLevel
+        );
+
+        verify(metrics);
+        assertThat(actualSensor, is(equalToObject(sensor)));
+    }
+
     @Test
     public void shouldGetNewStoreLevelSensorIfNoneExists() {
         final Metrics metrics = mock(Metrics.class);
@@ -505,14 +550,13 @@ public void shouldRemoveStateStoreLevelSensors() {
     public void shouldGetNewNodeLevelSensor() {
         final Metrics metrics = mock(Metrics.class);
         final RecordingLevel recordingLevel = RecordingLevel.INFO;
-        final String processorNodeName = "processorNodeName";
         setupGetNewSensorTest(metrics, recordingLevel);
         final StreamsMetricsImpl streamsMetrics = new StreamsMetricsImpl(metrics, CLIENT_ID, VERSION, time);
 
         final Sensor actualSensor = streamsMetrics.nodeLevelSensor(
             THREAD_ID1,
             TASK_ID1,
-            processorNodeName,
+            NODE_ID1,
             SENSOR_NAME_1,
             recordingLevel
         );
@@ -525,14 +569,13 @@ public void shouldGetNewNodeLevelSensor() {
     public void shouldGetExistingNodeLevelSensor() {
         final Metrics metrics = mock(Metrics.class);
         final RecordingLevel recordingLevel = RecordingLevel.INFO;
-        final String processorNodeName = "processorNodeName";
         setupGetExistingSensorTest(metrics);
         final StreamsMetricsImpl streamsMetrics = new StreamsMetricsImpl(metrics, CLIENT_ID, VERSION, time);
 
         final Sensor actualSensor = streamsMetrics.nodeLevelSensor(
             THREAD_ID1,
             TASK_ID1,
-            processorNodeName,
+            NODE_ID1,
             SENSOR_NAME_1,
             recordingLevel
         );
@@ -732,6 +775,9 @@ public void testMultiLevelSensorRemoval() {
         final String processorNodeName = "processorNodeName";
         final Map<String, String> nodeTags = mkMap(mkEntry("nkey", "value"));
 
+        final String topicName = "topicName";
+        final Map<String, String> topicTags = mkMap(mkEntry("tkey", "value"));
+
         final Sensor parent1 = metrics.taskLevelSensor(THREAD_ID1, taskName, operation, RecordingLevel.DEBUG);
         addAvgAndMaxLatencyToSensor(parent1, PROCESSOR_NODE_LEVEL_GROUP, taskTags, operation);
         addInvocationRateAndCountToSensor(parent1, PROCESSOR_NODE_LEVEL_GROUP, taskTags, operation, "", "");
@@ -744,6 +790,18 @@ public void testMultiLevelSensorRemoval() {
 
         assertThat(registry.metrics().size(), greaterThan(numberOfTaskMetrics));
 
+        final int numberOfNodeMetrics = registry.metrics().size();
+
+        final Sensor child1 = metrics.topicLevelSensor(THREAD_ID1, taskName, processorNodeName, topicName, operation, RecordingLevel.DEBUG, sensor1);
+        addAvgAndMaxLatencyToSensor(child1, TOPIC_LEVEL_GROUP, topicTags, operation);
+        addInvocationRateAndCountToSensor(child1, TOPIC_LEVEL_GROUP, topicTags, operation, "", "");
+
+        assertThat(registry.metrics().size(), greaterThan(numberOfNodeMetrics));
+
+        metrics.removeAllTopicLevelSensors(THREAD_ID1, taskName, processorNodeName, topicName);
+
+        assertThat(registry.metrics().size(), equalTo(numberOfNodeMetrics));
+
         metrics.removeAllNodeLevelSensors(THREAD_ID1, taskName, processorNodeName);
 
         assertThat(registry.metrics().size(), equalTo(numberOfTaskMetrics));
@@ -1104,6 +1162,22 @@ public void shouldAddValue() {
         assertThat(metrics.metrics().size(), equalTo(1 + 1)); // one metric is added automatically in the constructor of Metrics
     }
 
+    @Test
+    public void shouldAddTotalCountAndSumMetricsToSensor() {
+        final String totalMetricNamePrefix = "total";
+        final String sumMetricNamePrefix = "count";
+        StreamsMetricsImpl
+            .addTotalCountAndSumMetricsToSensor(sensor, group, tags, totalMetricNamePrefix, sumMetricNamePrefix, DESCRIPTION1, DESCRIPTION2);
+
+        final double valueToRecord1 = 18.0;
+        final double valueToRecord2 = 42.0;
+        final double expectedCountMetricValue = 4;
+        verifyMetric(totalMetricNamePrefix + "-total", DESCRIPTION1, valueToRecord1, valueToRecord2, expectedCountMetricValue);
+        final double expectedSumMetricValue = 2 * valueToRecord1 + 2 * valueToRecord2; // values are recorded once for each metric verification
+        verifyMetric(sumMetricNamePrefix + "-total", DESCRIPTION2, valueToRecord1, valueToRecord2, expectedSumMetricValue);
+        assertThat(metrics.metrics().size(), equalTo(2 + 1)); // one metric is added automatically in the constructor of Metrics
+    }
+
     @Test
     public void shouldAddAvgAndTotalMetricsToSensor() {
         StreamsMetricsImpl
diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
new file mode 100644
index 0000000000000..989fed037e856
--- /dev/null
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
@@ -0,0 +1,112 @@
+/*
+ * 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.kafka.streams.processor.internals.metrics;
+
+import org.apache.kafka.common.metrics.Sensor;
+import org.apache.kafka.common.metrics.Sensor.RecordingLevel;
+
+import org.junit.Test;
+import org.mockito.MockedStatic;
+import java.util.Collections;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import static org.apache.kafka.streams.processor.internals.metrics.StreamsMetricsImpl.TOPIC_LEVEL_GROUP;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+public class TopicMetricsTest {
+
+    private static final String THREAD_ID = "test-thread";
+    private static final String TASK_ID = "test-task";
+    private static final String PROCESSOR_NODE_ID = "test-processor";
+    private static final String TOPIC_NAME = "topic";
+
+    private final Map<String, String> tagMap = Collections.singletonMap("hello", "world");
+
+    private final Sensor expectedSensor = mock(Sensor.class);
+    private static final MockedStatic<StreamsMetricsImpl> streamsMetricsMockedStatic = mockStatic(StreamsMetricsImpl.class);
+    private final StreamsMetricsImpl streamsMetrics = mock(StreamsMetricsImpl.class);
+
+    @Test
+    public void shouldGetRecordsAndBytesConsumedSensor() {
+        final String recordsMetricNamePrefix = "records-consumed";
+        final String bytesMetricNamePrefix = "bytes-consumed";
+        final String descriptionOfRecordsTotal = "The total number of records consumed from this topic";
+        final String descriptionOfBytesTotal = "The total number of bytes consumed from this topic";
+
+        when(streamsMetrics.topicLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, "consumed", RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.topicLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, "consumed", RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.topicLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME)).thenReturn(tagMap);
+
+        verifySensor(
+            () -> TopicMetrics.consumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
+        );
+
+        streamsMetricsMockedStatic.verify(
+            () -> StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
+                expectedSensor,
+                TOPIC_LEVEL_GROUP,
+                tagMap,
+                recordsMetricNamePrefix,
+                bytesMetricNamePrefix,
+                descriptionOfRecordsTotal,
+                descriptionOfBytesTotal
+            )
+        );
+    }
+
+    @Test
+    public void shouldGetRecordsAndBytesProducedSensor() {
+        final String recordsMetricNamePrefix = "records-produced";
+        final String bytesMetricNamePrefix = "bytes-produced";
+        final String descriptionOfRecordsTotal = "The total number of records produced to this topic";
+        final String descriptionOfBytesTotal = "The total number of bytes produced to this topic";
+
+        when(streamsMetrics.topicLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, "produced", RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.topicLevelSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, "produced", RecordingLevel.INFO))
+            .thenReturn(expectedSensor);
+        when(streamsMetrics.topicLevelTagMap(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME)).thenReturn(tagMap);
+
+        verifySensor(() -> TopicMetrics.producedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics));
+
+        streamsMetricsMockedStatic.verify(
+            () -> StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
+                expectedSensor,
+                TOPIC_LEVEL_GROUP,
+                tagMap,
+                recordsMetricNamePrefix,
+                bytesMetricNamePrefix,
+                descriptionOfRecordsTotal,
+                descriptionOfBytesTotal
+            )
+        );
+    }
+
+    private void verifySensor(final Supplier<Sensor> sensorSupplier) {
+        final Sensor sensor = sensorSupplier.get();
+        assertThat(sensor, is(expectedSensor));
+    }
+
+}
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
index 8624497ef9081..178399426076f 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/KeyValueStoreTestDriver.java
@@ -32,7 +32,9 @@
 import org.apache.kafka.streams.processor.StateStoreContext;
 import org.apache.kafka.streams.processor.StreamPartitioner;
 import org.apache.kafka.streams.processor.TaskId;
+import org.apache.kafka.streams.processor.internals.InternalProcessorContext;
 import org.apache.kafka.streams.processor.internals.MockStreamsMetrics;
+import org.apache.kafka.streams.processor.internals.ProcessorTopology;
 import org.apache.kafka.streams.processor.internals.RecordCollector;
 import org.apache.kafka.streams.processor.internals.RecordCollectorImpl;
 import org.apache.kafka.streams.processor.internals.StreamsProducer;
@@ -45,6 +47,7 @@
 import org.apache.kafka.test.TestUtils;
 
 import java.io.File;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -54,7 +57,8 @@
 import java.util.Properties;
 import java.util.Set;
 
-import static org.apache.kafka.streams.processor.internals.ClientUtils.recordSizeInBytes;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 /**
  * A component that provides a {@link #context() ProcessingContext} that can be supplied to a {@link KeyValueStore} so that
@@ -201,6 +205,9 @@ private KeyValueStoreTestDriver(final StateSerdes<K, V> serdes) {
         props.put(StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG, MockRocksDbConfigSetter.class);
         props.put(StreamsConfig.METRICS_RECORDING_LEVEL_CONFIG, "DEBUG");
 
+        final ProcessorTopology topology = mock(ProcessorTopology.class);
+        when(topology.sinkTopics()).thenReturn(Collections.emptySet());
+
         final LogContext logContext = new LogContext("KeyValueStoreTestDriver ");
         final RecordCollector recordCollector = new RecordCollectorImpl(
             logContext,
@@ -214,17 +221,20 @@ private KeyValueStoreTestDriver(final StateSerdes<K, V> serdes) {
                 logContext,
                 Time.SYSTEM),
             new DefaultProductionExceptionHandler(),
-            new MockStreamsMetrics(new Metrics())
+            new MockStreamsMetrics(new Metrics()),
+            topology
         ) {
             @Override
-            public <K1, V1> long send(final String topic,
+            public <K1, V1> void send(final String topic,
                                       final K1 key,
                                       final V1 value,
                                       final Headers headers,
                                       final Integer partition,
                                       final Long timestamp,
                                       final Serializer<K1> keySerializer,
-                                      final Serializer<V1> valueSerializer) {
+                                      final Serializer<V1> valueSerializer,
+                                      final String processorNodeId,
+                                      final InternalProcessorContext<Void, Void> context) {
                 // for byte arrays we need to wrap it for comparison
 
                 final byte[] keyBytes = keySerializer.serialize(topic, headers, key);
@@ -234,17 +244,18 @@ public <K1, V1> long send(final String topic,
                 final V valueTest = serdes.valueFrom(valueBytes);
 
                 recordFlushed(keyTest, valueTest);
-                return recordSizeInBytes(keyBytes.length, valueBytes == null ? 0 : valueBytes.length, topic, headers);
             }
 
             @Override
-            public <K1, V1> long send(final String topic,
+            public <K1, V1> void send(final String topic,
                                       final K1 key,
                                       final V1 value,
                                       final Headers headers,
                                       final Long timestamp,
                                       final Serializer<K1> keySerializer,
                                       final Serializer<V1> valueSerializer,
+                                      final String processorNodeId,
+                                      final InternalProcessorContext<Void, Void> context,
                                       final StreamPartitioner<? super K1, ? super V1> partitioner) {
                 throw new UnsupportedOperationException();
             }
diff --git a/streams/src/test/java/org/apache/kafka/streams/state/internals/StreamThreadStateStoreProviderTest.java b/streams/src/test/java/org/apache/kafka/streams/state/internals/StreamThreadStateStoreProviderTest.java
index 5b0479d325028..a70bf57814819 100644
--- a/streams/src/test/java/org/apache/kafka/streams/state/internals/StreamThreadStateStoreProviderTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/state/internals/StreamThreadStateStoreProviderTest.java
@@ -430,7 +430,9 @@ private StreamTask createStreamsTask(final StreamsConfig streamsConfig,
                 Time.SYSTEM
             ),
             streamsConfig.defaultProductionExceptionHandler(),
-            new MockStreamsMetrics(metrics));
+            new MockStreamsMetrics(metrics),
+            topology
+        );
         final StreamsMetricsImpl streamsMetrics = new MockStreamsMetrics(metrics);
         final InternalProcessorContext context = new ProcessorContextImpl(
             taskId,
diff --git a/streams/src/test/java/org/apache/kafka/test/InternalMockProcessorContext.java b/streams/src/test/java/org/apache/kafka/test/InternalMockProcessorContext.java
index 0744995a07f44..5192a1f67821c 100644
--- a/streams/src/test/java/org/apache/kafka/test/InternalMockProcessorContext.java
+++ b/streams/src/test/java/org/apache/kafka/test/InternalMockProcessorContext.java
@@ -460,7 +460,9 @@ public void logChange(final String storeName,
             taskId().partition(),
             timestamp,
             BYTES_KEY_SERIALIZER,
-            BYTEARRAY_VALUE_SERIALIZER);
+            BYTEARRAY_VALUE_SERIALIZER,
+            null,
+            null);
     }
 
     @Override
diff --git a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
index 96dfa60dd29ef..c99a32c980f35 100644
--- a/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
+++ b/streams/src/test/java/org/apache/kafka/test/MockRecordCollector.java
@@ -21,6 +21,7 @@
 import org.apache.kafka.common.header.Headers;
 import org.apache.kafka.common.serialization.Serializer;
 import org.apache.kafka.streams.processor.StreamPartitioner;
+import org.apache.kafka.streams.processor.internals.InternalProcessorContext;
 import org.apache.kafka.streams.processor.internals.RecordCollector;
 
 import java.util.Collections;
@@ -39,31 +40,34 @@ public class MockRecordCollector implements RecordCollector {
     private boolean flushed = false;
 
     @Override
-    public <K, V> long send(final String topic,
+    public <K, V> void send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
                             final Integer partition,
                             final Long timestamp,
                             final Serializer<K> keySerializer,
-                            final Serializer<V> valueSerializer) {
+                            final Serializer<V> valueSerializer,
+                            final String processorNodeId,
+                            final InternalProcessorContext<Void, Void> context) {
         collected.add(new ProducerRecord<>(topic,
                                            partition,
                                            timestamp,
                                            key,
                                            value,
                                            headers));
-        return 0;
     }
 
     @Override
-    public <K, V> long send(final String topic,
+    public <K, V> void send(final String topic,
                             final K key,
                             final V value,
                             final Headers headers,
                             final Long timestamp,
                             final Serializer<K> keySerializer,
                             final Serializer<V> valueSerializer,
+                            final String processorNodeId,
+                            final InternalProcessorContext<Void, Void> context,
                             final StreamPartitioner<? super K, ? super V> partitioner) {
         collected.add(new ProducerRecord<>(topic,
             0, // partition id
@@ -71,7 +75,6 @@ public <K, V> long send(final String topic,
             key,
             value,
             headers));
-        return 0;
     }
 
     @Override
diff --git a/streams/test-utils/src/main/java/org/apache/kafka/streams/TopologyTestDriver.java b/streams/test-utils/src/main/java/org/apache/kafka/streams/TopologyTestDriver.java
index 49ebf732e9612..c918a491ae7af 100644
--- a/streams/test-utils/src/main/java/org/apache/kafka/streams/TopologyTestDriver.java
+++ b/streams/test-utils/src/main/java/org/apache/kafka/streams/TopologyTestDriver.java
@@ -498,7 +498,8 @@ private void setupTask(final StreamsConfig streamsConfig,
                 TASK_ID,
                 testDriverProducer,
                 streamsConfig.defaultProductionExceptionHandler(),
-                streamsMetrics
+                streamsMetrics,
+                processorTopology
             );
 
             final InternalProcessorContext context = new ProcessorContextImpl(

From 314be89d4c874d8cc07c7da39c1700ecb268d316 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 02:27:28 -0700
Subject: [PATCH 21/30] checkstyle

---
 .../processor/internals/metrics/TopicMetricsTest.java       | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
index 989fed037e856..d8504a7bb7e9e 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
@@ -43,7 +43,7 @@ public class TopicMetricsTest {
     private final Map<String, String> tagMap = Collections.singletonMap("hello", "world");
 
     private final Sensor expectedSensor = mock(Sensor.class);
-    private static final MockedStatic<StreamsMetricsImpl> streamsMetricsMockedStatic = mockStatic(StreamsMetricsImpl.class);
+    private static final MockedStatic<StreamsMetricsImpl> STREAMS_METRICS_STATIC_MOCK = mockStatic(StreamsMetricsImpl.class);
     private final StreamsMetricsImpl streamsMetrics = mock(StreamsMetricsImpl.class);
 
     @Test
@@ -63,7 +63,7 @@ public void shouldGetRecordsAndBytesConsumedSensor() {
             () -> TopicMetrics.consumedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics)
         );
 
-        streamsMetricsMockedStatic.verify(
+        STREAMS_METRICS_STATIC_MOCK.verify(
             () -> StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
                 expectedSensor,
                 TOPIC_LEVEL_GROUP,
@@ -91,7 +91,7 @@ public void shouldGetRecordsAndBytesProducedSensor() {
 
         verifySensor(() -> TopicMetrics.producedSensor(THREAD_ID, TASK_ID, PROCESSOR_NODE_ID, TOPIC_NAME, streamsMetrics));
 
-        streamsMetricsMockedStatic.verify(
+        STREAMS_METRICS_STATIC_MOCK.verify(
             () -> StreamsMetricsImpl.addTotalCountAndSumMetricsToSensor(
                 expectedSensor,
                 TOPIC_LEVEL_GROUP,

From 65a7ce4ebb14c6e1ff0865e6905d03995d5859c0 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 02:30:24 -0700
Subject: [PATCH 22/30] back out formatting changes

---
 .../internals/metrics/ProcessorNodeMetrics.java        |  6 +++---
 .../streams/integration/MetricsIntegrationTest.java    | 10 ++++++++++
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
index 0a39b223dda84..8dcd265a244ac 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/metrics/ProcessorNodeMetrics.java
@@ -95,9 +95,9 @@ public static Sensor suppressionEmitSensor(final String threadId,
     }
 
     public static Sensor skippedIdempotentUpdatesSensor(final String threadId,
-                                                        final String taskId,
-                                                        final String processorNodeId,
-                                                        final StreamsMetricsImpl streamsMetrics) {
+            final String taskId,
+            final String processorNodeId,
+            final StreamsMetricsImpl streamsMetrics) {
         return throughputSensor(
             threadId,
             taskId,
diff --git a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
index 50c37bfcdcfd7..2e1dd141f85c8 100644
--- a/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/integration/MetricsIntegrationTest.java
@@ -157,6 +157,10 @@ public static void closeCluster() {
     private static final String PROCESS_LATENCY_MAX = "process-latency-max";
     private static final String PUNCTUATE_LATENCY_AVG = "punctuate-latency-avg";
     private static final String PUNCTUATE_LATENCY_MAX = "punctuate-latency-max";
+    private static final String CREATE_LATENCY_AVG = "create-latency-avg";
+    private static final String CREATE_LATENCY_MAX = "create-latency-max";
+    private static final String DESTROY_LATENCY_AVG = "destroy-latency-avg";
+    private static final String DESTROY_LATENCY_MAX = "destroy-latency-max";
     private static final String PROCESS_RATE = "process-rate";
     private static final String PROCESS_TOTAL = "process-total";
     private static final String PROCESS_RATIO = "process-ratio";
@@ -165,6 +169,12 @@ public static void closeCluster() {
     private static final String PUNCTUATE_RATE = "punctuate-rate";
     private static final String PUNCTUATE_TOTAL = "punctuate-total";
     private static final String PUNCTUATE_RATIO = "punctuate-ratio";
+    private static final String CREATE_RATE = "create-rate";
+    private static final String CREATE_TOTAL = "create-total";
+    private static final String DESTROY_RATE = "destroy-rate";
+    private static final String DESTROY_TOTAL = "destroy-total";
+    private static final String FORWARD_TOTAL = "forward-total";
+    private static final String FORWARD_RATE = "forward-rate";
     private static final String STREAM_STRING = "stream";
     private static final String COMMIT_LATENCY_AVG = "commit-latency-avg";
     private static final String COMMIT_LATENCY_MAX = "commit-latency-max";

From 3e09f011477e60ccb2ae6d837cb1b731df2cad8c Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 03:08:11 -0700
Subject: [PATCH 23/30] fix StreamsMetricTest

---
 .../processor/internals/metrics/StreamsMetricsImplTest.java   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
index fb6654255bd77..3510d0126a08c 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
@@ -1171,9 +1171,9 @@ public void shouldAddTotalCountAndSumMetricsToSensor() {
 
         final double valueToRecord1 = 18.0;
         final double valueToRecord2 = 42.0;
-        final double expectedCountMetricValue = 4;
+        final double expectedCountMetricValue = 2;
         verifyMetric(totalMetricNamePrefix + "-total", DESCRIPTION1, valueToRecord1, valueToRecord2, expectedCountMetricValue);
-        final double expectedSumMetricValue = 2 * valueToRecord1 + 2 * valueToRecord2; // values are recorded once for each metric verification
+        final double expectedSumMetricValue = valueToRecord1 + valueToRecord2;
         verifyMetric(sumMetricNamePrefix + "-total", DESCRIPTION2, valueToRecord1, valueToRecord2, expectedSumMetricValue);
         assertThat(metrics.metrics().size(), equalTo(2 + 1)); // one metric is added automatically in the constructor of Metrics
     }

From d39b2495a1b81e44ed1d27ebc473afd8a3ee3030 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 05:18:51 -0700
Subject: [PATCH 24/30] topology mock

---
 .../streams/processor/internals/ActiveTaskCreatorTest.java      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreatorTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreatorTest.java
index e2ef0d16d46e0..538360bd63139 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreatorTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/ActiveTaskCreatorTest.java
@@ -60,6 +60,7 @@
 import static org.hamcrest.Matchers.closeTo;
 import static org.hamcrest.core.IsNot.not;
 import static org.junit.Assert.assertThrows;
+import static java.util.Collections.emptySet;
 
 @RunWith(EasyMockRunner.class)
 public class ActiveTaskCreatorTest {
@@ -478,6 +479,7 @@ private void createTasks() {
         reset(builder, stateDirectory);
         expect(builder.topologyConfigs()).andStubReturn(new TopologyConfig(new StreamsConfig(properties)));
         expect(builder.buildSubtopology(0)).andReturn(topology).anyTimes();
+        expect(topology.sinkTopics()).andStubReturn(emptySet());
         expect(stateDirectory.getOrCreateDirectoryForTask(task00)).andReturn(mock(File.class));
         expect(stateDirectory.checkpointFileFor(task00)).andReturn(mock(File.class));
         expect(stateDirectory.getOrCreateDirectoryForTask(task01)).andReturn(mock(File.class));

From 681400061790f642ad3c6418053304a7dbd8ddbf Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 13:19:52 -0700
Subject: [PATCH 25/30] close partition group in closeCleanAndRecycleState

---
 .../streams/processor/internals/StreamTask.java  | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
index e7ebfdb900e38..ea593a297389d 100644
--- a/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
+++ b/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java
@@ -553,6 +553,7 @@ public void closeCleanAndRecycleState() {
         switch (state()) {
             case SUSPENDED:
                 stateMgr.recycle();
+                partitionGroup.close();
                 recordCollector.closeClean();
 
                 break;
@@ -614,6 +615,13 @@ private void removeAllSensors() {
     private void close(final boolean clean) {
         switch (state()) {
             case SUSPENDED:
+                TaskManager.executeAndMaybeSwallow(
+                    clean,
+                    partitionGroup::close,
+                    "partition group close",
+                    log
+                );
+
                 // first close state manager (which is idempotent) then close the record collector
                 // if the latter throws and we re-close dirty which would close the state manager again.
                 TaskManager.executeAndMaybeSwallow(
@@ -637,13 +645,6 @@ private void close(final boolean clean) {
                     log
                 );
 
-                TaskManager.executeAndMaybeSwallow(
-                    clean,
-                    partitionGroup::close,
-                    "partition group close",
-                    log
-                );
-
                 break;
 
             case CLOSED:
@@ -660,7 +661,6 @@ private void close(final boolean clean) {
         }
 
         record = null;
-        partitionGroup.clear();
         closeTaskSensor.record();
 
         transitionTo(State.CLOSED);

From 7e67567d5a1f2e027562335284a9349434701d9d Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 13:27:53 -0700
Subject: [PATCH 26/30] fix StreamsMetricsImplTest

---
 .../processor/internals/metrics/StreamsMetricsImplTest.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
index 3510d0126a08c..b8d3d92e62575 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/StreamsMetricsImplTest.java
@@ -1173,7 +1173,7 @@ public void shouldAddTotalCountAndSumMetricsToSensor() {
         final double valueToRecord2 = 42.0;
         final double expectedCountMetricValue = 2;
         verifyMetric(totalMetricNamePrefix + "-total", DESCRIPTION1, valueToRecord1, valueToRecord2, expectedCountMetricValue);
-        final double expectedSumMetricValue = valueToRecord1 + valueToRecord2;
+        final double expectedSumMetricValue = 2 * valueToRecord1 + 2 * valueToRecord2; // values are recorded once for each metric verification
         verifyMetric(sumMetricNamePrefix + "-total", DESCRIPTION2, valueToRecord1, valueToRecord2, expectedSumMetricValue);
         assertThat(metrics.metrics().size(), equalTo(2 + 1)); // one metric is added automatically in the constructor of Metrics
     }

From 982376411d3ea77e8dbf260eb913d84706627cfa Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 14:03:52 -0700
Subject: [PATCH 27/30] fixin up TestTopicsTest

---
 .../apache/kafka/streams/TestTopicsTest.java  | 57 +++++++++++--------
 1 file changed, 32 insertions(+), 25 deletions(-)

diff --git a/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java b/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
index 766729fffa4f5..91752f60f6c7f 100644
--- a/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
+++ b/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
@@ -89,12 +89,12 @@ public void tearDown() {
 
     @Test
     public void testValue() {
-        final TestInputTopic<String, String> inputTopic =
-            testDriver.createInputTopic(INPUT_TOPIC, stringSerde.serializer(), stringSerde.serializer());
+        final TestInputTopic<Long, String> inputTopic =
+            testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer());
         final TestOutputTopic<String, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, stringSerde.deserializer(), stringSerde.deserializer());
-        //Feed word "Hello" to inputTopic and no kafka key, timestamp is irrelevant in this case
-        inputTopic.pipeInput("Hello");
+        //Feed word "Hello" to inputTopic, timestamp and key irrelevant in this case
+        inputTopic.pipeInput(1L, "Hello");
         assertThat(outputTopic.readValue(), equalTo("Hello"));
         //No more output in topic
         assertThat(outputTopic.isEmpty(), is(true));
@@ -102,16 +102,20 @@ public void testValue() {
 
     @Test
     public void testValueList() {
-        final TestInputTopic<String, String> inputTopic =
-            testDriver.createInputTopic(INPUT_TOPIC, stringSerde.serializer(), stringSerde.serializer());
+        final TestInputTopic<Long, String> inputTopic =
+            testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer());
         final TestOutputTopic<String, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, stringSerde.deserializer(), stringSerde.deserializer());
-        final List<String> inputList = Arrays.asList("This", "is", "an", "example");
-        //Feed list of words to inputTopic and no kafka key, timestamp is irrelevant in this case
-        inputTopic.pipeValueList(inputList);
+        final List<KeyValue<Long, String>> inputList = Arrays.asList(
+            new KeyValue<>(1L, "This"),
+            new KeyValue<>(2L, "is"),
+            new KeyValue<>(3L, "an"),
+            new KeyValue<>(4L, "example"));
+        //Feed list of words to inputTopic, key and timestamp are irrelevant in this case
+        inputTopic.pipeKeyValueList(inputList);
         final List<String> output = outputTopic.readValuesToList();
         assertThat(output, hasItems("This", "is", "an", "example"));
-        assertThat(output, is(equalTo(inputList)));
+        assertThat(output, is(equalTo(inputList.stream().map(kv -> kv.value))));
     }
 
     @Test
@@ -166,15 +170,16 @@ public void testKeyValuesToMap() {
     }
 
     @Test
-    public void testKeyValuesToMapWithNull() {
+    public void testPipeInputWithNullKey() {
         final TestInputTopic<Long, String> inputTopic =
             testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer());
         final TestOutputTopic<Long, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, longSerde.deserializer(), stringSerde.deserializer());
-        inputTopic.pipeInput("value");
-        assertThrows(IllegalStateException.class, outputTopic::readKeyValuesToMap);
-    }
+        final StreamsException exception = assertThrows(StreamsException.class, () -> inputTopic.pipeInput("value"));
+        assertThat(exception.getCause() instanceof NullPointerException, is(true));
+        assertThat(outputTopic.readKeyValuesToMap().isEmpty(), is(true));
 
+    }
 
     @Test
     public void testKeyValueListDuration() {
@@ -229,8 +234,8 @@ public void testTimestamp() {
             testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer());
         final TestOutputTopic<Long, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, longSerde.deserializer(), stringSerde.deserializer());
-        inputTopic.pipeInput(null, "Hello", baseTime);
-        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(null, "Hello", null, baseTime))));
+        inputTopic.pipeInput(1L, "Hello", baseTime);
+        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(1L, "Hello", null, baseTime))));
 
         inputTopic.pipeInput(2L, "Kafka", ++baseTime);
         assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(2L, "Kafka", null, baseTime))));
@@ -238,13 +243,15 @@ public void testTimestamp() {
         inputTopic.pipeInput(2L, "Kafka", testBaseTime);
         assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(2L, "Kafka", testBaseTime))));
 
-        final List<String> inputList = Arrays.asList("Advancing", "time");
+        final List<KeyValue<Long, String>> inputList = Arrays.asList(
+            new KeyValue<>(1L, "Advancing"),
+            new KeyValue<>(2L, "time"));
         //Feed list of words to inputTopic and no kafka key, timestamp advancing from testInstant
         final Duration advance = Duration.ofSeconds(15);
         final Instant recordInstant = testBaseTime.plus(Duration.ofDays(1));
-        inputTopic.pipeValueList(inputList, recordInstant, advance);
-        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(null, "Advancing", recordInstant))));
-        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(null, "time", null, recordInstant.plus(advance)))));
+        inputTopic.pipeKeyValueList(inputList, recordInstant, advance);
+        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(1L, "Advancing", recordInstant))));
+        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(2L, "time", null, recordInstant.plus(advance)))));
     }
 
     @Test
@@ -292,8 +299,8 @@ public void testTimestampAutoAdvance() {
             testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer(), testBaseTime, advance);
         final TestOutputTopic<Long, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, longSerde.deserializer(), stringSerde.deserializer());
-        inputTopic.pipeInput("Hello");
-        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(null, "Hello", testBaseTime))));
+        inputTopic.pipeInput(1L, "Hello");
+        assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(1L, "Hello", testBaseTime))));
         inputTopic.pipeInput(2L, "Kafka");
         assertThat(outputTopic.readRecord(), is(equalTo(new TestRecord<>(2L, "Kafka", testBaseTime.plus(advance)))));
     }
@@ -337,12 +344,12 @@ public void testNonUsedOutputTopic() {
 
     @Test
     public void testEmptyTopic() {
-        final TestInputTopic<String, String> inputTopic =
-            testDriver.createInputTopic(INPUT_TOPIC, stringSerde.serializer(), stringSerde.serializer());
+        final TestInputTopic<Long, String> inputTopic =
+            testDriver.createInputTopic(INPUT_TOPIC, longSerde.serializer(), stringSerde.serializer());
         final TestOutputTopic<String, String> outputTopic =
             testDriver.createOutputTopic(OUTPUT_TOPIC, stringSerde.deserializer(), stringSerde.deserializer());
         //Feed word "Hello" to inputTopic and no kafka key, timestamp is irrelevant in this case
-        inputTopic.pipeInput("Hello");
+        inputTopic.pipeInput(1L, "Hello");
         assertThat(outputTopic.readValue(), equalTo("Hello"));
         //No more output in topic
         assertThrows(NoSuchElementException.class, outputTopic::readRecord, "Empty topic");

From 49fa512bd85510541a819afe67a673c47b6308b9 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 14:04:46 -0700
Subject: [PATCH 28/30] toSet

---
 .../src/test/java/org/apache/kafka/streams/TestTopicsTest.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java b/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
index 91752f60f6c7f..f39b2b554a630 100644
--- a/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
+++ b/streams/test-utils/src/test/java/org/apache/kafka/streams/TestTopicsTest.java
@@ -43,6 +43,7 @@
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Properties;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -115,7 +116,7 @@ public void testValueList() {
         inputTopic.pipeKeyValueList(inputList);
         final List<String> output = outputTopic.readValuesToList();
         assertThat(output, hasItems("This", "is", "an", "example"));
-        assertThat(output, is(equalTo(inputList.stream().map(kv -> kv.value))));
+        assertThat(output, is(equalTo(inputList.stream().map(kv -> kv.value).collect(Collectors.toList()))));
     }
 
     @Test

From a408b95c5a9cb0e753ceb9f5df57255a5acf8961 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Fri, 3 Jun 2022 23:08:42 -0700
Subject: [PATCH 29/30] fixin scala tests

---
 .../scala/kstream/KStreamSplitTest.scala      | 69 +++++++++++--------
 1 file changed, 40 insertions(+), 29 deletions(-)

diff --git a/streams/streams-scala/src/test/scala/org/apache/kafka/streams/scala/kstream/KStreamSplitTest.scala b/streams/streams-scala/src/test/scala/org/apache/kafka/streams/scala/kstream/KStreamSplitTest.scala
index bbcc1b503f4fa..89adbd6b1ef29 100644
--- a/streams/streams-scala/src/test/scala/org/apache/kafka/streams/scala/kstream/KStreamSplitTest.scala
+++ b/streams/streams-scala/src/test/scala/org/apache/kafka/streams/scala/kstream/KStreamSplitTest.scala
@@ -17,6 +17,7 @@
 package org.apache.kafka.streams.scala.kstream
 
 import org.apache.kafka.streams.kstream.Named
+import org.apache.kafka.streams.KeyValue
 import org.apache.kafka.streams.scala.ImplicitConversions._
 import org.apache.kafka.streams.scala.StreamsBuilder
 import org.apache.kafka.streams.scala.serialization.Serdes._
@@ -35,7 +36,7 @@ class KStreamSplitTest extends TestDriver {
     val sinkTopic = Array("default", "even", "three");
 
     val m = builder
-      .stream[Integer, Integer](sourceTopic)
+      .stream[Int, Int](sourceTopic)
       .split(Named.as("_"))
       .branch((_, v) => v % 2 == 0)
       .branch((_, v) => v % 3 == 0)
@@ -46,14 +47,17 @@ class KStreamSplitTest extends TestDriver {
     m("_2").to(sinkTopic(2))
 
     val testDriver = createTestDriver(builder)
-    val testInput = testDriver.createInput[Integer, Integer](sourceTopic)
-    val testOutput = sinkTopic.map(name => testDriver.createOutput[Integer, Integer](name))
-
-    testInput.pipeValueList(
-      List(1, 2, 3, 4, 5)
-        .map(Integer.valueOf)
-        .asJava
-    )
+    val testInput = testDriver.createInput[Int, Int](sourceTopic)
+    val testOutput = sinkTopic.map(name => testDriver.createOutput[Int, Int](name))
+
+    testInput pipeKeyValueList List(
+      new KeyValue(1, 1),
+      new KeyValue(1, 2),
+      new KeyValue(1, 3),
+      new KeyValue(1, 4),
+      new KeyValue(1, 5)
+    ).asJava
+
     assertEquals(List(1, 5), testOutput(0).readValuesToList().asScala)
     assertEquals(List(2, 4), testOutput(1).readValuesToList().asScala)
     assertEquals(List(3), testOutput(2).readValuesToList().asScala)
@@ -67,7 +71,7 @@ class KStreamSplitTest extends TestDriver {
     val sourceTopic = "source"
 
     val m = builder
-      .stream[Integer, Integer](sourceTopic)
+      .stream[Int, Int](sourceTopic)
       .split(Named.as("_"))
       .branch((_, v) => v % 2 == 0, Branched.withConsumer(ks => ks.to("even"), "consumedEvens"))
       .branch((_, v) => v % 3 == 0, Branched.withFunction(ks => ks.mapValues(x => x * x), "mapped"))
@@ -76,15 +80,18 @@ class KStreamSplitTest extends TestDriver {
     m("_mapped").to("mapped")
 
     val testDriver = createTestDriver(builder)
-    val testInput = testDriver.createInput[Integer, Integer](sourceTopic)
-    testInput.pipeValueList(
-      List(1, 2, 3, 4, 5, 9)
-        .map(Integer.valueOf)
-        .asJava
-    )
-
-    val even = testDriver.createOutput[Integer, Integer]("even")
-    val mapped = testDriver.createOutput[Integer, Integer]("mapped")
+    val testInput = testDriver.createInput[Int, Int](sourceTopic)
+    testInput pipeKeyValueList List(
+      new KeyValue(1, 1),
+      new KeyValue(1, 2),
+      new KeyValue(1, 3),
+      new KeyValue(1, 4),
+      new KeyValue(1, 5),
+      new KeyValue(1, 9)
+    ).asJava
+
+    val even = testDriver.createOutput[Int, Int]("even")
+    val mapped = testDriver.createOutput[Int, Int]("mapped")
 
     assertEquals(List(2, 4), even.readValuesToList().asScala)
     assertEquals(List(9, 81), mapped.readValuesToList().asScala)
@@ -98,7 +105,7 @@ class KStreamSplitTest extends TestDriver {
     val sourceTopic = "source"
 
     val m = builder
-      .stream[Integer, Integer](sourceTopic)
+      .stream[Int, Int](sourceTopic)
       .split(Named.as("_"))
       .branch((_, v) => v % 2 == 0, Branched.withConsumer(ks => ks.to("even")))
       .branch((_, v) => v % 3 == 0, Branched.withFunction(ks => ks.mapValues(x => x * x)))
@@ -107,19 +114,23 @@ class KStreamSplitTest extends TestDriver {
     m("_2").to("mapped")
 
     val testDriver = createTestDriver(builder)
-    val testInput = testDriver.createInput[Integer, Integer](sourceTopic)
-    testInput.pipeValueList(
-      List(1, 2, 3, 4, 5, 9)
-        .map(Integer.valueOf)
-        .asJava
-    )
-
-    val even = testDriver.createOutput[Integer, Integer]("even")
-    val mapped = testDriver.createOutput[Integer, Integer]("mapped")
+    val testInput = testDriver.createInput[Int, Int](sourceTopic)
+    testInput pipeKeyValueList List(
+      new KeyValue(1, 1),
+      new KeyValue(1, 2),
+      new KeyValue(1, 3),
+      new KeyValue(1, 4),
+      new KeyValue(1, 5),
+      new KeyValue(1, 9)
+    ).asJava
+
+    val even = testDriver.createOutput[Int, Int]("even")
+    val mapped = testDriver.createOutput[Int, Int]("mapped")
 
     assertEquals(List(2, 4), even.readValuesToList().asScala)
     assertEquals(List(9, 81), mapped.readValuesToList().asScala)
 
     testDriver.close()
   }
+
 }

From a0e2f08051f872ffd62965b04b5432fb88cfe6e5 Mon Sep 17 00:00:00 2001
From: "A. Sophie Blee-Goldman" <sophie@confluent.io>
Date: Mon, 6 Jun 2022 19:33:49 -0700
Subject: [PATCH 30/30] FINALLY fix the broken tests...

---
 .../processor/internals/metrics/TopicMetricsTest.java       | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
index d8504a7bb7e9e..c359affe5dae1 100644
--- a/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
+++ b/streams/src/test/java/org/apache/kafka/streams/processor/internals/metrics/TopicMetricsTest.java
@@ -19,6 +19,7 @@
 import org.apache.kafka.common.metrics.Sensor;
 import org.apache.kafka.common.metrics.Sensor.RecordingLevel;
 
+import org.junit.AfterClass;
 import org.junit.Test;
 import org.mockito.MockedStatic;
 import java.util.Collections;
@@ -46,6 +47,11 @@ public class TopicMetricsTest {
     private static final MockedStatic<StreamsMetricsImpl> STREAMS_METRICS_STATIC_MOCK = mockStatic(StreamsMetricsImpl.class);
     private final StreamsMetricsImpl streamsMetrics = mock(StreamsMetricsImpl.class);
 
+    @AfterClass
+    public static void cleanUp() {
+        STREAMS_METRICS_STATIC_MOCK.close();
+    }
+
     @Test
     public void shouldGetRecordsAndBytesConsumedSensor() {
         final String recordsMetricNamePrefix = "records-consumed";