logstash-input-snmp 1.2.7 → 1.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 755490661919181ec1b348c1b2bade1300a1829be66206b52c203a230c7a00fd
-  data.tar.gz: b05f137f91e3720ec567f620358c230b8ffe88f96c83d5158a9d05975b3e8ea6
+  metadata.gz: 4bcb5f73151249317b6f7b36c028a3f863e7d4a88ba6da977fbc88d255355364
+  data.tar.gz: 85ef765af5f93aefb92a8f40d9738101ada3b5173bb9b4b8de3d4ec21a406578
 SHA512:
-  metadata.gz: a3af3dba5c77fa3b6bec973a23eb8e3e0f8260287a6aa974d4cde6dd323193086d9767b2725600fc6e9776445e65bcb09e4e85883ffde331fe9e403eeba68edd
-  data.tar.gz: dfe8509aa8619a38616aeb23f534097f19ce06dd14f2c7d1bcb6874fcbdb14bf01fef88148b4cd06b20ed1fd766a03e81735cc96694ca6e28106ad4be649e0ab
+  metadata.gz: 423f10e23a58b04a72c47d70beb06053dedc8d07e1ec1e36c835ca783c6791bb6ccd12d701d3e50bd4ebe173185a4240ae21a93c36d7ecdf38bf4e2ae6d58f25
+  data.tar.gz: f452759e6c453d088b002721ae1520b1c22291e16ff609d8f308e57c3e9aa9dc29b008c809a9a6a76e76b00e68c0399fc96b63f23dc066aa403a682f19712f2e

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 1.2.8
+  - Fixed interval handling to only sleep off the _remainder_ of the interval (if any), and to log a helpful warning when crawling the hosts takes longer than the configured interval [#61](https://github.com/logstash-plugins/logstash-input-snmp/issues/61)
+
 ## 1.2.7
   - Added integration tests to ensure SNMP server and IPv6 connections [#87](https://github.com/logstash-plugins/logstash-input-snmp/pull/87)
 

data/docs/index.asciidoc

@@ -163,6 +163,7 @@ input {
 ===== `interval` 
 
 The `interval` option specifies the polling interval in seconds.
+If polling all configured hosts takes longer than this interval, a warning will be emitted to the logs.
 
 * Value type is <<number,number>>
 * Default value is `30`

data/lib/logstash/inputs/snmp.rb

@@ -161,9 +161,9 @@ class LogStash::Inputs::Snmp < LogStash::Inputs::Base
   end
 
   def run(queue)
-    # for now a naive single threaded poller which sleeps for the given interval between
+    # for now a naive single threaded poller which sleeps off the remaining interval between
     # each run. each run polls all the defined hosts for the get and walk options.
-    while !stop?
+    stoppable_interval_runner.every(@interval, "polling hosts") do
       @client_definitions.each do |definition|
         result = {}
         if !definition[:get].empty?
@@ -207,11 +207,13 @@ class LogStash::Inputs::Snmp < LogStash::Inputs::Base
           queue << event
         end
       end
-
-      Stud.stoppable_sleep(@interval) { stop? }
     end
   end
 
+  def stoppable_interval_runner
+    StoppableIntervalRunner.new(self)
+  end
+
   def close
     @client_definitions.each do |definition|
       begin
@@ -222,6 +224,9 @@ class LogStash::Inputs::Snmp < LogStash::Inputs::Base
     end
   end
 
+  def stop
+  end
+
   private
 
   OID_REGEX = /^\.?([0-9\.]+)$/
@@ -295,4 +300,45 @@ class LogStash::Inputs::Snmp < LogStash::Inputs::Base
   def validate_strip!
     raise(LogStash::ConfigurationError, "you can not specify both oid_root_skip and oid_path_length") if @oid_root_skip > 0 and @oid_path_length > 0
   end
+
+  ##
+  # The StoppableIntervalRunner is capable of running a block of code at a
+  # repeating interval, while respecting the stop condition of the plugin.
+  class StoppableIntervalRunner
+    ##
+    # @param plugin [#logger,#stop?]
+    def initialize(plugin)
+      @plugin = plugin
+    end
+
+    ##
+    # Runs the provided block repeatedly using the provided interval.
+    # After executing the block, the remainder of the interval if any is slept off
+    # using an interruptible sleep.
+    # If no time remains, a warning is emitted to the logs.
+    #
+    # @param interval_seconds [Integer,Float]
+    # @param desc [String] (default: "operation"): a description to use when logging
+    # @yield
+    def every(interval_seconds, desc="operation", &block)
+      until @plugin.stop?
+        start_time = Time.now
+
+        yield
+
+        duration_seconds = Time.now - start_time
+        if duration_seconds >= interval_seconds
+          @plugin.logger.warn("#{desc} took longer than the configured interval", :interval_seconds => interval_seconds, :duration_seconds => duration_seconds.round(3))
+        else
+          remaining_interval = interval_seconds - duration_seconds
+          sleep(remaining_interval)
+        end
+      end
+    end
+
+    # @api private
+    def sleep(duration)
+      Stud.stoppable_sleep(duration) { @plugin.stop? }
+    end
+  end
 end

data/logstash-input-snmp.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name          = 'logstash-input-snmp'
-  s.version       = '1.2.7'
+  s.version       = '1.2.8'
   s.licenses      = ['Apache-2.0']
   s.summary       = "SNMP input plugin"
   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/integration/it_spec.rb

@@ -44,12 +44,12 @@ describe LogStash::Inputs::Snmp do
   end
 
   describe "against single snmp server with snmpv2 and udp", :integration => true do
-    let(:config) { super.merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}]})}
+    let(:config) { super().merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}]})}
     it_behaves_like "snmp plugin return single event"
   end
 
   describe "against single server with snmpv3 and tcp", :integration => true do
