logstash-input-redis 3.6.1 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63317e087d685718d569e6dde70a5e007d0d988abcac587f55f8f439ca354c87
-  data.tar.gz: 39410717e0a0a8fdcb3fd2a61553846bee7e82b3417a111ac36e1b222ccc782e
+  metadata.gz: 0be6dfe6d1465214b44d17ae4a45482ba364735abb7032fa26e37660845aaba8
+  data.tar.gz: d68f634cac89442c536f8f57713354af640f61dc0cc72561ba0972503c9b2d10
 SHA512:
-  metadata.gz: e3612cb6febfe05864710e56a02b4eb2c899e75fbd1e9f25a4b9bbca4e62114c13846f05fe9c73f92b45ad2e8301baf6d9d5ab7719d576bd9ec13a2026894f9a
-  data.tar.gz: c10673819296c367d1ca7de3c795fd2c212099fc505c6bbe0b6a169f2ca87801afc70dc521d8a5db4a3f53e77c3a476bfef9e4d5f7cdc3fcfae414f9f832a5d2
+  metadata.gz: 7c662434d97dc7d4811f062ef9dfd3c0d6fe1eec8083f27b7f0a0638e35e5ad7ef10a5b322439ed5df5bf45acaa9fff645bf9592cd5a481b9c8a9d753cd022c6
+  data.tar.gz: f96f01c43dfaaa0843645fb737af52408709c27b962231b10781353951c849aa8b83bad85dc4a92fc2b76c5731bca1d01bb5e1998aa2e79799744078b64b8c42

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 3.7.0
+  - Fix: better (Redis) exception handling [#89](https://github.com/logstash-plugins/logstash-input-redis/pull/89)
+  - Test: start running integration specs on CI
+
 ## 3.6.1
   - Fix: resolve crash when commands_map is set [#86](https://github.com/logstash-plugins/logstash-input-redis/pull/86)
 

data/lib/logstash/inputs/redis.rb

@@ -107,26 +107,22 @@ module LogStash module Inputs class Redis < LogStash::Inputs::Threadable
 
   # private
   def redis_params
+    params = {
+        :timeout => @timeout,
+        :db => @db,
+        :password => @password.nil? ? nil : @password.value,
+        :ssl => @ssl
+    }
+
     if @path.nil?
-      connectionParams = {
-        :host => @host,
-        :port => @port
-      }
+      params[:host] = @host
+      params[:port] = @port
     else
       @logger.warn("Parameter 'path' is set, ignoring parameters: 'host' and 'port'")
-      connectionParams = {
-        :path => @path
-      }
+      params[:path] = @path
     end
 
-    baseParams = {
-      :timeout => @timeout,
-      :db => @db,
-      :password => @password.nil? ? nil : @password.value,
-      :ssl => @ssl
-    }
-
-    return connectionParams.merge(baseParams)
+    params
   end
 
   def new_redis_instance
@@ -174,9 +170,12 @@ EOF
 
   # private
   def list_stop
-    return if @redis.nil? || !@redis.connected?
+    redis = @redis # might change during method invocation
+    return if redis.nil? || !redis.connected?
 
-    @redis.quit rescue nil
+    redis.quit rescue nil # does client.disconnect internally
+    # check if input retried while executing
+    list_stop unless redis.equal? @redis
     @redis = nil
   end
 
@@ -186,15 +185,9 @@ EOF
       begin
         @redis ||= connect
         @list_method.call(@redis, output_queue)
-      rescue ::Redis::BaseError => e
-        info = { message: e.message, exception: e.class }
-        info[:backtrace] = e.backtrace if @logger.debug?
-        @logger.warn("Redis connection problem", info)
-        # Reset the redis variable to trigger reconnect
-        @redis = nil
-        # this sleep does not need to be stoppable as its
-        # in a while !stop? loop
-        sleep 1
+      rescue => e
+        log_error(e)
+        retry if reset_for_error_retry(e)
       end
     end
   end
@@ -248,18 +241,19 @@ EOF
 
   # private
   def subscribe_stop
-    return if @redis.nil? || !@redis.connected?
-    # if its a SubscribedClient then:
-    # it does not have a disconnect method (yet)
-    if @redis.subscribed?
+    redis = @redis # might change during method invocation
+    return if redis.nil? || !redis.connected?
+
+    if redis.subscribed?
       if @data_type == 'pattern_channel'
-        @redis.punsubscribe
+        redis.punsubscribe
       else
-        @redis.unsubscribe
+        redis.unsubscribe
       end
-    else
-      @redis.disconnect!
     end
+    redis.close rescue nil # does client.disconnect
+    # check if input retried while executing
+    subscribe_stop unless redis.equal? @redis
     @redis = nil
   end
 
@@ -268,15 +262,43 @@ EOF
     begin
       @redis ||= connect
       yield
-    rescue ::Redis::BaseError => e
-      @logger.warn("Redis connection problem", :exception => e)
-      # Reset the redis variable to trigger reconnect
-      @redis = nil
-      Stud.stoppable_sleep(1) { stop? }
-      retry if !stop?
+    rescue => e
+      log_error(e)
+      retry if reset_for_error_retry(e)
+    end
+  end
+
+  def log_error(e)
+    info = { message: e.message, exception: e.class }
+    info[:backtrace] = e.backtrace if @logger.debug?
+
+    case e
+    when ::Redis::TimeoutError
+      # expected for channels in case no data is available
+      @logger.debug("Redis timeout, retrying", info)
+    when ::Redis::BaseConnectionError, ::Redis::ProtocolError
+      @logger.warn("Redis connection error", info)
+    when ::Redis::BaseError
+      @logger.error("Redis error", info)
+    when ::LogStash::ShutdownSignal
+      @logger.debug("Received shutdown signal")
+    else
+      info[:backtrace] ||= e.backtrace
+      @logger.error("Unexpected error", info)
     end
   end
 
+  # @return [true] if operation is fine to retry
+  def reset_for_error_retry(e)
+    return if e.is_a?(::LogStash::ShutdownSignal)
+
+    # Reset the redis variable to trigger reconnect
+    @redis = nil
+
+    Stud.stoppable_sleep(1) { stop? }
+    !stop? # retry if not stop-ing
+  end
+
   # private
   def channel_runner(output_queue)
     redis_runner do
@@ -324,6 +346,4 @@ EOF
     end
   end
 
-# end
-
 end end end # Redis Inputs  LogStash

data/logstash-input-redis.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-input-redis'
-  s.version         = '3.6.1'
+  s.version         = '3.7.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Reads events from a Redis instance"
   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/inputs/redis_spec.rb

@@ -17,11 +17,15 @@ def populate(key, event_count)
 end
 
 def process(conf, event_count)
-  events = input(conf) do |pipeline, queue|
-    event_count.times.map{queue.pop}
+  events = input(conf) do |_, queue|
+    sleep 0.1 until queue.size >= event_count
+    queue.size.times.map { queue.pop }
   end
-
-  expect(events.map{|evt| evt.get("sequence")}).to eq((0..event_count.pred).to_a)
+  # due multiple workers we get events out-of-order in the output
+  events.sort! { |a, b| a.get('sequence') <=> b.get('sequence') }
+  expect(events[0].get('sequence')).to eq(0)
+  expect(events[100].get('sequence')).to eq(100)
+  expect(events[1000].get('sequence')).to eq(1000)
 end
 
 # integration tests ---------------------
@@ -31,7 +35,6 @@ describe "inputs/redis", :redis => true do
   it "should read events from a list" do
     key = SecureRandom.hex
     event_count = 1000 + rand(50)
-    # event_count = 100
     conf = <<-CONFIG
       input {
         redis {
@@ -163,7 +166,6 @@ describe LogStash::Inputs::Redis do
       allow_any_instance_of( Redis::Client ).to receive(:call_with_timeout) do |_, command, timeout, &block|
         expect(command[0]).to eql :blpop
         expect(command[1]).to eql ['foo', 0]
-        expect(command[2]).to eql 1
       end.and_return ['foo', "{\"foo1\":\"bar\""], nil
 
       tt = Thread.new do
@@ -178,6 +180,69 @@ describe LogStash::Inputs::Redis do
       expect( queue.size ).to be > 0
     end
 
+    it 'keeps running when a connection error occurs' do
+      raised = false
+      allow_any_instance_of( Redis::Client ).to receive(:call_with_timeout) do |_, command, timeout, &block|
+        expect(command[0]).to eql :blpop
+        unless raised
+          raised = true
+          raise Redis::CannotConnectError.new('test')
+        end
+        ['foo', "{\"after\":\"raise\"}"]
+      end
+
+      expect(subject.logger).to receive(:warn).with('Redis connection error',
+                                                    hash_including(:message=>"test", :exception=>Redis::CannotConnectError)
+      ).and_call_original
+
+      tt = Thread.new do
+        sleep 2.0 # allow for retry (sleep) after handle_error
+        subject.do_stop
+      end
+
+      subject.run(queue)
+
+      tt.join
+
+      try(3) { expect( queue.size ).to be > 0 }
+    end
+
+    context 'error handling' do
+
+      let(:config) do
+        super().merge 'batch_count' => 2
+      end
+
+      it 'keeps running when a (non-Redis) io error occurs' do
+        raised = false
+        allow(subject).to receive(:connect).and_return redis = double('redis')
+        allow(redis).to receive(:blpop).and_return nil
+        expect(redis).to receive(:evalsha) do
+          unless raised
+            raised = true
+            raise IOError.new('closed stream')
+          end
+          []
+        end.at_least(1)
+        redis
+        allow(subject).to receive(:stop)
+
+        expect(subject.logger).to receive(:error).with('Unexpected error',
+                                                       hash_including(:message=>'closed stream', :exception=>IOError)
+        ).and_call_original
+
+        tt = Thread.new do
+          sleep 2.0 # allow for retry (sleep) after handle_error
+          subject.do_stop
+        end
+
+        subject.run(queue)
+
+        tt.join
+      end
+
+    end
+
     context "when the batch size is greater than 1" do
       let(:batch_count) { 10 }
 
@@ -233,9 +298,6 @@ describe LogStash::Inputs::Redis do
     end
 
     it 'multiple close calls, calls to redis once' do
-      # subject.use_redis(redis)
-      # allow(redis).to receive(:blpop).and_return(['foo', 'l1'])
-      # expect(redis).to receive(:connected?).and_return(connected.last)
       allow_any_instance_of( Redis::Client ).to receive(:connected?).and_return true, false
       # allow_any_instance_of( Redis::Client ).to receive(:disconnect)
       quit_calls.each do |call|
@@ -249,6 +311,9 @@ describe LogStash::Inputs::Redis do
   end
 
   context 'for the subscribe data_types' do
+
+    before { subject.register }
+
     def run_it_thread(inst)
       Thread.new(inst) do |subj|
         subj.run(queue)
@@ -289,6 +354,8 @@ describe LogStash::Inputs::Redis do
       let(:data_type) { 'channel' }
       let(:quit_calls) { [:unsubscribe, :connection] }
 
+      before { subject.register }
+
       context 'mocked redis' do
         it 'multiple stop calls, calls to redis once', type: :mocked do
           subject.do_stop
@@ -367,6 +434,10 @@ describe LogStash::Inputs::Redis do
 
     ["list", "channel", "pattern_channel"].each do |data_type|
       context data_type do
+        # TODO pending
+        # redis-rb ends up in a read wait loop since we do not use subscribe_with_timeout
+        next unless data_type == 'list'
+
         it_behaves_like "an interruptible input plugin", :redis => true do
           let(:config) { { 'key' => 'foo', 'data_type' => data_type } }
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-redis
 version: !ruby/object:Gem::Version
-  version: 3.6.1
+  version: 3.7.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-07 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement