logstash-output-http 5.2.2 → 5.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd00218e30610f309f7870230ffeff01b5d1481b38d8723cb2e938f2067a561b
-  data.tar.gz: 6c31789a86e548649b8ae995cab4e5927fe071d4491570d98c3ef454c28649fd
+  metadata.gz: 4296b53881ec5d3e420667e9aa554a25781397858a38cbbd9a1d41b6ff49f91b
+  data.tar.gz: 07c7e8e0b029d23c18855f86147bef1848f6eac1625afe86344e7d24b6dc4a6f
 SHA512:
-  metadata.gz: 0ed20344862d2b1587d8a3b5cb8bb6b71de3c51ac75a91c85f5f1326185438f899ff08573de4613394c0fbae252c572e8c4996f05497e9cf081fc92c227182c1
-  data.tar.gz: 11248626b51ec811d865f761e01a7adf219b9967211c20abd71c901ff16d0e551201c7d931d209f19cf40fa6d7dad164e4dbe06f2c13ee2bfa7549bb8a16b1b3
+  metadata.gz: cccd68833da4cb41c5699541a7c67065e4b6c0d476f1076dbf59f103912050689756a20bb3d4b53468a08bf84e2c088a3fdf5586c5f19b6032504d3ba3cc698d
+  data.tar.gz: bcc121d030f1f2bcaa5de4f7a498610338b35a8df01d2262a7d28cc46472780896d56551aa058cfec5dbd8f12e132bd1ac67321a36c6cb1bb474faaf1b604f34

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 5.2.3
+  - Fixed handling of empty `retryable_codes` [#99](https://github.com/logstash-plugins/logstash-output-http/pull/99)
+
 ## 5.2.2
   - Fix high CPU usage on retries in json_batch mode. [#89](https://github.com/logstash-plugins/logstash-output-http/pull/89)
   - Enable compression in json_batch mode. [#89](https://github.com/logstash-plugins/logstash-output-http/pull/89)

data/lib/logstash/outputs/http.rb

@@ -8,18 +8,18 @@ require "zlib"
 
 class LogStash::Outputs::Http < LogStash::Outputs::Base
   include LogStash::PluginMixins::HttpClient
-  
+
   concurrency :shared
 
   attr_accessor :is_batch
 
   VALID_METHODS = ["put", "post", "patch", "delete", "get", "head"]
-  
+
   RETRYABLE_MANTICORE_EXCEPTIONS = [
     ::Manticore::Timeout,
     ::Manticore::SocketException,
-    ::Manticore::ClientProtocolException, 
-    ::Manticore::ResolutionFailure, 
+    ::Manticore::ClientProtocolException,
+    ::Manticore::ResolutionFailure,
     ::Manticore::SocketTimeout
   ]
 
@@ -53,14 +53,14 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
   # * if format is "json", "application/json"
   # * if format is "form", "application/x-www-form-urlencoded"
   config :content_type, :validate => :string
-  
+
   # Set this to false if you don't want this output to retry failed requests
   config :retry_failed, :validate => :boolean, :default => true
-  
+
   # If encountered as response codes this plugin will retry these requests
   config :retryable_codes, :validate => :number, :list => true, :default => [429, 500, 502, 503, 504]
-  
-  # If you would like to consider some non-2xx codes to be successes 
+
+  # If you would like to consider some non-2xx codes to be successes
   # enumerate them here. Responses returning these codes will be considered successes
   config :ignorable_codes, :validate => :number, :list => true
 
@@ -85,7 +85,7 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
 
   # Set this to true if you want to enable gzip compression for your http requests
   config :http_compression, :validate => :boolean, :default => false
-  
+
   config :message, :validate => :string
 
   def register
@@ -114,7 +114,7 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
     @headers["Content-Type"] = @content_type
 
     validate_format!
-    
+
     # Run named Timer as daemon thread
     @timer = java.util.Timer.new("HTTP Output #{self.params['id']}", true)
   end # def register
@@ -123,7 +123,7 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
     return if events.empty?
     send_events(events)
   end
-  
+
   class RetryTimerTask < java.util.TimerTask
     def initialize(pending, event, attempt)
       @pending = pending
@@ -131,7 +131,7 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
       @attempt = attempt
       super()
     end
-    
+
     def run
       @pending << [@event, @attempt]
     end
@@ -153,7 +153,7 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
               :event => event
             )
   end
-  
+
   def send_events(events)
     successes = java.util.concurrent.atomic.AtomicInteger.new(0)
     failures  = java.util.concurrent.atomic.AtomicInteger.new(0)
@@ -169,44 +169,43 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
 
     while popped = pending.pop
       break if popped == :done
-      
+
       event, attempt = popped
 
-      send_event(event, attempt) do |action,event,attempt|
-        begin 
-          action = :failure if action == :retry && !@retry_failed
-          
-          case action
-          when :success
-            successes.incrementAndGet
-          when :retry
-            retries.incrementAndGet
-            
-            next_attempt = attempt+1
-            sleep_for = sleep_for_attempt(next_attempt)
-            @logger.info("Retrying http request, will sleep for #{sleep_for} seconds")
-            timer_task = RetryTimerTask.new(pending, event, next_attempt)
-            @timer.schedule(timer_task, sleep_for*1000)
-          when :failure 
-            failures.incrementAndGet
-          else
-            raise "Unknown action #{action}"
-          end
-          
-          if action == :success || action == :failure 
-            if successes.get+failures.get == event_count
-              pending << :done
-            end
-          end
-        rescue => e 
-          # This should never happen unless there's a flat out bug in the code
-          @logger.error("Error sending HTTP Request",
-            :class => e.class.name,
-            :message => e.message,
-            :backtrace => e.backtrace)
+      action, event, attempt = send_event(event, attempt)
+      begin
+        action = :failure if action == :retry && !@retry_failed
+
+        case action
+        when :success
+          successes.incrementAndGet
+        when :retry
+          retries.incrementAndGet
+
+          next_attempt = attempt+1
+          sleep_for = sleep_for_attempt(next_attempt)
+          @logger.info("Retrying http request, will sleep for #{sleep_for} seconds")
+          timer_task = RetryTimerTask.new(pending, event, next_attempt)
+          @timer.schedule(timer_task, sleep_for*1000)
+        when :failure
           failures.incrementAndGet
-          raise e
+        else
+          raise "Unknown action #{action}"
         end
+
+        if action == :success || action == :failure
+          if successes.get+failures.get == event_count
+            pending << :done
+          end
+        end
+      rescue => e
+        # This should never happen unless there's a flat out bug in the code
+        @logger.error("Error sending HTTP Request",
+          :class => e.class.name,
+          :message => e.message,
+          :backtrace => e.backtrace)
+        failures.incrementAndGet
+        raise e
       end
     end
   rescue => e
@@ -216,13 +215,13 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
             :backtrace => e.backtrace)
     raise e
   end
-  
+
   def sleep_for_attempt(attempt)
     sleep_for = attempt**2
     sleep_for = sleep_for <= 60 ? sleep_for : 60
     (sleep_for/2) + (rand(0..sleep_for)/2)
   end
-  
+
   def send_event(event, attempt)
     body = event_body(event)
 
@@ -237,62 +236,38 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
     end
 
     # Create an async request
-    request = client.background.send(@http_method, url, :body => body, :headers => headers)
-
-    request.on_success do |response|
-      begin
-        if !response_success?(response)
-          if retryable_response?(response)
-            log_retryable_response(response)
-            yield :retry, event, attempt
-          else
-            log_error_response(response, url, event)
-            yield :failure, event, attempt
-          end
-        else
-          yield :success, event, attempt
-        end
-      rescue => e 
-        # Shouldn't ever happen
-        @logger.error("Unexpected error in request success!",
-          :class => e.class.name,
-          :message => e.message,
-          :backtrace => e.backtrace)
+    response = client.send(@http_method, url, :body => body, :headers => headers).call
+
+    if !response_success?(response)
+      if retryable_response?(response)
+        log_retryable_response(response)
+        return :retry, event, attempt
+      else
+        log_error_response(response, url, event)
+        return :failure, event, attempt
       end
+    else
+      return :success, event, attempt
     end
 
-    request.on_failure do |exception|
-      begin 
-        will_retry = retryable_exception?(exception)
-        log_failure("Could not fetch URL",
-                    :url => url,
-                    :method => @http_method,
-                    :body => body,
-                    :headers => headers,
-                    :message => exception.message,
-                    :class => exception.class.name,
-                    :backtrace => exception.backtrace,
-                    :will_retry => will_retry
-        )
-        
-        if will_retry
-          yield :retry, event, attempt
-        else
-          yield :failure, event, attempt
-        end
-      rescue => e 
-        # Shouldn't ever happen
-        @logger.error("Unexpected error in request failure!",
-          :class => e.class.name,
-          :message => e.message,
-          :backtrace => e.backtrace)
-        end
+  rescue => exception
+    will_retry = retryable_exception?(exception)
+    log_failure("Could not fetch URL",
+                :url => url,
+                :method => @http_method,
+                :body => body,
+                :headers => headers,
+                :message => exception.message,
+                :class => exception.class.name,
+                :backtrace => exception.backtrace,
+                :will_retry => will_retry
+    )
+
+    if will_retry
+      return :retry, event, attempt
+    else
+      return :failure, event, attempt
     end
-
-    # Actually invoke the request in the background
-    # Note: this must only be invoked after all handlers are defined, otherwise
-    # those handlers are not guaranteed to be called!
-    request.call 
   end
 
   def close
@@ -301,17 +276,17 @@ class LogStash::Outputs::Http < LogStash::Outputs::Base
   end
 
   private
-  
+
   def response_success?(response)
     code = response.code
     return true if @ignorable_codes && @ignorable_codes.include?(code)
     return code >= 200 && code <= 299
   end
-  
+
   def retryable_response?(response)
-    @retryable_codes.include?(response.code)
+    @retryable_codes && @retryable_codes.include?(response.code)
   end
-  
+
   def retryable_exception?(exception)
     RETRYABLE_MANTICORE_EXCEPTIONS.any? {|me| exception.is_a?(me) }
   end

data/logstash-output-http.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-output-http'
-  s.version         = '5.2.2'
+  s.version         = '5.2.3'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Sends events to a generic HTTP or HTTPS endpoint"
   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/outputs/http_spec.rb

@@ -117,12 +117,10 @@ describe LogStash::Outputs::Http do
 
     let(:expected_method) { method.clone.to_sym }
     let(:client) { subject.client }
-    let(:client_proxy) { subject.client.background }
 
     before do
-      allow(client).to receive(:background).and_return(client_proxy)
       subject.register
-      allow(client_proxy).to receive(:send).
+      allow(client).to receive(:send).
                          with(expected_method, url, anything).
                          and_call_original
       allow(subject).to receive(:log_failure).with(any_args)
@@ -142,7 +140,7 @@ describe LogStash::Outputs::Http do
         end
 
         it "should execute the request" do
-          expect(client_proxy).to have_received(:send).
+          expect(client).to have_received(:send).
                               with(expected_method, url, anything)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-http
 version: !ruby/object:Gem::Version
-  version: 5.2.2
+  version: 5.2.3
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-07-06 00:00:00.000000000 Z
+date: 2018-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement