logstash-codec-multiline 2.0.7 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36df6112f2d0e3f3d6b3d0481a72e5250fae5352
-  data.tar.gz: b86e58bbb8f62680e7ab478adc0d75a3d61d6530
+  metadata.gz: f9e0a15839b1bbabcad88ee95445b72ed589a4dd
+  data.tar.gz: bdf59bcab8b5ad4fc35906de033bde7ed658e52a
 SHA512:
-  metadata.gz: afe492266d2d77c9946ff76ad71e755f8d03a655222f92673f70d0804b99543edd82dbb3365674f1f640036eb24cb42c6f3b65d6bea290378e959de6f6356bfe
-  data.tar.gz: e053998e3802437a06a82b5997f28c8bc4983b80c936a1d9bbbe3b81a4a99be11f6086dac0f01a73c69fb2770728ee6ef030f807714c226a7e570815d11c49d2
+  metadata.gz: 5e0bcea055b8af6ebbd45300e2901146a2770b7937de6ca8b5f08f4a01b347cc7b876d3b675589c475b3b41f4ce65632e7edc44432a2f00b2abc5f9b7dc5d899
+  data.tar.gz: 6333ad636771cc1e9407f9642f242ff40f59181b4073fe55e2b3aa93b9cd675ca435961aabc7f054c4cad6be072bdefc42395198b14cafb3ba7b286474e888ab

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 2.0.8
+ - Fix for issue #28, Memory leak when using cancel + execute on ScheduledTask.
+
 ## 2.0.7
  - Fix for issue #23, Thread deadlock on auto-flush when using multiple inputs with this codec. Use cancel + execute on ScheduledTask instead of reset.
 

data/Gemfile

@@ -1,3 +1,2 @@
 source 'https://rubygems.org'
-gemspec
-gem "concurrent-ruby", "0.9.1"
+gemspec

data/lib/logstash/codecs/auto_flush.rb

@@ -1,74 +1,32 @@
 # encoding: utf-8
 require "concurrent"
+require "logstash/codecs/retriggerable_task"
 
 module LogStash module Codecs class AutoFlush
   def initialize(mc, interval)
     @mc, @interval = mc, interval
     @stopped = Concurrent::AtomicBoolean.new # false by default
+    @task = RetriggerableTask.new(@interval, self)
   end
 
-  # def start
-  #   # can't start if pipeline is stopping
-  #   return self if stopped?
-  #   if pending?
-  #     @task.cancel
-  #     create_task
-  #   elsif finished?
-  #     create_task
-  #   # else the task is executing
-  #   end
-  #   self
-  # end
+  def timeout
+    @mc.auto_flush
+  end
 
   def start
     # can't start if pipeline is stopping
     return self if stopped?
-
-    if pending? && @task.cancel
-      create_task
-      return self
-    end
-    # maybe we have a timing edge case
-    # where pending? was true but cancel failed
-    # because the task started running
-    if finished?
-      create_task
-      return self
-    end
-    # else the task is executing
-    # wait for task to complete
-    # flush could feasibly block on queue access
-    @task.value
-    create_task
+    @task.retrigger
     self
   end
 
-  def create_task
-    @task = Concurrent::ScheduledTask.execute(@interval) do
-      @mc.auto_flush()
-    end
-  end
-
-  def finished?
-    return true if @task.nil?
-    @task.fulfilled?
-  end
-
-  def pending?
-    @task && @task.pending?
-  end
-
   def stopped?
     @stopped.value
   end
 
   def stop
     @stopped.make_true
-    cancel
-  end
-
-  def cancel
-    @task.cancel if pending?
+    @task.close
   end
 end
 
@@ -76,10 +34,6 @@ class AutoFlushUnset
   def initialize(mc, interval)
   end
 
-  def pending?
-    false
-  end
-
   def stopped?
     true
   end
@@ -88,15 +42,7 @@ class AutoFlushUnset
     self
   end
 
-  def finished?
-    true
-  end
-
   def stop
     self
   end
-
-  def cancel
-    self
-  end
 end end end

