You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@beam.apache.org by "junaiddshaukat (via GitHub)" <gi...@apache.org> on 2026/08/04 09:27:09 UTC

[PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

junaiddshaukat opened a new pull request, #39610:
URL: https://github.com/apache/beam/pull/39610

   ## Summary
   
   Part of #18479. Enables `CombineTest` in the ValidatesRunner suite, and picks up two review follow-ups from #39546 and #39578.
   
   ## Combine coverage
   
   Combine has always been expected to work here without a translator of its own: the fuser expands `Combine.perKey` into a GroupByKey with the combining logic running as ordinary ParDos in the SDK harness, all of which the runner already executes. That was an assumption though — nothing exercised it. Enabling `CombineTest` takes the suite from 49 to 59 tests and makes it a tested claim.
   
   | Suite | Tests |
   | --- | --- |
   | `CombineTest$BasicTests` | 8 |
   | `CombineTest$WindowingTests` | 2 |
   
   `BasicTests` passes in full, including hot-key fanout and the accumulation-mode variant; `WindowingTests` contributes the fixed-window and empty-window cases. The rest falls out on category excludes the task already declares — `CombineWithContextTests` and `AccumulationTests` need side inputs, and most of `WindowingTests` needs side inputs, triggers or `TestStream`.
   
   `CombineTest$WindowingTests.testSessionsCombine` is sickbayed. Session windows are merging windows, which the first windowing pass did not implement, so it joins the existing `testGroupByKeyMergingWindows` entry under a comment now worded to cover Combine too. That is the *only* Combine failure, and it is the known windowing gap rather than anything specific to Combine.
   
   ## Flatten: what the `Math.max` is actually doing
   
   The review question on #39546 was whether the `Math.max` over the inputs' partition counts is redundant, since the comment above it asserted the inputs are co-partitioned.
   
   Neither half of that was quite right, so both are now fixed. The max is not a no-op in principle: Kafka Streams merges the subtopologies of every parent a processor is wired to and gives the merged subtopology as many tasks as its largest source topic has partitions, so the max is what that task count comes to. But the mismatched case does not reach this translator at all. A Flatten whose branches would disagree — one through a GroupByKey, one straight from a source — is folded into the SDK harness stage by the fuser rather than becoming a node here, and the runner Flattens that do arrive come from the fuser deduplicating partial outputs of a single PCollection.
   
   I tried to build the mismatched shape to see what the runner does with it, and could not: it never becomes a runner Flatten. `FlattenParallelismTest` records that, so if a change ever lets that shape through, it starts failing and the partition-count handling gets revisited. The comment now describes the situation instead of asserting an invariant nothing enforces.
   
   Worth stating why this is not just tidying. If such a Flatten ever did reach the translator, the branch with fewer partitions would only produce on that many of the merged subtopology's tasks, and the remaining Flatten instances would wait forever for a watermark report from it. A stalled pipeline is a bad failure mode to leave undetected, which is what the test is guarding.
   
   ## Partitioner: guard the null key
   
   `GroupByKeyBroadcastPartitioner.partition()` guarded against a null record key, but `partitions()` — the method Kafka Streams actually calls when it is present — hashed it unguarded. Nothing reaches that today, because data arriving at a repartition sink has been re-keyed by `ShuffleByKeyProcessor` first, but the guard belongs on the method that runs.
   
   That is the groundwork for the other half of the review point: that a stateless stage should carry a null key rather than the empty-array placeholder Impulse and Read emit. That change is more invasive than it looks — every processor is declared `Processor<byte[], …, byte[], …>`, so emitting a null key means moving all of them, plus the payload serde and the partitioner generics, to `byte @Nullable []`, or adding nullness suppressions in several places. It is worth doing, but as its own change rather than folded in here.
   
   ## Testing
   
   ```
   ./gradlew :runners:kafka-streams:validatesRunner   # 59 tests, 0 failures
   ./gradlew :runners:kafka-streams:build            # 82 unit tests, spotless + checker + errorprone
   ```
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

Posted by "junaiddshaukat (via GitHub)" <gi...@apache.org>.
junaiddshaukat commented on code in PR #39610:
URL: https://github.com/apache/beam/pull/39610#discussion_r3711238092


##########
runners/kafka-streams/src/main/java/org/apache/beam/runners/kafka/streams/translation/GroupByKeyBroadcastPartitioner.java:
##########
@@ -56,7 +56,10 @@ public Optional<Set<Integer>> partitions(
       }
       return Optional.of(all);
     }