-    let(:config) { super.merge({
+    let(:config) { super().merge({
        "hosts" => [{"host" => "tcp:snmp1/161", "version" => "3"}],
        "security_name" => "user_1",
        "auth_protocol" => "sha",
@@ -63,7 +63,7 @@ describe LogStash::Inputs::Snmp do
   end
 
   describe "invalid user against snmpv3 server", :integration => true do
-    let(:config) { super.merge({
+    let(:config) { super().merge({
                                    "hosts" => [{"host" => "tcp:snmp1/161", "version" => "3"}],
                                    "security_name" => "user_2",
                                    "auth_protocol" => "sha",
@@ -84,7 +84,7 @@ describe LogStash::Inputs::Snmp do
   end
 
   describe "single input plugin on single server with snmpv2 and mix of udp and tcp", :integration => true do
-    let(:config) { super.merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}, {"host" => "tcp:snmp1/161", "community" => "public"}]})}
+    let(:config) { super().merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}, {"host" => "tcp:snmp1/161", "community" => "public"}]})}
     it "should return two events " do
       plugin.register
       queue = []
@@ -99,7 +99,7 @@ describe LogStash::Inputs::Snmp do
   end
 
   describe "single input plugin on multiple udp hosts", :integration => true do
-    let(:config) { super.merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}, {"host" => "udp:snmp2/162", "community" => "public"}]})}
+    let(:config) { super().merge({"hosts" => [{"host" => "udp:snmp1/161", "community" => "public"}, {"host" => "udp:snmp2/162", "community" => "public"}]})}
     it "should return two events, one per host" do
       plugin.register
       queue = []
@@ -189,7 +189,7 @@ describe LogStash::Inputs::Snmp do
   end
 
   describe "single host with tcp over ipv6", :integration => true do
-    let(:config) { super.merge({"hosts" => [{"host" => "tcp:[2001:3984:3989::161]/161"}]})}
+    let(:config) { super().merge({"hosts" => [{"host" => "tcp:[2001:3984:3989::161]/161"}]})}
     it_behaves_like "snmp plugin return single event"
   end
 

data/spec/inputs/snmp_spec.rb

@@ -171,5 +171,95 @@ describe LogStash::Inputs::Snmp do
       expect(event.get("host")).to eq("udp:127.0.0.1/161,public")
     end
   end
+
+  context "StoppableIntervalRunner" do
+    let(:stop_holder) { Struct.new(:value).new(false) }
+
+    before(:each) do
+      allow(plugin).to receive(:stop?) { stop_holder.value }
+    end
+
+    let(:plugin) do
+      double("Plugin").tap do |dbl|
+        allow(dbl).to receive(:logger).and_return(double("Logger").as_null_object)
+        allow(dbl).to receive(:stop?) { stop_holder.value }
+      end
+    end
+
+    subject(:interval_runner) { LogStash::Inputs::Snmp::StoppableIntervalRunner.new(plugin) }
+
+    context "#every" do
+      context "when the plugin is stopped" do
+        let(:interval_seconds) { 2 }
+        it 'does not yield the block' do
+          stop_holder.value = true
+          expect { |yielder| interval_runner.every(interval_seconds, &yielder) }.to_not yield_control
+        end
+      end
+
+      context "when the yield takes shorter than the interval" do
+        let(:duration_seconds) { 1 }
+        let(:interval_seconds) { 2 }
+
+        it 'sleeps off the remainder' do
+          allow(interval_runner).to receive(:sleep).and_call_original
+
+          interval_runner.every(interval_seconds) do
+            Kernel::sleep(duration_seconds) # non-stoppable
+            stop_holder.value = true # prevent re-runs
+          end
+
+          expect(interval_runner).to have_received(:sleep).with(a_value_within(0.1).of(1))
+        end
+      end
+
+      context "when the yield takes longer than the interval" do
+        let(:duration_seconds) { 2 }
+        let(:interval_seconds) { 1 }
+
+        it 'logs a warning to the plugin' do
+          allow(interval_runner).to receive(:sleep).and_call_original
+
+          interval_runner.every(interval_seconds) do
+            Kernel::sleep(duration_seconds) # non-stoppable
+            stop_holder.value = true # prevent re-runs
+          end
+
+          expect(interval_runner).to_not have_received(:sleep)
+
+          expect(plugin.logger).to have_received(:warn).with(a_string_including("took longer"), a_hash_including(:interval_seconds => interval_seconds, :duration_seconds => a_value_within(0.1).of(duration_seconds)))
+        end
+      end
+
+      it 'runs regularly until the plugin is stopped' do
+        timestamps = []
+
+        thread = Thread.new do
+          interval_runner.every(1) do
+            timestamps << Time.now
+            Kernel::sleep(Random::rand(0.8))
+          end
+        end
+
+        Kernel::sleep(5)
+        expect(thread).to be_alive
+
+        stop_holder.value = true
+        Kernel::sleep(1)
+
+        aggregate_failures do
+          expect(thread).to_not be_alive
+          expect(timestamps.count).to be_within(1).of(5)
+
+          timestamps.each_cons(2) do |previous, current|
+            # ensure each start time is very close to 1s after the previous.
+            expect(current - previous).to be_within(0.05).of(1)
+          end
+
+          thread.kill if thread.alive?
+        end
+      end
+    end
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-input-snmp
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.2.8
 platform: ruby
 authors:
 - Elasticsearch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -416,8 +416,10 @@ files:
 - spec/fixtures/collision.dic
 - spec/inputs/integration/it_spec.rb
 - spec/inputs/snmp/base_client_spec.rb
+- spec/inputs/snmp/interval_runner_spec.rb
 - spec/inputs/snmp/mib_spec.rb
 - spec/inputs/snmp_spec.rb
+- vendor/jar-dependencies/org/snmp4j/snmp4j/2.5.11/snmp4j-2.5.11.jar
 - vendor/jar-dependencies/org/snmp4j/snmp4j/2.8.4/snmp4j-2.8.4.jar
 homepage: http://www.elastic.co/guide/en/logstash/current/index.html
 licenses:
@@ -441,8 +443,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.6.13
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: SNMP input plugin
@@ -451,5 +452,6 @@ test_files:
 - spec/fixtures/collision.dic
 - spec/inputs/integration/it_spec.rb
 - spec/inputs/snmp/base_client_spec.rb
+- spec/inputs/snmp/interval_runner_spec.rb
 - spec/inputs/snmp/mib_spec.rb
 - spec/inputs/snmp_spec.rb