data/lib/logstash/codecs/identity_map_codec.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 require "logstash/namespace"
 require "thread_safe"
+require "concurrent"
 
 # This class is a Codec duck type
 # Using Composition, it maps from a stream identity to
@@ -37,41 +38,51 @@ module LogStash module Codecs class IdentityMapCodec
     end
   end
 
-  class MapCleaner
-    def initialize(imc, interval)
-      @imc, @interval = imc, interval
-      @running = false
+  class PeriodicRunner
+    def initialize(listener, interval, method_symbol)
+      @listener, @interval = listener, interval
+      @method_symbol = method_symbol
+      @running = Concurrent::AtomicBoolean.new(false)
     end
 
     def start
       return self if running?
-      @running = true
-      @thread = Thread.new(@imc) do |imc|
-        loop do
+      @running.make_true
+      @thread = Thread.new() do
+        while running? do
           sleep @interval
-          break if !@running
-          imc.map_cleanup
+          break if !running?
+          @listener.send(@method_symbol)
         end
       end
       self
     end
 
     def running?
-      @running
+      @running.value
     end
 
     def stop
       return if !running?
-      @running = false
-      @thread.wakeup if @thread.alive?
+      @running.make_false
+      if @thread.alive?
+        @thread.wakeup
+        @thread.join
+      end
+      @listener = nil
     end
   end
 
-  # A composite class to hold both the codec and the eviction_timeout
+  class NoopRunner
+    attr_reader :start, :stop
+    def running?() false; end
+  end
+
+  # A composite class to hold both the codec, the eviction_timeout and a last_used timestamp
   # instances of this Value Object are stored in the mapping hash
   class CodecValue
     attr_reader :codec
-    attr_accessor :timeout
+    attr_accessor :eviction_timeout, :auto_flush_timeout
 
     def initialize(codec)
       @codec = codec
@@ -92,7 +103,7 @@ module LogStash module Codecs class IdentityMapCodec
   CLEANER_INTERVAL = 60 * 5 # 5 minutes
 
   attr_reader :identity_map
-  attr_accessor :base_codec, :cleaner
+  attr_accessor :base_codec, :cleaner, :auto_flusher
 
   def initialize(codec)
     @base_codec = codec
@@ -100,7 +111,14 @@ module LogStash module Codecs class IdentityMapCodec
     @identity_map = ThreadSafe::Hash.new &method(:codec_builder)
     @max_identities = MAX_IDENTITIES
     @evict_timeout = EVICT_TIMEOUT
-    @cleaner = MapCleaner.new(self, CLEANER_INTERVAL)
+    cleaner_interval(CLEANER_INTERVAL)
+    if codec.respond_to?(:use_mapper_auto_flush) &&
+        (@auto_flush_interval = codec.use_mapper_auto_flush)
+      @auto_flusher = PeriodicRunner.new(self, 0.5, :auto_flush_mapped)
+    else
+      @auto_flusher = NoopRunner.new
+    end
+
     @decode_block = lambda {|*| true }
     @eviction_block = nil
   end
@@ -123,8 +141,8 @@ module LogStash module Codecs class IdentityMapCodec
 
   # used to add  a non-default cleaner interval
   def cleaner_interval(interval)
-    @cleaner.stop
-    @cleaner = MapCleaner.new(self, interval.to_i)
+    @cleaner.stop if @cleaner
+    @cleaner = PeriodicRunner.new(self, interval.to_i, :map_cleanup)
     self
   end
 
@@ -133,6 +151,7 @@ module LogStash module Codecs class IdentityMapCodec
     @eviction_block = block
     self
   end
+
   # end Constructional/builder methods
   # ==============================================
 
@@ -182,11 +201,34 @@ module LogStash module Codecs class IdentityMapCodec
 
   def close()
     cleaner.stop
+    auto_flusher.stop
     all_codecs.each(&:close)
   end
   # end Codec API
   # ==============================================
 
+  def auto_flush_mapped
+    if !identity_count.zero?
+      nowf = Time.now.to_f
+      identity_map.each do |identity, compo|
+        next if compo.auto_flush_timeout.zero?
+        next unless nowf > compo.auto_flush_timeout
+        compo.codec.auto_flush
+        # at eof (tail and read) no more lines for a while or ever
+        # so reset compo.auto_flush_timeout
+        compo.auto_flush_timeout = 0
+      end
+    end
+  end
+
+  def flush_mapped(listener)
+    listener_has_path = listener.respond_to?(:path)
+    identity_map.each do |identity, compo|
+      listener.path = identity if listener_has_path
+      compo.codec.auto_flush(listener)
+    end
+  end
+
   def all_codecs
     no_streams? ? @base_codecs : identity_map.values.map(&:codec)
   end
@@ -204,14 +246,16 @@ module LogStash module Codecs class IdentityMapCodec
   # been accessed in the last @evict_timeout
   # period (default 1 hour)
   def map_cleanup
-    cut_off = Time.now.to_i
-    # delete_if is atomic
-    # contents should not mutate during this call
-    identity_map.delete_if do |identity, compo|
-      if (flag = compo.timeout <= cut_off)
-        evict_flush(compo.codec)
+    if !identity_count.zero?
+      nowi = Time.now.to_i
+      # delete_if is atomic
+      # contents should not mutate during this call
+      identity_map.delete_if do |identity, compo|
+        if (flag = compo.eviction_timeout <= nowi)
+          evict_flush(compo.codec)
+        end
+        flag
       end
-      flag
     end
     current_size_and_limit
   end
@@ -241,7 +285,7 @@ module LogStash module Codecs class IdentityMapCodec
   end
 
   def eviction_timestamp_for(identity)
-    find_codec_value(identity).timeout
+    find_codec_value(identity).eviction_timeout
   end
 
   private
@@ -261,13 +305,20 @@ module LogStash module Codecs class IdentityMapCodec
     # only start the cleaner if streams are in use
     # continuous calls to start are OK
     cleaner.start
+    auto_flusher.start
     compo = find_codec_value(identity)
-    compo.timeout = eviction_timestamp
+    now = Time.now
+    compo.eviction_timeout = eviction_timestamp(now)
+    compo.auto_flush_timeout = auto_flush_timestamp(now)
     compo.codec
   end
 
-  def eviction_timestamp
-    Time.now.to_i + @evict_timeout
+  def auto_flush_timestamp(now = Time.now)
+    now.to_f + @auto_flush_interval.to_f
+  end
+
+  def eviction_timestamp(now = Time.now)
+    now.to_i + @evict_timeout
   end
 
   def check_map_limits
@@ -277,6 +328,7 @@ module LogStash module Codecs class IdentityMapCodec
 
   def codec_builder(hash, k)
     codec = hash.empty? ? @base_codec : @base_codec.clone
+    codec.use_mapper_auto_flush if using_mapped_auto_flush?
     compo = CodecValue.new(codec)
     hash.store(k, compo)
   end
@@ -284,4 +336,8 @@ module LogStash module Codecs class IdentityMapCodec
   def no_streams?
     identity_map.empty?
   end
+
+  def using_mapped_auto_flush?
+    !@auto_flush_interval.nil?
+  end
 end end end

data/lib/logstash/codecs/multiline.rb

@@ -171,6 +171,12 @@ module LogStash module Codecs class Multiline < LogStash::Codecs::Base
     end
   end # def register
 
+  def use_mapper_auto_flush
+    return unless auto_flush_active?
+    @auto_flush_runner = AutoFlushUnset.new(nil, nil)
+    @auto_flush_interval = @auto_flush_interval.to_f
+  end
+
   def accept(listener)
     # memoize references to listener that holds upstream state
     @previous_listener = @last_seen_listener || listener
@@ -215,9 +221,11 @@ module LogStash module Codecs class Multiline < LogStash::Codecs::Base
     end
   end
 
-  def auto_flush
+  def auto_flush(listener = @last_seen_listener)
+    return if listener.nil?
+
     flush do |event|
-      @last_seen_listener.process_event(event)
+      listener.process_event(event)
     end
   end
 
@@ -272,11 +280,7 @@ module LogStash module Codecs class Multiline < LogStash::Codecs::Base
   end # def encode
 
   def close
-    if auto_flush_runner.pending?
-      #will cancel task if necessary
-      auto_flush_runner.stop
-    end
-    auto_flush
+    auto_flush_runner.stop
   end
 
   def auto_flush_active?

data/lib/logstash/codecs/retriggerable_task.rb

@@ -0,0 +1,81 @@
+require "concurrent"
+
+module LogStash module Codecs class RetriggerableTask
+  SLEEP_FOR = 0.25.freeze
+
+  attr_reader :thread
+
+  def initialize(delay, listener)
+    @count = calculate_count(delay)
+    @listener = listener
+    @counter = Concurrent::AtomicFixnum.new(0 + @count)
+    @stopped = Concurrent::AtomicBoolean.new(false)
+    @semaphore = Concurrent::Semaphore.new(1)
+  end
+
+  def retrigger
+    return if stopped?
+    if executing?
+      @semaphore.acquire
+    end
+
+    if pending?
+      reset_counter
+    else
+      start
+    end
+  end
+
+  def close
+    @stopped.make_true
+  end
+
+  def counter
+    @counter.value
+  end
+
+  def executing?
+    running? && counter < 1
+  end
+
+  def pending?
+    running? && counter > 0
+  end
+
+  private
+
+  def calculate_count(value)
+    # in multiples of SLEEP_FOR (0.25) seconds
+    # if delay is 10 seconds then count is 40
+    # this only works when SLEEP_FOR is less than 1
+    return 1 if value < SLEEP_FOR
+    (value / SLEEP_FOR).floor
+  end
+
+  def reset_counter
+    @counter.value = 0 + @count
+  end
+
+  def running?
+    @thread && @thread.alive?
+  end
+
+  def start()
+    reset_counter
+    @thread = Thread.new do
+      while counter > 0
+        break if stopped?
+        sleep SLEEP_FOR
+        @counter.decrement
+      end
+
+      @semaphore.drain_permits
+      @listener.timeout if !stopped?
+      @semaphore.release
+    end
+  end
+
+  def stopped?
+    @stopped.value
+  end
+end end end

data/logstash-codec-multiline.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-codec-multiline'
-  s.version         = '2.0.7'
+  s.version         = '2.0.8'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "The multiline codec will collapse multiline messages and merge them into a single event."
   s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"

data/spec/codecs/auto_flush_spec.rb

@@ -4,109 +4,102 @@ require "logstash/codecs/multiline"
 require_relative "../supports/helpers.rb"
 
 describe "AutoFlush and AutoFlushUnset" do
+  before(:all) do
+    @thread_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+
+  after(:all) do
+    Thread.abort_on_exception = @thread_abort
+  end
+
   let(:flushable)  { Mlc::AutoFlushTracer.new }
-  let(:flush_wait) { 0.1 }
+  let(:flush_wait) { 0.25 }
 
   describe LogStash::Codecs::AutoFlush do
     subject { described_class.new(flushable, flush_wait) }
 
     context "when initialized" do
-      it "#pending? is false" do
-        expect(subject.pending?).to be_falsy
-      end
-
       it "#stopped? is false" do
-        expect(subject.stopped?).to be_falsy
-      end
-
-      it "#finished? is true" do
-        expect(subject.finished?).to be_truthy
+        expect(subject.stopped?).to be_falsey
       end
     end
 
-    context "when started" do
-      let(:flush_wait) { 20 }
-
+    context "when starting once" do
       before { subject.start }
       after  { subject.stop }
 
-      it "#pending? is true" do
-        expect(subject.pending?).to be_truthy
-      end
-
-      it "#stopped? is false" do
-        expect(subject.stopped?).to be_falsy
-      end
-
-      it "#finished? is false" do
-        expect(subject.finished?).to be_falsy
+      it "calls auto_flush on flushable" do
+        sleep flush_wait + 0.5
+        expect(flushable.trace_for(:auto_flush)).to be_truthy
       end
     end
 
-    context "when finished" do
-      before do
-        subject.start
-        sleep flush_wait + 0.1
-      end
-
+    context "when starting multiple times" do
+      before { subject.start }
       after  { subject.stop }
 
       it "calls auto_flush on flushable" do
-        expect(flushable.trace_for(:auto_flush)).to be_truthy
-      end
+        expect(flushable.trace_for(:auto_flush)).to be_falsey
+        sleep 0.1
+        subject.start
+        expect(flushable.trace_for(:auto_flush)).to be_falsey
+        sleep 0.1
+        subject.start
+        expect(flushable.trace_for(:auto_flush)).to be_falsey
 
-      it "#pending? is false" do
-        expect(subject.pending?).to be_falsy
+        sleep flush_wait + 0.5
+        expect(flushable.trace_for(:auto_flush)).to be_truthy
       end
+    end
 
-      it "#stopped? is false" do
-        expect(subject.stopped?).to be_falsy
+    context "when retriggering during execution" do
+      let(:flush_wait) { 1 }
+      let(:delay)      { 1 }
+      before do
+        flushable.set_delay(delay)
+        subject.start
       end
+      after  { subject.stop }
 
-      it "#finished? is true" do
-        expect(subject.finished?).to be_truthy
+      it "calls auto_flush twice on flushable" do
+        now = Time.now.to_f
+        combined_time = flush_wait + delay
+        expect(flushable.trace_for(:auto_flush)).to be_falsey
+        sleep flush_wait + 0.25 # <---- wait for execution to start
+        subject.start          # <---- because of the semaphore, this waits for delay = 2 seconds, then starts a new thread
+        sleep combined_time + 0.5   # <---- wait for more than 4 seconds = flush_wait + delay
+        elapsed1, elapsed2 = flushable.full_trace_for(:delay).map{ |el| (el - now).floor }
+        expect(elapsed1).to eq(combined_time)
+        expect(elapsed2).to eq(2 * combined_time)
+        expect(flushable.full_trace_for(:auto_flush)).to eq([true, true])
       end
     end
 
-    context "when stopped" do
+    context "when stopping before timeout" do
       before do
         subject.start
+        sleep 0.1
         subject.stop
       end
 
       it "does not call auto_flush on flushable" do
-        expect(flushable.trace_for(:auto_flush)).to be_falsy
-      end
-
-      it "#pending? is false" do
-        expect(subject.pending?).to be_falsy
+        expect(flushable.trace_for(:auto_flush)).to be_falsey
       end
 
       it "#stopped? is true" do
         expect(subject.stopped?).to be_truthy
       end
-
-      it "#finished? is false" do
-        expect(subject.finished?).to be_falsy
-      end
     end
   end
 
   describe LogStash::Codecs::AutoFlushUnset do
     subject { described_class.new(flushable, 2) }
 
-    it "#pending? is false" do
-      expect(subject.pending?).to be_falsy
-    end
-
     it "#stopped? is true" do
       expect(subject.stopped?).to be_truthy
     end
 
-    it "#finished? is true" do
-      expect(subject.finished?).to be_truthy
-    end
-
     it "#start returns self" do
       expect(subject.start).to eq(subject)
     end

data/spec/codecs/identity_map_codec_spec.rb

@@ -12,6 +12,15 @@ describe LogStash::Codecs::IdentityMapCodec do
   let(:codec1)  { demuxer.codec_without_usage_update(stream1) }
   let(:arg1)    { "data-a" }
 
+  before(:all) do
+    @thread_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+
+  after(:all) do
+    Thread.abort_on_exception = @thread_abort
+  end
+
   after do
     codec.close
   end
@@ -206,8 +215,7 @@ describe LogStash::Codecs::IdentityMapCodec do
     let(:imc) { described_class.new(mlc) }
 
     before do
-      listener = Mlc::LineListener.new(queue, imc, identity)
-      listener.accept("foo")
+      l_0 = Mlc::LineListener.new(queue, imc, identity).tap {|o| o.accept("foo")}
     end
 
     describe "normal processing" do
@@ -221,11 +229,23 @@ describe LogStash::Codecs::IdentityMapCodec do
 
       context "when wrapped codec has auto-flush activated" do
         let(:config) { {"pattern" => "^\\s", "what" => "previous", "auto_flush_interval" => 0.2} }
-        it "one event is generated" do
-          sleep 0.4
-          expect(queue.size).to eq(1)
-          expect(queue[0]["message"]).to eq("foo")
-          expect(imc.identity_count).to eq(1)
+        before do
+          l_1 = Mlc::LineListener.new(queue, imc, "stream2").tap {|o| o.accept("bar")}
+          l_2 = Mlc::LineListener.new(queue, imc, "stream3").tap {|o| o.accept("baz")}
+        end
+        it "three events are auto flushed from three different identities/codecs" do
+          sleep 0.6 # wait for auto_flush - in multiples of 0.5 plus 0.1
+          expect(queue.size).to eq(3)
+          e1, e2, e3 = queue
+          expect(e1["path"]).to eq("stream1")
+          expect(e1["message"]).to eq("foo")
+
+          expect(e2["path"]).to eq("stream2")
+          expect(e2["message"]).to eq("bar")
+
+          expect(e3["path"]).to eq("stream3")
+          expect(e3["message"]).to eq("baz")
+          expect(imc.identity_count).to eq(3)
         end
       end
     end

data/spec/codecs/multiline_spec.rb

@@ -225,7 +225,7 @@ describe LogStash::Codecs::Multiline do
         "de.log" => ["Hallo Welt"] }
     end
     let(:listener_class) { Mlc::LineListener }
-    let(:auto_flush_interval) { 0.5 }
+    let(:auto_flush_interval) { 2 }
 
     let(:line_producer) do
       lambda do |path|

data/spec/supports/helpers.rb

@@ -73,6 +73,10 @@ module Mlc
       params.nil? ? false : params.last
     end
 
+    def full_trace_for(symbol)
+      @tracer.select{|array| array[0] == symbol}.map(&:last)
+    end
+
     def clear()
       @tracer.clear()
     end
@@ -91,7 +95,16 @@ module Mlc
   end
 
   class AutoFlushTracer < TracerBase
-    def auto_flush() @tracer.push [:auto_flush, true]; end
+    def auto_flush() simulate_execution_delay; @tracer.push [:auto_flush, true]; end
+    def set_delay(delay)
+      @delay = delay
+    end
+
+    def simulate_execution_delay
+      return if @delay.nil? || @delay.zero?
+      sleep @delay
+      @tracer.push [:delay, Time.now.to_f]
+    end
   end
 
   class IdentityMapCodecTracer < TracerBase

metadata

@@ -1,77 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: logstash-codec-multiline
 version: !ruby/object:Gem::Version
-  version: 2.0.7
+  version: 2.0.8
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-27 00:00:00.000000000 Z
+date: 2016-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: logstash-core
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
-    - - "<"
+    - - <
       - !ruby/object:Gem::Version
         version: 3.0.0
-  name: logstash-core
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
-    - - "<"
+    - - <
       - !ruby/object:Gem::Version
         version: 3.0.0
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
+  name: logstash-patterns-core
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-patterns-core
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: jls-grok
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
+        version: 0.11.1
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 0.11.1
-  name: jls-grok
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-devutils
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 0.11.1
-- !ruby/object:Gem::Dependency
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-devutils
   prerelease: false
   type: :development
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !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/plugin install gemname. This gem is not a stand-alone program
 email: info@elastic.co
 executables: []
@@ -87,6 +87,7 @@ files:
 - lib/logstash/codecs/auto_flush.rb
 - lib/logstash/codecs/identity_map_codec.rb
 - lib/logstash/codecs/multiline.rb
+- lib/logstash/codecs/retriggerable_task.rb
 - logstash-codec-multiline.gemspec
 - spec/codecs/auto_flush_spec.rb
 - spec/codecs/identity_map_codec_spec.rb
@@ -104,12 +105,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []