logstash-output-kafka 6.2.4 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 870dfa346e6d0aece5fa86221a1b54f4e01d7223012a7c6af5bdb759d8e9563d
-  data.tar.gz: 50608eda6ee0f6644de6831d13e607b04230bc9d027e692b98973b16e1482304
+SHA1:
+  metadata.gz: 16ba446928486f42a66917029451fe39f5273e79
+  data.tar.gz: 6dfef7dbad150d1f69ca07c47a38bbe40df66a0f
 SHA512:
-  metadata.gz: 9444f1648daaf96411cec7cc8f0ed576f060ec3c7f4b16ba37bba600b54a295297626deadb38aae5fcf6b1f36cc6ad64d9b449bc3e326dff13c39f857364a753
-  data.tar.gz: 4f68f1f9f01542372c621e8686b9604ff911851c8bab0477b4f42069b7bb7e269c324815c8bb65eadee6a8835a6cc56be7f385b5fc98227f40ced706a5026e13
+  metadata.gz: e7186f5cbbd2ad8b9ac238dbbf26a16ee057fbd5592ebc47e11f593d86acbcf78bdc017e80ec61405f699a731e7203350ed674792b02fa2d471e49bbef586879
+  data.tar.gz: 8531a86e70b27dabac9bce52c71eb51e244d5b4db2ac49a6e7a1bfe2eb450350bb61b6537bf2329cfa37f4f9fda9c1a474afde6688cbe5867155969e38248a2b

data/CHANGELOG.md

