anchor.diff:              "DEBUG"
             ]
             
  -=== metricReporters
  +`metricReporters`
   
   A list of classes to use as metrics reporters. Implementing the org.apache.kafka.common.metrics.MetricsReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics.
   
  -=== keyDeserializer
  +`keyDeserializer`
   
   Deserializer class for key that implements the org.apache.kafka.common.serialization.Deserializer interface.
   
             "default": "org.apache.kafka.common.serialization.StringDeserializer"
             
  -=== valueDeserializer
  +`valueDeserializer`
   
   Deserializer class for value that implements the org.apache.kafka.common.serialization.Deserializer interface.
   
             "default": "org.apache.kafka.common.serialization.StringDeserializer"
   
  -=== requestTimeoutMs
  +`requestTimeoutMs`
   
   The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted.
   
             "default": 30000,
             "minimum": 0
             
  -=== defaultApiTimeoutMs
  +`defaultApiTimeoutMs`
   
   Specifies the timeout (in milliseconds) for client APIs. This configuration is used as the default timeout for all client operations that do not specify a timeout parameter.
   
             "default": 60000,
             "minimum": 0
             
  -=== connectionsMaxIdleMs
  +`connectionsMaxIdleMs`
   
   Close idle connections after the number of milliseconds specified by this config.
   
             "default": 540000
             
  -=== interceptorClasses
  +`interceptorClasses`
   
   A list of classes to use as interceptors. Implementing the org.apache.kafka.clients.consumer.ConsumerInterceptor interface allows you to intercept (and possibly mutate) records received by the consumer. By default, there are no interceptors.
   
  -=== maxPollRecords
  +`maxPollRecords`
   
   The maximum number of records returned in a single call to poll().
   
             "default": 500,
             "minimum": 1
             
  -=== maxPollIntervalMs
  +`maxPollIntervalMs`
   
   The maximum delay between invocations of poll() when using consumer group management. This places an upper bound on the amount of time that the consumer can be idle before fetching more records. If poll() is not called before expiration of this timeout, then the consumer is considered failed and the group will rebalance in order to reassign the partitions to another member. For consumers using a non-null group.instance.id which reach this timeout, partitions will not be immediately reassigned. Instead, the consumer will stop sending heartbeats and partitions will be reassigned after expiration of session.timeout.ms. This mirrors the behavior of a static consumer which has shutdown.
   
             "default": 300000,
             "minimum": 1
             
  -=== excludeInternalTopics
  +`excludeInternalTopics`
   
   Whether internal topics matching a subscribed pattern should be excluded from the subscription. It is always possible to explicitly subscribe to an internal topic.
   
             "default": true
             
  -=== isolationLevel
  +`isolationLevel`
   
   Controls how to read messages written transactionally. If set to read_committed, consumer.poll() will only return transactional messages which have been committed. If set to read_uncommitted (the default), consumer.poll() will return all messages, even transactional messages which have been aborted. Non-transactional messages will be returned unconditionally in either mode.+
   Messages will always be returned in offset order. Hence, in read_committed mode, consumer.poll() will only return messages up to the last stable offset (LSO), which is the one less than the offset of the first open transaction. In particular any messages appearing after messages belonging to ongoing transactions will be withheld until the relevant transaction has been completed. As a result, read_committed consumers will not be able to read up to the high watermark when there are in flight transactions.+
   Further, when in read_committed the seekToEnd method will return the LSO
   
  -         [source, json]
  -         ----
  +         
            "default": "READ_UNCOMMITTED
             "enum": [
               "READ_COMMITTED
               "READ_UNCOMMITTED"
             ]
  -          ----
  -          
  -=== allowAutoCreateTopics
  +          
  +          
  +`allowAutoCreateTopics`
   
   Allow automatic topic creation on the broker when subscribing to or assigning a topic. A topic being subscribed to will be automatically created only if the broker allows for it using auto.create.topics.enable broker configuration. This configuration must be set to false when using brokers older than 0.11.0
   
             "default": true
             
  -=== securityProviders
  +`securityProviders`
   
   A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the org.apache.kafka.common.security.auth.SecurityProviderCreator interface.
   
  -=== securityProtocol
  +`securityProtocol`
   
   Protocol used to communicate with brokers.
   
  
positive.code:             "DEBUG"
            ]
  
  === metricReporters
  
  A list of classes to use as metrics reporters. Implementing the org.apache.kafka.common.metrics.MetricsReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics.
  
  === maxInFlightRequestsPerConnection
  
  The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this setting is set to be greater than 1 and there are failed sends, there is a risk of message re-ordering due to retries (i.e., if retries are enabled).
  
            "default": 5,
            "minimum": 1
  
  === keySerializer
  
  Serializer class for key that implements the org.apache.kafka.common.serialization.Serializer interface.
  
            "default": "org.apache.kafka.common.serialization.StringSerializer"
  
  === valueSerializer
  
  Serializer class for value that implements the org.apache.kafka.common.serialization.Serializer interface.
  
            "default": "org.apache.kafka.common.serialization.StringSerializer"
  
  === connectionsMaxIdleMs
  
  Close idle connections after the number of milliseconds specified by this config.
  
            "default": 540000
  
  === partitionerClass
  
  Partitioner class that implements the org.apache.kafka.clients.producer.Partitioner interface.
  
            "default": "org.apache.kafka.clients.producer.internals.DefaultPartitioner"
  
  === interceptorClasses
  
  A list of classes to use as interceptors. Implementing the org.apache.kafka.clients.consumer.ConsumerInterceptor interface allows you to intercept (and possibly mutate) records received by the consumer. By default, there are no interceptors.
  
  === securityProtocol
  
  Protocol used to communicate with brokers.
  
  
negative.code:       }
        ----
  
  === Kafka producer settings
  
  `bufferMemory`
  
  The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will block for max.block.ms after which it will throw an exception.<p>This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests.
  
            "default": 33554432,
            "minimum": 0
            
  `retries`
  
  Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Note that this retry is no different than if the client resent the record upon receiving the error. Allowing retries without setting max.in.flight.requests.per.connection to 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first. Note additionally that produce requests will be failed before the number of retries has been exhausted if the timeout configured by delivery.timeout.ms expires first before successful acknowledgement. Users should generally prefer to leave this config unset and instead use delivery.timeout.ms to control retry behavior.
  
  