[jira] [Assigned] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Micah Ramos reassigned KAFKA-9584: -- Assignee: (was: Micah Ramos) > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17046201#comment-17046201 ] Micah Ramos commented on KAFKA-9584: I dont have the necessary permissions to change the status of this ticket to "Patch Available" > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17042815#comment-17042815 ] Micah Ramos commented on KAFKA-9584: I added an example here [https://github.com/MicahRam/kafka/commit/fddf3aaa38d06b2dc40043cc82239f7a5f705118] These examples sometimes throw null pointer exceptions because of the the same root cause. > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Commented] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17041990#comment-17041990 ] Micah Ramos commented on KAFKA-9584: When calling context.headers() from punctuate it returns the headers from this static consumer record [https://github.com/apache/kafka/blob/2.5/streams/src/main/java/org/apache/kafka/streams/processor/internals/StreamTask.java#L440] > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Updated] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Micah Ramos updated KAFKA-9584: --- Affects Version/s: (was: 2.0.0) 0.10.0.0 > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 0.10.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Updated] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Micah Ramos updated KAFKA-9584: --- Description: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds a single header could append an infinite number of headers (one per punctuate iteration), causing memory problems in the current topology as well as down stream consumers since the headers are written with the record when it is produced to a topic. I would expect that each invocation of punctuate would be initialized with a new header object. was: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds a single header could append an infinite number of headers (one per punctuate iteration), causing memory problems in the current topology as well as down stream consumers since the headers are written with the record when it is produced to a topic. > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. > > I would expect that each invocation of punctuate would be initialized with a > new header object. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Updated] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Micah Ramos updated KAFKA-9584: --- Description: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds a single header could append an infinite number of headers (one per punctuate iteration), causing memory problems in the current topology as well as down stream consumers since the headers are written with the record when it is produced to a topic. was: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds a single header could append an infinite number of headers (one per punctuate iteration), causing memory problems in the current topology as well as down stream consumers since the headers are produced when the records is produced to a topic. > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are written with > the record when it is produced to a topic. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Updated] (KAFKA-9584) Removing headers causes ConcurrentModificationException
[ https://issues.apache.org/jira/browse/KAFKA-9584?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ] Micah Ramos updated KAFKA-9584: --- Description: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds a single header could append an infinite number of headers (one per punctuate iteration), causing memory problems in the current topology as well as down stream consumers since the headers are produced when the records is produced to a topic. was: The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds headers could append an infinite number of headers, causing memory problems in the current topology as well as down stream consumers since the headers are produced when the records is produced to a topic. > Removing headers causes ConcurrentModificationException > --- > > Key: KAFKA-9584 > URL: https://issues.apache.org/jira/browse/KAFKA-9584 > Project: Kafka > Issue Type: Bug > Components: streams >Affects Versions: 2.0.0 >Reporter: Micah Ramos >Priority: Minor > > The consumer record that is used during punctuate is static, this can cause > java.util.ConcurrentModificationException when modifying the headers. > Using a single instance of ConsumerRecord for all punctuates causes other > strange behavior: > # Headers are shared across partitions. > # A topology that adds a single header could append an infinite number of > headers (one per punctuate iteration), causing memory problems in the current > topology as well as down stream consumers since the headers are produced when > the records is produced to a topic. -- This message was sent by Atlassian Jira (v8.3.4#803005)
[jira] [Created] (KAFKA-9584) Removing headers causes ConcurrentModificationException
Micah Ramos created KAFKA-9584: -- Summary: Removing headers causes ConcurrentModificationException Key: KAFKA-9584 URL: https://issues.apache.org/jira/browse/KAFKA-9584 Project: Kafka Issue Type: Bug Components: streams Affects Versions: 2.0.0 Reporter: Micah Ramos The consumer record that is used during punctuate is static, this can cause java.util.ConcurrentModificationException when modifying the headers. Using a single instance of ConsumerRecord for all punctuates causes other strange behavior: # Headers are shared across partitions. # A topology that adds headers could append an infinite number of headers, causing memory problems in the current topology as well as down stream consumers since the headers are produced when the records is produced to a topic. -- This message was sent by Atlassian Jira (v8.3.4#803005)