@@ -1,14 +1,5 @@
-## 6.2.4
-  - Backport of fixes from more recent branches:
-    - Fixed unnecessary sleep after exhausted retries [#166](https://github.com/logstash-plugins/logstash-output-kafka/pull/166)
-    - Changed Kafka send errors to log as warn [#179](https://github.com/logstash-plugins/logstash-output-kafka/pull/179)
-
-## 6.2.3
-  - Bugfix: Sends are now retried until successful. Previously, failed transmissions to Kafka
-    could have been lost by the KafkaProducer library. Now we verify transmission explicitly.
-    This changes the default 'retry' from 0 to retry-forever. It was a bug that we defaulted
-    to a retry count of 0.
-    https://github.com/logstash-plugins/logstash-output-kafka/pull/151
+## 7.0.0
+  - Breaking: mark deprecated `block_on_buffer_full`, `ssl` and `timeout_ms` options as obsolete
 
 ## 6.2.2
   - bump kafka dependency to 0.11.0.0

data/docs/index.asciidoc

@@ -20,11 +20,26 @@ include::{include_path}/plugin_header.asciidoc[]
 
 ==== Description
 
-Write events to a Kafka topic. 
-
-This plugin uses Kafka Client 0.11.0.0. For broker compatibility, see the official https://cwiki.apache.org/confluence/display/KAFKA/Compatibility+Matrix[Kafka compatibility reference].
-
-If you're using a plugin version that was released after {version}, see the https://www.elastic.co/guide/en/logstash/master/plugins-inputs-kafka.html[latest plugin documentation] for updated information about Kafka compatibility. If you require features not yet available in this plugin (including client version upgrades), please file an issue with details about what you need..
+Write events to a Kafka topic. This uses the Kafka Producer API to write messages to a topic on
+the broker.
+
+Here's a compatibility matrix that shows the Kafka client versions that are compatible with each combination
+of Logstash and the Kafka output plugin: 
+
+[options="header"]
+|==========================================================
+|Kafka Client Version |Logstash Version |Plugin Version |Why?
+|0.8       |2.0.0 - 2.x.x   |<3.0.0 |Legacy, 0.8 is still popular 
+|0.9       |2.0.0 - 2.3.x   | 3.x.x |Works with the old Ruby Event API (`event['product']['price'] = 10`)
+|0.9       |2.4.x - 5.x.x   | 4.x.x |Works with the new getter/setter APIs (`event.set('[product][price]', 10)`)
+|0.10.0.x  |2.4.x - 5.x.x   | 5.x.x |Not compatible with the <= 0.9 broker
+|0.10.1.x  |2.4.x - 5.x.x   | 6.x.x |
+|0.11.0.0  |2.4.x - 5.x.x   | 6.2.2 |Not compatible with the <= 0.9 broker
+|==========================================================
+
+NOTE: We recommended that you use matching Kafka client and broker versions. During upgrades, you should
+upgrade brokers before clients because brokers target backwards compatibility. For example, the 0.9 broker
+is compatible with both the 0.8 consumer and 0.9 consumer APIs, but not the other way around.
 
 This output supports connecting to Kafka over:
 
@@ -121,17 +136,6 @@ The producer will attempt to batch records together into fewer requests whenever
 records are being sent to the same partition. This helps performance on both the client
 and the server. This configuration controls the default batch size in bytes.
 
-[id="plugins-{type}s-{plugin}-block_on_buffer_full"]
-===== `block_on_buffer_full`  (DEPRECATED)
-
-  * DEPRECATED WARNING: This configuration item is deprecated and may not be available in future versions.
-  * Value type is <<boolean,boolean>>
-  * Default value is `true`
-
-When our memory buffer is exhausted we must either stop accepting new
-records (block) or throw errors. By default this setting is true and we block,
-however in some scenarios blocking is not desirable and it is better to immediately give an error.
-
 [id="plugins-{type}s-{plugin}-bootstrap_servers"]
 ===== `bootstrap_servers` 
 
@@ -287,17 +291,10 @@ retries are exhausted.
 ===== `retries` 
 
   * Value type is <<number,number>>
-  * There is no default value for this setting.
-
-The default retry behavior is to retry until successful. To prevent data loss,
-the use of this setting is discouraged.
-
-If you choose to set `retries`, a value greater than zero will cause the
-client to only retry a fixed number of times. This will result in data loss
-if a transport fault exists for longer than your retry count (network outage,
-Kafka down, etc).
+  * Default value is `0`
 
-A value less than zero is a configuration error.
+Setting a value greater than zero will cause the client to
+resend any record whose send fails with a potentially transient error.
 
 [id="plugins-{type}s-{plugin}-retry_backoff_ms"]
 ===== `retry_backoff_ms` 
@@ -342,15 +339,6 @@ Security protocol to use, which can be either of PLAINTEXT,SSL,SASL_PLAINTEXT,SA
 
 The size of the TCP send buffer to use when sending data.
 
-[id="plugins-{type}s-{plugin}-ssl"]
-===== `ssl`  (DEPRECATED)
-
-  * DEPRECATED WARNING: This configuration item is deprecated and may not be available in future versions.
-  * Value type is <<boolean,boolean>>
-  * Default value is `false`
-
-Enable SSL/TLS secured communication to Kafka broker.
-
 [id="plugins-{type}s-{plugin}-ssl_key_password"]
 ===== `ssl_key_password` 
 
@@ -407,19 +395,6 @@ The truststore password
 
 The truststore type.
 
-[id="plugins-{type}s-{plugin}-timeout_ms"]
-===== `timeout_ms`  (DEPRECATED)
-
-  * DEPRECATED WARNING: This configuration item is deprecated and may not be available in future versions.
-  * Value type is <<number,number>>
-  * Default value is `30000`
-
-The configuration controls the maximum amount of time the server will wait for acknowledgments
-from followers to meet the acknowledgment requirements the producer has specified with the
-acks configuration. If the requested number of acknowledgments are not met when the timeout
-elapses an error will be returned. This timeout is measured on the server side and does not
-include the network latency of the request.
-
 [id="plugins-{type}s-{plugin}-topic_id"]
 ===== `topic_id` 
 

data/lib/logstash/outputs/kafka.rb

@@ -71,10 +71,8 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
   # `host1:port1,host2:port2`, and the list can be a subset of brokers or a VIP pointing to a
   # subset of brokers.
   config :bootstrap_servers, :validate => :string, :default => 'localhost:9092'
-  # When our memory buffer is exhausted we must either stop accepting new
-  # records (block) or throw errors. By default this setting is true and we block,
-  # however in some scenarios blocking is not desirable and it is better to immediately give an error.
-  config :block_on_buffer_full, :validate => :boolean, :default => true, :deprecated => "This config will be removed in a future release"
+
+  config :block_on_buffer_full, :validate => :boolean, :obsolete => "This options is obsolete"
   # The total bytes of memory the producer can use to buffer records waiting to be sent to the server.
   config :buffer_memory, :validate => :number, :default => 33554432
   # The compression type for all data generated by the producer.
@@ -111,21 +109,15 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
   # elapses the client will resend the request if necessary or fail the request if
   # retries are exhausted.
   config :request_timeout_ms, :validate => :string
-  # The default retry behavior is to retry until successful. To prevent data loss,
-  # the use of this setting is discouraged.
-  #
-  # If you choose to set `retries`, a value greater than zero will cause the
-  # client to only retry a fixed number of times. This will result in data loss
-  # if a transient error outlasts your retry count.
-  #
-  # A value less than zero is a configuration error.
-  config :retries, :validate => :number
+  # Setting a value greater than zero will cause the client to
+  # resend any record whose send fails with a potentially transient error.
+  config :retries, :validate => :number, :default => 0
   # The amount of time to wait before attempting to retry a failed produce request to a given topic partition.
   config :retry_backoff_ms, :validate => :number, :default => 100
   # The size of the TCP send buffer to use when sending data.
   config :send_buffer_bytes, :validate => :number, :default => 131072
   # Enable SSL/TLS secured communication to Kafka broker.
-  config :ssl, :validate => :boolean, :default => false, :deprecated => "Use security_protocol => 'ssl'"
+  config :ssl, :validate => :boolean, :obsolete => "Use security_protocol => 'SSL'"
   # The truststore type.
   config :ssl_truststore_type, :validate => :string
   # The JKS truststore path to validate the Kafka broker's certificate.
@@ -168,12 +160,9 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
   config :jaas_path, :validate => :path
   # Optional path to kerberos config file. This is krb5.conf style as detailed in https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html
   config :kerberos_config, :validate => :path
-  # The configuration controls the maximum amount of time the server will wait for acknowledgments
-  # from followers to meet the acknowledgment requirements the producer has specified with the
-  # acks configuration. If the requested number of acknowledgments are not met when the timeout
-  # elapses an error will be returned. This timeout is measured on the server side and does not
-  # include the network latency of the request.
-  config :timeout_ms, :validate => :number, :default => 30000, :deprecated => "This config will be removed in a future release. Please use request_timeout_ms"
+
+  config :timeout_ms, :validate => :number, :obsolete => "This option is obsolete. Please use request_timeout_ms"
+
   # The topic to produce messages to
   config :topic_id, :validate => :string, :required => true
   # Serializer class for the value of the message
@@ -181,17 +170,6 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
 
   public
   def register
-    @thread_batch_map = Concurrent::Hash.new
-
-    if !@retries.nil? 
-      if @retries < 0
-        raise ConfigurationError, "A negative retry count (#{@retries}) is not valid. Must be a value >= 0"
-      end
-
-      @logger.warn("Kafka output is configured with finite retry. This instructs Logstash to LOSE DATA after a set number of send attempts fails. If you do not want to lose data if Kafka is down, then you must remove the retry setting.", :retries => @retries)
-    end
-
-
     @producer = create_producer
     @codec.on_event do |event, data|
       begin
@@ -200,7 +178,7 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
         else
           record = org.apache.kafka.clients.producer.ProducerRecord.new(event.sprintf(@topic_id), event.sprintf(@message_key), data)
         end
-        prepare(record)
+        @producer.send(record)
       rescue LogStash::ShutdownSignal
         @logger.debug('Kafka producer got shutdown signal')
       rescue => e
@@ -208,92 +186,14 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
                      :exception => e)
       end
     end
-  end # def register
-
-  def prepare(record)
-    # This output is threadsafe, so we need to keep a batch per thread.
-    @thread_batch_map[Thread.current].add(record)
-  end
-
-  def multi_receive(events)
-    t = Thread.current
-    if !@thread_batch_map.include?(t)
-      @thread_batch_map[t] = java.util.ArrayList.new(events.size)
-    end
-
-    events.each do |event|
-      break if event == LogStash::SHUTDOWN
-      @codec.encode(event)
-    end
-
-    batch = @thread_batch_map[t]
-    if batch.any?
-      retrying_send(batch)
-      batch.clear
-    end
-  end
-
-  def retrying_send(batch)
-    remaining = @retries
-
-    while batch.any?
-      if !remaining.nil?
-        if remaining < 0
-          # TODO(sissel): Offer to DLQ? Then again, if it's a transient fault,
-          # DLQing would make things worse (you dlq data that would be successful
-          # after the fault is repaired)
-          logger.info("Exhausted user-configured retry count when sending to Kafka. Dropping these events.",
-                      :max_retries => @retries, :drop_count => batch.count)
-          break
-        end
-
-        remaining -= 1
-      end
 
-      failures = []
-
-      futures = batch.collect do |record| 
-        begin
-          # send() can throw an exception even before the future is created.
-          @producer.send(record)
-        rescue org.apache.kafka.common.errors.TimeoutException => e
-          failures << record
-          nil
-        rescue org.apache.kafka.common.errors.InterruptException => e
-          failures << record
-          nil
-        rescue org.apache.kafka.common.errors.SerializationException => e
-          # TODO(sissel): Retrying will fail because the data itself has a problem serializing.
-          # TODO(sissel): Let's add DLQ here.
-          failures << record
-          nil
-        end
-      end.compact
-
-      futures.each_with_index do |future, i|
-        begin
-          result = future.get()
-        rescue => e
-          # TODO(sissel): Add metric to count failures, possibly by exception type.
-          logger.debug? && logger.debug("KafkaProducer.send() failed: #{e}", :exception => e);
-          failures << batch[i]
-        end
-      end
-
-      # No failures? Cool. Let's move on.
-      break if failures.empty?
+  end # def register
 
-      # Otherwise, retry with any failed transmissions
-      if remaining != nil && remaining < 0
-        logger.info("Sending batch to Kafka failed.", :batch_size => batch.size,:failures => failures.size)
-      else
-        delay = @retry_backoff_ms / 1000.0
-        logger.info("Sending batch to Kafka failed. Will retry after a delay.", :batch_size => batch.size,
-                    :failures => failures.size, :sleep => delay)
-        batch = failures
-        sleep(delay)
-      end
+  def receive(event)
+    if event == LogStash::SHUTDOWN
+      return
     end
+    @codec.encode(event)
   end
 
   def close
@@ -317,14 +217,14 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
       props.put(kafka::MAX_REQUEST_SIZE_CONFIG, max_request_size.to_s)
       props.put(kafka::RECONNECT_BACKOFF_MS_CONFIG, reconnect_backoff_ms) unless reconnect_backoff_ms.nil?
       props.put(kafka::REQUEST_TIMEOUT_MS_CONFIG, request_timeout_ms) unless request_timeout_ms.nil?
-      props.put(kafka::RETRIES_CONFIG, retries.to_s) unless retries.nil?
-      props.put(kafka::RETRY_BACKOFF_MS_CONFIG, retry_backoff_ms.to_s) 
+      props.put(kafka::RETRIES_CONFIG, retries.to_s)
+      props.put(kafka::RETRY_BACKOFF_MS_CONFIG, retry_backoff_ms.to_s)
       props.put(kafka::SEND_BUFFER_CONFIG, send_buffer_bytes.to_s)
       props.put(kafka::VALUE_SERIALIZER_CLASS_CONFIG, value_serializer)
 
       props.put("security.protocol", security_protocol) unless security_protocol.nil?
 
-      if security_protocol == "SSL" || ssl
+      if security_protocol == "SSL"
         set_trustore_keystore_config(props)
       elsif security_protocol == "SASL_PLAINTEXT"
         set_sasl_config(props)
@@ -336,9 +236,7 @@ class LogStash::Outputs::Kafka < LogStash::Outputs::Base
 
       org.apache.kafka.clients.producer.KafkaProducer.new(props)
     rescue => e
-      logger.error("Unable to create Kafka producer from given configuration",
-                   :kafka_error_message => e,
-                   :cause => e.respond_to?(:getCause) ? e.getCause() : nil)
+      logger.error("Unable to create Kafka producer from given configuration", :kafka_error_message => e)
       raise e
     end
   end

data/logstash-output-kafka.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-kafka'
-  s.version         = '6.2.4'
+  s.version         = '7.0.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = 'Output events to a Kafka topic. This uses the Kafka Producer API to write messages to a topic on the broker'
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"

data/spec/integration/outputs/kafka_spec.rb

@@ -157,7 +157,7 @@ describe "outputs/kafka", :integration => true do
   def load_kafka_data(config)
     kafka = LogStash::Outputs::Kafka.new(config)
     kafka.register
-    kafka.multi_receive(num_events.times.collect { event })
+    num_events.times do kafka.receive(event) end
     kafka.close
   end
 

data/spec/unit/outputs/kafka_spec.rb

@@ -25,168 +25,34 @@ describe "outputs/kafka" do
   context 'when outputting messages' do
     it 'should send logstash event to kafka broker' do
       expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-        .with(an_instance_of(org.apache.kafka.clients.producer.ProducerRecord)).and_call_original
+        .with(an_instance_of(org.apache.kafka.clients.producer.ProducerRecord))
       kafka = LogStash::Outputs::Kafka.new(simple_kafka_config)
       kafka.register
-      kafka.multi_receive([event])
+      kafka.receive(event)
     end
 
     it 'should support Event#sprintf placeholders in topic_id' do
       topic_field = 'topic_name'
       expect(org.apache.kafka.clients.producer.ProducerRecord).to receive(:new)
-        .with("my_topic", event.to_s).and_call_original
-      expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send).and_call_original
+        .with("my_topic", event.to_s)
+      expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
       kafka = LogStash::Outputs::Kafka.new({'topic_id' => "%{#{topic_field}}"})
       kafka.register
-      kafka.multi_receive([event])
+      kafka.receive(event)
     end
 
     it 'should support field referenced message_keys' do
       expect(org.apache.kafka.clients.producer.ProducerRecord).to receive(:new)
-        .with("test", "172.0.0.1", event.to_s).and_call_original
-      expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send).and_call_original
+        .with("test", "172.0.0.1", event.to_s)
+      expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
       kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge({"message_key" => "%{host}"}))
       kafka.register
-      kafka.multi_receive([event])
+      kafka.receive(event)
     end
-
+    
     it 'should raise config error when truststore location is not set and ssl is enabled' do
-      kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge("security_protocol" => "SSL"))
+      kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge({"ssl" => "true"}))
       expect { kafka.register }.to raise_error(LogStash::ConfigurationError, /ssl_truststore_location must be set when SSL is enabled/)
     end
   end
-  
-  context "when KafkaProducer#send() raises an exception" do
-    let(:failcount) { (rand * 10).to_i }
-    let(:sendcount) { failcount + 1 }
-
-    let(:exception_classes) { [
-      org.apache.kafka.common.errors.TimeoutException,
-      org.apache.kafka.common.errors.InterruptException,
-      org.apache.kafka.common.errors.SerializationException
-    ] }
-
-    before do
-      count = 0
-      expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-        .exactly(sendcount).times
-        .and_wrap_original do |m, *args|
-        if count < failcount # fail 'failcount' times in a row.
-          count += 1
-          # Pick an exception at random
-          raise exception_classes.shuffle.first.new("injected exception for testing")
-        else
-          m.call(*args) # call original
-        end
-      end
-    end
-
-    it "should retry until successful" do
-      kafka = LogStash::Outputs::Kafka.new(simple_kafka_config)
-      kafka.register
-      kafka.multi_receive([event])
-    end
-  end
-
-  context "when a send fails" do
-    context "and the default retries behavior is used" do
-      # Fail this many times and then finally succeed.
-      let(:failcount) { (rand * 10).to_i }
-
-      # Expect KafkaProducer.send() to get called again after every failure, plus the successful one.
-      let(:sendcount) { failcount + 1 }
-
-      it "should retry until successful" do
-        count = 0;
-
-        expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-              .exactly(sendcount).times
-              .and_wrap_original do |m, *args|
-          if count < failcount
-            count += 1
-            # inject some failures.
-
-            # Return a custom Future that will raise an exception to simulate a Kafka send() problem.
-            future = java.util.concurrent.FutureTask.new { raise "Failed" }
-            future.run
-            future
-          else
-            m.call(*args)
-          end
-        end
-        kafka = LogStash::Outputs::Kafka.new(simple_kafka_config)
-        kafka.register
-        kafka.multi_receive([event])
-      end
-    end
-
-    context 'when retries is 0' do
-      let(:retries) { 0  }
-      let(:max_sends) { 1 }
-
-      it "should should only send once" do
-        expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-                                                                                       .once
-                                                                                       .and_wrap_original do |m, *args|
-          # Always fail.
-          future = java.util.concurrent.FutureTask.new { raise "Failed" }
-          future.run
-          future
-        end
-        kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge("retries" => retries))
-        kafka.register
-        kafka.multi_receive([event])
-      end
-
-      it 'should not sleep' do
-        expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-                                                                                       .once
-                                                                                       .and_wrap_original do |m, *args|
-          # Always fail.
-          future = java.util.concurrent.FutureTask.new { raise "Failed" }
-          future.run
-          future
-        end
-
-        kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge("retries" => retries))
-        expect(kafka).not_to receive(:sleep).with(anything)
-        kafka.register
-        kafka.multi_receive([event])
-      end
-    end
-
-    context "and when retries is set by the user" do
-      let(:retries) { (rand * 10).to_i }
-      let(:max_sends) { retries + 1 }
-
-      it "should give up after retries are exhausted" do
-        expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-              .at_most(max_sends).times
-              .and_wrap_original do |m, *args|
-          # Always fail.
-          future = java.util.concurrent.FutureTask.new { raise "Failed" }
-          future.run
-          future
-        end
-        kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge("retries" => retries))
-        kafka.register
-        kafka.multi_receive([event])
-      end
-
-      it 'should only sleep retries number of times' do
-        expect_any_instance_of(org.apache.kafka.clients.producer.KafkaProducer).to receive(:send)
-                                                                                       .at_most(max_sends)
-                                                                                       .and_wrap_original do |m, *args|
-          # Always fail.
-          future = java.util.concurrent.FutureTask.new { raise "Failed" }
-          future.run
-          future
-        end
-        kafka = LogStash::Outputs::Kafka.new(simple_kafka_config.merge("retries" => retries))
-        expect(kafka).to receive(:sleep).exactly(retries).times
-        kafka.register
-        kafka.multi_receive([event])
-      end
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-kafka
 version: !ruby/object:Gem::Version
-  version: 6.2.4
+  version: 7.0.0
 platform: ruby
 authors:
 - Elasticsearch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-12 00:00:00.000000000 Z
+date: 2017-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -114,9 +114,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: This gem is a Logstash plugin required to be installed on top of the
-  Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This
-  gem is not a stand-alone program
+description: This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program
 email: info@elastic.co
 executables: []
 extensions: []
@@ -178,11 +176,10 @@ requirements:
 - jar 'org.slf4j:slf4j-log4j12', '1.7.21'
 - jar 'org.apache.logging.log4j:log4j-1.2-api', '2.6.2'
 rubyforge_project:
-rubygems_version: 2.6.13
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
-summary: Output events to a Kafka topic. This uses the Kafka Producer API to write
-  messages to a topic on the broker
+summary: Output events to a Kafka topic. This uses the Kafka Producer API to write messages to a topic on the broker
 test_files:
 - spec/integration/outputs/kafka_spec.rb
 - spec/unit/outputs/kafka_spec.rb