-    int partition = Utils.toPositive(Utils.murmur2(key)) % numPartitions;
+    // A keyless record — a stateless stage carries no key — has nowhere in particular to go, so
+    // send it to partition 0 rather than hashing a null. This is the method Kafka Streams calls,
+    // so the guard has to be here and not only on partition() above.
+    int partition = key == null ? 0 : Utils.toPositive(Utils.murmur2(key)) % numPartitions;
     return Optional.of(Collections.singleton(partition));

Review Comment:
   You're right I checked again, partition 0 is a fixed partition, not an absence of one — keyless records would all have piled onto it. Fixed by returning Optional.empty() instead: I checked RecordCollectorImpl, and it tests isPresent() before using the returned set, so an empty Optional means no explicit partition was chosen and the producer's default partitioner handles it. That spreads keyless records over the topic, which is the behaviour a record with no key should get.
   
   



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

Posted by "junaiddshaukat (via GitHub)" <gi...@apache.org>.
junaiddshaukat commented on code in PR #39610:
URL: https://github.com/apache/beam/pull/39610#discussion_r3711236190


##########
runners/kafka-streams/src/test/java/org/apache/beam/runners/kafka/streams/translation/FlattenParallelismTest.java:
##########
@@ -0,0 +1,110 @@
+/*
+ * 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.beam.runners.kafka.streams.translation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.apache.beam.runners.kafka.streams.KafkaStreamsPipelineOptions;
+import org.apache.beam.runners.kafka.streams.KafkaStreamsTestRunner;
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.transforms.Create;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.GroupByKey;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.PCollectionList;
+import org.junit.Test;
+
+/**
+ * Pins down what happens to a Flatten whose branches would run at different parallelisms — one
+ * through a GroupByKey and so at the shuffle's parallelism, one straight from a source and so a
+ * single instance.
+ *
+ * <p>This matters because a Flatten runs as one set of tasks over all of its inputs. Kafka Streams
+ * merges the subtopologies of every parent a processor is wired to and gives the result as many
+ * tasks as its largest source topic has partitions, so a parent with fewer partitions would only
+ * produce on some of those tasks and the rest would wait forever for a watermark report from it.
+ *
+ * <p>That does not arise, and this test is here to record why: the fuser folds such a Flatten into
+ * the SDK harness stage rather than leaving a node for the runner to translate. The Flattens that
+ * do reach {@link FlattenTranslator} come from the fuser deduplicating partial outputs of a single
+ * PCollection. If a change ever makes the mismatched shape reach the translator, this test starts
+ * failing and the partition-count handling there needs revisiting.
+ */
+public class FlattenParallelismTest {
+
+  private static class ToKvFn extends DoFn<Integer, KV<String, Integer>> {
+    @ProcessElement
+    public void processElement(@Element Integer input, OutputReceiver<KV<String, Integer>> out) {
+      out.output(KV.of("k", input));
+    }
+  }
+
+  private static class UngroupFn extends DoFn<KV<String, Iterable<Integer>>, Integer> {
+    @ProcessElement
+    public void processElement(
+        @Element KV<String, Iterable<Integer>> group, OutputReceiver<Integer> out) {
+      for (int value : group.getValue()) {
+        out.output(value);
+      }
+    }
+  }
+
+  private static Pipeline mixedParallelismFlatten(int internalParallelism) {
+    KafkaStreamsPipelineOptions options =
+        KafkaStreamsTestRunner.testOptions().as(KafkaStreamsPipelineOptions.class);
+    options.setInternalParallelism(internalParallelism);
+    Pipeline pipeline = Pipeline.create(options);
+
+    // Through a GroupByKey, so this branch runs at the shuffle's parallelism.
+    PCollection<Integer> shuffled =
+        pipeline
+            .apply("createGrouped", Create.of(1, 2, 3))
+            .apply("toKv", ParDo.of(new ToKvFn()))
+            .apply("group", GroupByKey.create())
+            .apply("ungroup", ParDo.of(new UngroupFn()));
+
+    // Straight from a source, so this branch is a single instance.
+    PCollection<Integer> direct = pipeline.apply("createDirect", Create.of(4, 5, 6));
+
+    PCollectionList.of(shuffled).and(direct).apply("merge", Flatten.pCollections());
+    return pipeline;
+  }
+
+  @Test
+  public void branchesAtDifferentParallelismsAreFusedRatherThanLeftToTheRunner() {
+    // Translating is the assertion: the mismatched shape does not reach FlattenTranslator, because
+    // the fuser absorbs this Flatten into the harness stage. Were it to arrive there, the runner
+    // would build one Flatten node over branches of differing parallelism and stall.
+    KafkaStreamsTranslationContext context =
+        KafkaStreamsTestRunner.translate(mixedParallelismFlatten(4));
+
+    assertThat(context.getTopology().describe().subtopologies().isEmpty(), is(false));

Review Comment:
   Agreed, isEmpty() == false would have passed no matter what the fuser did, so it wasn't testing the thing the file exists for. Both now assert the shape: that no processor node stands for the Flatten, and that the branches stay in three separate subtopologies instead of being merged into one. That is the actual claim, since a Flatten node over branches of differing parallelism is exactly the case where the smaller branch can't reach all instances and the rest stall.
   
   The second test asserts the same shape deliberately, because whether the Flatten is fused is a property of the fused graph rather than of the parallelism — which is what makes raising the parallelism safe. I printed the translated topology to write these, and there's no Flatten node in either case; both branches just end.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

Posted by "je-ik (via GitHub)" <gi...@apache.org>.
je-ik merged PR #39610:
URL: https://github.com/apache/beam/pull/39610


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

Posted by "je-ik (via GitHub)" <gi...@apache.org>.
je-ik commented on code in PR #39610:
URL: https://github.com/apache/beam/pull/39610#discussion_r3711128991


##########
runners/kafka-streams/src/main/java/org/apache/beam/runners/kafka/streams/translation/GroupByKeyBroadcastPartitioner.java:
##########
@@ -56,7 +56,10 @@ public Optional<Set<Integer>> partitions(
       }
       return Optional.of(all);
     }
-    int partition = Utils.toPositive(Utils.murmur2(key)) % numPartitions;
+    // A keyless record — a stateless stage carries no key — has nowhere in particular to go, so
+    // send it to partition 0 rather than hashing a null. This is the method Kafka Streams calls,
+    // so the guard has to be here and not only on partition() above.
+    int partition = key == null ? 0 : Utils.toPositive(Utils.murmur2(key)) % numPartitions;
     return Optional.of(Collections.singleton(partition));

Review Comment:
   Is this correct? I would expect that the record should go to the partition it came from OR a random partition from numPartitions, not a fixed partition.



##########
runners/kafka-streams/src/test/java/org/apache/beam/runners/kafka/streams/translation/FlattenParallelismTest.java:
##########
@@ -0,0 +1,110 @@
+/*
+ * 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.beam.runners.kafka.streams.translation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.apache.beam.runners.kafka.streams.KafkaStreamsPipelineOptions;
+import org.apache.beam.runners.kafka.streams.KafkaStreamsTestRunner;
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.transforms.Create;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.GroupByKey;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.PCollectionList;
+import org.junit.Test;
+
+/**
+ * Pins down what happens to a Flatten whose branches would run at different parallelisms — one
+ * through a GroupByKey and so at the shuffle's parallelism, one straight from a source and so a
+ * single instance.
+ *
+ * <p>This matters because a Flatten runs as one set of tasks over all of its inputs. Kafka Streams
+ * merges the subtopologies of every parent a processor is wired to and gives the result as many
+ * tasks as its largest source topic has partitions, so a parent with fewer partitions would only
+ * produce on some of those tasks and the rest would wait forever for a watermark report from it.
+ *
+ * <p>That does not arise, and this test is here to record why: the fuser folds such a Flatten into
+ * the SDK harness stage rather than leaving a node for the runner to translate. The Flattens that
+ * do reach {@link FlattenTranslator} come from the fuser deduplicating partial outputs of a single
+ * PCollection. If a change ever makes the mismatched shape reach the translator, this test starts
+ * failing and the partition-count handling there needs revisiting.
+ */
+public class FlattenParallelismTest {
+
+  private static class ToKvFn extends DoFn<Integer, KV<String, Integer>> {
+    @ProcessElement
+    public void processElement(@Element Integer input, OutputReceiver<KV<String, Integer>> out) {
+      out.output(KV.of("k", input));
+    }
+  }
+
+  private static class UngroupFn extends DoFn<KV<String, Iterable<Integer>>, Integer> {
+    @ProcessElement
+    public void processElement(
+        @Element KV<String, Iterable<Integer>> group, OutputReceiver<Integer> out) {
+      for (int value : group.getValue()) {
+        out.output(value);
+      }
+    }
+  }
+
+  private static Pipeline mixedParallelismFlatten(int internalParallelism) {
+    KafkaStreamsPipelineOptions options =
+        KafkaStreamsTestRunner.testOptions().as(KafkaStreamsPipelineOptions.class);
+    options.setInternalParallelism(internalParallelism);
+    Pipeline pipeline = Pipeline.create(options);
+
+    // Through a GroupByKey, so this branch runs at the shuffle's parallelism.
+    PCollection<Integer> shuffled =
+        pipeline
+            .apply("createGrouped", Create.of(1, 2, 3))
+            .apply("toKv", ParDo.of(new ToKvFn()))
+            .apply("group", GroupByKey.create())
+            .apply("ungroup", ParDo.of(new UngroupFn()));
+
+    // Straight from a source, so this branch is a single instance.
+    PCollection<Integer> direct = pipeline.apply("createDirect", Create.of(4, 5, 6));
+
+    PCollectionList.of(shuffled).and(direct).apply("merge", Flatten.pCollections());
+    return pipeline;
+  }
+
+  @Test
+  public void branchesAtDifferentParallelismsAreFusedRatherThanLeftToTheRunner() {
+    // Translating is the assertion: the mismatched shape does not reach FlattenTranslator, because
+    // the fuser absorbs this Flatten into the harness stage. Were it to arrive there, the runner
+    // would build one Flatten node over branches of differing parallelism and stall.
+    KafkaStreamsTranslationContext context =
+        KafkaStreamsTestRunner.translate(mixedParallelismFlatten(4));
+
+    assertThat(context.getTopology().describe().subtopologies().isEmpty(), is(false));
+  }
+
+  @Test
+  public void theSameShapeTranslatesAtASingleParallelism() {
+    KafkaStreamsTranslationContext context =
+        KafkaStreamsTestRunner.translate(mixedParallelismFlatten(1));
+
+    assertThat(context.getTopology().describe().subtopologies().isEmpty(), is(false));

Review Comment:
   Same here?



##########
runners/kafka-streams/src/test/java/org/apache/beam/runners/kafka/streams/translation/FlattenParallelismTest.java:
##########
@@ -0,0 +1,110 @@
+/*
+ * 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.beam.runners.kafka.streams.translation;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.apache.beam.runners.kafka.streams.KafkaStreamsPipelineOptions;
+import org.apache.beam.runners.kafka.streams.KafkaStreamsTestRunner;
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.transforms.Create;
+import org.apache.beam.sdk.transforms.DoFn;
+import org.apache.beam.sdk.transforms.Flatten;
+import org.apache.beam.sdk.transforms.GroupByKey;
+import org.apache.beam.sdk.transforms.ParDo;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.PCollectionList;
+import org.junit.Test;
+
+/**
+ * Pins down what happens to a Flatten whose branches would run at different parallelisms — one
+ * through a GroupByKey and so at the shuffle's parallelism, one straight from a source and so a
+ * single instance.
+ *
+ * <p>This matters because a Flatten runs as one set of tasks over all of its inputs. Kafka Streams
+ * merges the subtopologies of every parent a processor is wired to and gives the result as many
+ * tasks as its largest source topic has partitions, so a parent with fewer partitions would only
+ * produce on some of those tasks and the rest would wait forever for a watermark report from it.
+ *
+ * <p>That does not arise, and this test is here to record why: the fuser folds such a Flatten into
+ * the SDK harness stage rather than leaving a node for the runner to translate. The Flattens that
+ * do reach {@link FlattenTranslator} come from the fuser deduplicating partial outputs of a single
+ * PCollection. If a change ever makes the mismatched shape reach the translator, this test starts
+ * failing and the partition-count handling there needs revisiting.
+ */
+public class FlattenParallelismTest {
+
+  private static class ToKvFn extends DoFn<Integer, KV<String, Integer>> {
+    @ProcessElement
+    public void processElement(@Element Integer input, OutputReceiver<KV<String, Integer>> out) {
+      out.output(KV.of("k", input));
+    }
+  }
+
+  private static class UngroupFn extends DoFn<KV<String, Iterable<Integer>>, Integer> {
+    @ProcessElement
+    public void processElement(
+        @Element KV<String, Iterable<Integer>> group, OutputReceiver<Integer> out) {
+      for (int value : group.getValue()) {
+        out.output(value);
+      }
+    }
+  }
+
+  private static Pipeline mixedParallelismFlatten(int internalParallelism) {
+    KafkaStreamsPipelineOptions options =
+        KafkaStreamsTestRunner.testOptions().as(KafkaStreamsPipelineOptions.class);
+    options.setInternalParallelism(internalParallelism);
+    Pipeline pipeline = Pipeline.create(options);
+
+    // Through a GroupByKey, so this branch runs at the shuffle's parallelism.
+    PCollection<Integer> shuffled =
+        pipeline
+            .apply("createGrouped", Create.of(1, 2, 3))
+            .apply("toKv", ParDo.of(new ToKvFn()))
+            .apply("group", GroupByKey.create())
+            .apply("ungroup", ParDo.of(new UngroupFn()));
+
+    // Straight from a source, so this branch is a single instance.
+    PCollection<Integer> direct = pipeline.apply("createDirect", Create.of(4, 5, 6));
+
+    PCollectionList.of(shuffled).and(direct).apply("merge", Flatten.pCollections());
+    return pipeline;
+  }
+
+  @Test
+  public void branchesAtDifferentParallelismsAreFusedRatherThanLeftToTheRunner() {
+    // Translating is the assertion: the mismatched shape does not reach FlattenTranslator, because
+    // the fuser absorbs this Flatten into the harness stage. Were it to arrive there, the runner
+    // would build one Flatten node over branches of differing parallelism and stall.
+    KafkaStreamsTranslationContext context =
+        KafkaStreamsTestRunner.translate(mixedParallelismFlatten(4));
+
+    assertThat(context.getTopology().describe().subtopologies().isEmpty(), is(false));

Review Comment:
   Should we test how the topology looks-like, not only that it is non-empty?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


Re: [PR] [GSoC 2026] Kafka Streams runner: CombineTest coverage and two review follow-ups [beam]

Posted by "gemini-code-assist[bot] (via GitHub)" <gi...@apache.org>.
gemini-code-assist[bot] commented on PR #39610:
URL: https://github.com/apache/beam/pull/39610#issuecomment-5177121045

   > [!CAUTION]
   > The consumer version of Gemini Code Assist on GitHub has been sunset. All code review activity has officially ceased.
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: github-unsubscribe@beam.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org