logstash-output-udp 3.0.6 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03da8b46cdf2746435b5822fce43ac3310c990748e316c53e2d0068cf29a682c
-  data.tar.gz: a50dae007a3c6db9c856acd7dd058b73765c21b04180a5ff6bc834000830f6a3
+  metadata.gz: f6d89de043149e0924a181b904dfd2d56766fd52c77ffb7ad623c27c3ee18df4
+  data.tar.gz: 94ad42d0d5b5d9c2bda8714318b3ca79899b8889e1db69e1e2a4c71358059f2d
 SHA512:
-  metadata.gz: 7543ed4c366a4f9dde7916c560de384fb4991f337d4fc534c55690b242df85d10c8b559a7612924dcad746c4d2d770115b2a0b8d45bd10c7c4614e6bc9c23c0c
-  data.tar.gz: 840f950c945e73a96de90afa3fd25f3b8e2b2df3ac204b576bbb1b2ab7458e2ddd264b3b815b968ff1724ec170461763d58362c3f86766984553a3b59dacb792
+  metadata.gz: ead3de8b14b596c8cac1330ca63737232fb8d8ce5e2564f5aed6cedb54e811662dae7ba2a2a36680ba6aba9d11aa1ce6f14e1e35888076d01907de6976fb5e2d
+  data.tar.gz: 71d2903845ceed02477768fe9eea5ca8c27a0875ba064b96a2d396331c726d1bbaa0aca88d64ed9df77b70a7ab30b0523ceaf67a648436f87449a33ba4b9cf26

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 3.1.0
+ - Fixed plugin crash upon socket write exception [#10](https://github.com/logstash-plugins/logstash-output-udp/pull/10)
+ - Added support for the 'retry_count' and 'retry_backoff_ms' options [#12](https://github.com/logstash-plugins/logstash-output-udp/pull/12)
+
 ## 3.0.6
   - Docs: Set the default_codec doc attribute.
 

data/docs/index.asciidoc

@@ -23,7 +23,14 @@ include::{include_path}/plugin_header.asciidoc[]
 
 Send events over UDP
 
-Keep in mind that UDP will lose messages.
+Keep in mind that UDP does not provide delivery or duplicate protection guarantees.
+Even when this plugin succeeds at writing to the UDP socket, there is no guarantee that
+the recipient will receive exactly one copy of the event.
+
+When this plugin fails to write to the UDP socket, by default the event will be dropped
+and the error message will be logged. The <<plugins-{type}s-{plugin}-retry_count>> option
+in conjunction with the <<plugins-{type}s-{plugin}-retry_backoff_ms>> option can be used
+to retry a failed write for a number of times before dropping the event.
 
 [id="plugins-{type}s-{plugin}-options"]
 ==== Udp Output Configuration Options
@@ -35,6 +42,8 @@ This plugin supports the following configuration options plus the <<plugins-{typ
 |Setting |Input type|Required
 | <<plugins-{type}s-{plugin}-host>> |<<string,string>>|Yes
 | <<plugins-{type}s-{plugin}-port>> |<<number,number>>|Yes
+| <<plugins-{type}s-{plugin}-retry_count>> |<<number,number>>|No
+| <<plugins-{type}s-{plugin}-retry_backoff_ms>> |<<number,number>>|No
 |=======================================================================
 
 Also see <<plugins-{type}s-{plugin}-common-options>> for a list of options supported by all
@@ -60,7 +69,21 @@ The address to send messages to
 
 The port to send messages on
 
+[id="plugins-{type}s-{plugin}-retry_count"]
+===== `retry_count`
+
+* Value type is <<number,number>>
+* Default value is `0`
+
+The number of times to retry a failed UPD socket write
+
+[id="plugins-{type}s-{plugin}-retry_backoff_ms"]
+===== `retry_backoff_ms`
+
+* Value type is <<number,number>>
+* Default value is `10`
 
+The amount of time to wait in milliseconds before attempting to retry a failed UPD socket write
 
 [id="plugins-{type}s-{plugin}-common-options"]
 include::{include_path}/{type}.asciidoc[]

data/lib/logstash/outputs/udp.rb

@@ -5,7 +5,7 @@ require "socket"
 
 # Send events over UDP
 #
-# Keep in mind that UDP will lose messages.
+# Keep in mind that UDP is a lossy protocol
 class LogStash::Outputs::UDP < LogStash::Outputs::Base
   config_name "udp"
   
@@ -17,18 +17,58 @@ class LogStash::Outputs::UDP < LogStash::Outputs::Base
   # The port to send messages on
   config :port, :validate => :number, :required => true
 
-  public
+  # The number of times to retry a failed UPD socket write
+  config :retry_count, :validate => :number, :default => 0
+
+  # The amount of time to wait in milliseconds before attempting to retry a failed UPD socket write
+  config :retry_backoff_ms, :validate => :number, :default => 100
+
   def register
     @socket = UDPSocket.new
+
     @codec.on_event do |event, payload|
-      @socket.send(payload, 0, @host, @port)
+      socket_send(payload)
     end
   end
 
   def receive(event)
-    
-    return if event == LogStash::SHUTDOWN
     @codec.encode(event)
   end
 
-end # class LogStash::Outputs::Stdout
+  private
+
+  def socket_send(payload)
+    send_count = 0
+    begin
+      send_count += 1
+      @socket.send(payload, 0, @host, @port)
+    rescue Errno::EMSGSIZE => e
+      logger.error("Failed to send event, message size of #{payload.size} too long", error_hash(e, payload))
+    rescue => e
+      if @retry_count > 0 && send_count <= @retry_count
+        logger.warn("Failed to send event, retrying:", error_hash(e, payload))
+        sleep(@retry_backoff_ms / 1000.0)
+        retry
+      else
+        logger.error("Failed to send event:", error_hash(e, payload))
+      end
+    end
+  end
+
+  MAX_DEBUG_PAYLOAD = 1000
+
+  def error_hash(error, payload)
+    error_hash = {
+      :error => error.inspect,
+      :backtrace => error.backtrace.first(10)
+    }
+    if logger.debug?
+      error_hash.merge(
+        :event_payload =>
+        payload.length > MAX_DEBUG_PAYLOAD ? "#{payload[0...MAX_DEBUG_PAYLOAD]}...<TRUNCATED>" : payload
+      )
+    else
+      error_hash
+    end
+  end
+end

data/logstash-output-udp.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-udp'
-  s.version         = '3.0.6'
+  s.version         = '3.1.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Sends events over UDP"
   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/udp_spec.rb

@@ -3,18 +3,17 @@ require_relative "../spec_helper"
 
 describe LogStash::Outputs::UDP do
 
+  subject { described_class.new(config) }
   let(:host) { "localhost" }
   let(:port) { rand(1024..65535) }
+  let(:config) {{ "host" => host, "port" => port}}
 
   it "should register without errors" do
-    plugin = LogStash::Plugin.lookup("output", "udp").new({ "host" => host, "port" => port})
+    plugin = LogStash::Plugin.lookup("output", "udp").new(config)
     expect { plugin.register }.to_not raise_error
   end
 
   describe "#send" do
-
-    subject { LogStash::Outputs::UDP.new({"host" => host, "port" => port}) }
-
     let(:properties) { { "message" => "This is a message!"} }
     let(:event)      { LogStash::Event.new(properties) }
 
@@ -24,7 +23,71 @@ describe LogStash::Outputs::UDP do
 
     it "should receive the generated event" do
       expect(subject.instance_variable_get("@socket")).to receive(:send).with(kind_of(String), 0, host, port)
+      expect(subject.instance_variable_get("@logger")).not_to receive(:error)
+      subject.receive(event)
+    end
+  end
+
+  describe "retries" do
+    let(:event) { LogStash::Event.new("message" => "test") }
+    let(:config) {{ "host" => host, "port" => port}}
+
+    before(:each) do
+      subject.register
+    end
+
+    context "not using :retry_count" do
+      it "should not retry upon send exception by default" do
+        allow(subject.instance_variable_get("@socket")).to receive(:send).once.and_raise(IOError)
+        expect(subject.instance_variable_get("@logger")).to receive(:error).once
+        subject.receive(event)
+      end
+    end
+
+    context "using :retry_count" do
+      let(:backoff) { 10 }
+      let(:retry_count) { 5 }
+      let(:config) {{ "host" => host, "port" => port, "retry_count" => retry_count, "retry_backoff_ms" => backoff}}
+
+      it "should retry upon send exception" do
+        allow(subject.instance_variable_get("@socket")).to receive(:send).exactly(retry_count + 1).times.and_raise(IOError)
+        expect(subject.instance_variable_get("@logger")).to receive(:warn).exactly(retry_count).times
+        expect(subject.instance_variable_get("@logger")).to receive(:error).once
+        expect(subject).to receive(:sleep).with(backoff / 1000.0).exactly(retry_count).times
+        subject.receive(event)
+      end
+    end
+  end
+
+  describe "large message" do
+    let(:properties) { { "message" => "0" * 65_536 } }
+    let(:event)      { LogStash::Event.new(properties) }
+
+    before(:each) do
+      subject.register
+    end
+
+    it "should handle the error and log when an error is received" do
+      expect(subject.instance_variable_get("@logger")).to receive(:error)
       subject.receive(event)
     end
+
+    it "should log a truncated payload with debug logging when an error is received and the message is too long" do
+      expect(subject.instance_variable_get("@logger")).to receive(:debug?).and_return(true)
+      expect(subject.instance_variable_get("@logger")).to receive(:error) do |_, hash|
+        expect(hash).to include(:event_payload)
+        expect(hash[:event_payload]).to include("TRUNCATED")
+      end
+      subject.receive(event)
+    end
+
+    it "should not log a payload with debug logging when an error is received" do
+      expect(subject.instance_variable_get("@logger")).to receive(:debug?).and_return(false)
+      expect(subject.instance_variable_get("@logger")).to receive(:error) do |_, hash|
+        expect(hash).not_to include(:event_payload)
+      end
+      subject.receive(event)
+    end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-udp
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.1.0
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-04-06 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key:
 specification_version: 4
 summary: Sends events over UDP