logstash-core 5.3.3-java → 5.4.0-java

data/spec/logstash/settings/port_range_spec.rb

@@ -56,7 +56,7 @@ describe LogStash::Setting::PortRange do
     end
   end
 
-  context "when the value is an unkown type" do
+  context "when the value is an unknown type" do
     subject { LogStash::Setting::PortRange.new("mynewtest", 0.1) }
 
 

data/spec/logstash/settings_spec.rb

@@ -87,6 +87,27 @@ describe LogStash::Settings do
       end
     end
   end
+  
+  describe "post_process" do
+    subject(:settings) { described_class.new }
+    
+    before do
+      settings.on_post_process do
+        settings.set("baz", "bot")
+      end
+      settings.register(LogStash::Setting::String.new("foo", "bar"))
+      settings.register(LogStash::Setting::String.new("baz", "somedefault"))
+      settings.post_process
+    end
+    
+    it "should run the post process callbacks" do
+      expect(settings.get("baz")).to eq("bot")
+    end
+    
+    it "should preserve original settings" do
+      expect(settings.get("foo")).to eq("bar")
+    end
+  end
 
   context "transient settings" do
     subject do

data/spec/logstash/timestamp_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "logstash/timestamp"
+
+describe LogStash::Timestamp do
+  context "constructors" do
+    it "should work" do
+      t = LogStash::Timestamp.new
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
+
+      t = LogStash::Timestamp.now
+      expect(t.time.to_i).to be_within(1).of Time.now.to_i
+
+      now = Time.now.utc
+      t = LogStash::Timestamp.new(now)
+      expect(t.time).to eq(now)
+
+      t = LogStash::Timestamp.at(now.to_i)
+      expect(t.time.to_i).to eq(now.to_i)
+    end
+
+    it "should raise exception on invalid format" do
+      expect{LogStash::Timestamp.new("foobar")}.to raise_error
+    end
+
+  end
+
+end

data/spec/logstash/util/accessors_spec.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+require "spec_helper"
+
+# this is to skip specs when running agains an alternate logstash-core-event implementation
+# that does not define the Accessors class. For example, in logstash-core-event-java
+# the Accessors class does not exists in the Ruby namespace.
+class_exists = begin
+  require "logstash/util/accessors"
+  true
+rescue LoadError
+  false
+end
+
+describe "LogStash::Util::Accessors", :if => class_exists do
+
+  context "using simple field" do
+
+    it "should get value of word key" do
+      str = "hello"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of key with spaces" do
+      str = "hel lo"
+      data = { "hel lo" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should get value of numeric key string" do
+      str = "1"
+      data = { "1" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data[str])
+    end
+
+    it "should handle delete" do
+      str = "simple"
+      data = { "simple" => "things" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("things")
+      expect(data).to be_empty
+    end
+
+    it "should handle delete on non-existent field" do
+      str = "[foo][bar]"
+      data = { "hello" => "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to be_nil
+      expect(data).not_to be_empty
+      # assert no side effects
+      expect(accessors.get("foo")).to be_nil
+      expect(accessors.get("hello")).to eq("world")
+    end
+
+    it "should set string value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "things")).to eq("things")
+      expect(data).to eq({ "simple" => "things" })
+    end
+
+    it "should set array value" do
+      str = "simple"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "simple" => ["foo", "bar"]})
+    end
+  end
+
+  context "using field path" do
+
+    it "should get shallow string value of word key" do
+      str = "[hello]"
+      data = { "hello" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of key with spaces" do
+      str = "[hel lo]"
+      data = { "hel lo" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get shallow string value of numeric key string" do
+      str = "[1]"
+      data = { "1" =>  "world" }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq("world")
+    end
+
+    it "should get deep string value" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to eq(data["hello"]["world"])
+    end
+
+    it "should return nil when getting a non-existant field (with no side-effects on original data)" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get(str)).to be_nil
+      expect(data).to  be_empty
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => {"world" => "foo"} })
+    end
+
+    it "should handle delete" do
+      str = "[hello][world]"
+      data = { "hello" => { "world" => "foo", "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq("foo")
+
+      # Make sure the "world" key is removed.
+      expect(data["hello"]).to eq({ "bar" => "baz" })
+    end
+
+    it "should set shallow string value" do
+      str = "[hello]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => "foo" })
+    end
+
+    it "should set deep string value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "foo")).to eq("foo")
+      expect(data).to eq({ "hello" => { "world" => "foo" } })
+    end
+
+    it "should set deep array value" do
+      str = "[hello][world]"
+      data = {}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, ["foo", "bar"])).to eq(["foo", "bar"])
+      expect(data).to eq({ "hello" => { "world" => ["foo", "bar"] } })
+    end
+
+    it "should set element within array value" do
+      str = "[hello][0]"
+      data = {"hello" => ["foo", "bar"]}
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.set(str, "world") ).to eq("world")
+      expect(data).to eq({"hello" => ["world", "bar"]})
+    end
+
+    it "should retrieve array item" do
+      data = { "hello" => { "world" => ["a", "b"], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0]")).to eq(data["hello"]["world"][0])
+      expect(accessors.get("[hello][world][1]")).to eq(data["hello"]["world"][1])
+    end
+
+    it "should retrieve array item containing hash" do
+      data = { "hello" => { "world" => [ { "a" => 123 }, { "b" => 345 } ], "bar" => "baz" } }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.get("[hello][world][0][a]")).to eq(data["hello"]["world"][0]["a"])
+      expect(accessors.get("[hello][world][1][b]")).to eq(data["hello"]["world"][1]["b"])
+    end
+
+    it "should handle delete of array element" do
+      str = "[geocoords][0]"
+      data = { "geocoords" => [4, 2] }
+      accessors = LogStash::Util::Accessors.new(data)
+      expect(accessors.del(str)).to eq(4)
+      expect(data).to eq({ "geocoords" => [2] })
+    end
+  end
+end

data/spec/logstash/util/wrapped_synchronous_queue_spec.rb

@@ -60,13 +60,10 @@ describe LogStash::Util::WrappedSynchronousQueue do
 
         context "when the queue is empty" do
           it "doesnt record the `duration_in_millis`" do
-            batch = read_client.take_batch
+            batch = read_client.read_batch
             read_client.close_batch(batch)
             store = collector.snapshot_metric.metric_store
 
-            expect(store.get_shallow(:events, :in).value).to eq(0)
-            expect(store.get_shallow(:events, :in)).to be_kind_of(LogStash::Instrument::MetricType::Counter)
-
             expect(store.get_shallow(:events, :out).value).to eq(0)
             expect(store.get_shallow(:events, :out)).to be_kind_of(LogStash::Instrument::MetricType::Counter)
 
@@ -76,9 +73,6 @@ describe LogStash::Util::WrappedSynchronousQueue do
             expect(store.get_shallow(:events, :duration_in_millis).value).to eq(0)
             expect(store.get_shallow(:events, :duration_in_millis)).to be_kind_of(LogStash::Instrument::MetricType::Counter)
 
-            expect(store.get_shallow(:pipeline, :in).value).to eq(0)
-            expect(store.get_shallow(:pipeline, :in)).to be_kind_of(LogStash::Instrument::MetricType::Counter)
-
             expect(store.get_shallow(:pipeline, :duration_in_millis).value).to eq(0)
             expect(store.get_shallow(:pipeline, :duration_in_millis)).to be_kind_of(LogStash::Instrument::MetricType::Counter)
 
@@ -95,7 +89,8 @@ describe LogStash::Util::WrappedSynchronousQueue do
             batch = write_client.get_new_batch
             5.times {|i| batch.push("value-#{i}")}
             write_client.push_batch(batch)
-            read_batch = read_client.take_batch
+
+            read_batch = read_client.read_batch
             sleep(0.1) # simulate some work for the `duration_in_millis`
             # TODO: this interaction should be cleaned in an upcoming PR,
             # This is what the current pipeline does.
@@ -104,11 +99,9 @@ describe LogStash::Util::WrappedSynchronousQueue do
             read_client.close_batch(read_batch)
             store = collector.snapshot_metric.metric_store
 
-            expect(store.get_shallow(:events, :in).value).to eq(5)
             expect(store.get_shallow(:events, :out).value).to eq(5)
             expect(store.get_shallow(:events, :filtered).value).to eq(5)
             expect(store.get_shallow(:events, :duration_in_millis).value).to be > 0
-            expect(store.get_shallow(:pipeline, :in).value).to eq(5)
             expect(store.get_shallow(:pipeline, :duration_in_millis).value).to be > 0
             expect(store.get_shallow(:pipeline, :out).value).to eq(5)
             expect(store.get_shallow(:pipeline, :filtered).value).to eq(5)
@@ -126,7 +119,7 @@ describe LogStash::Util::WrappedSynchronousQueue do
           batch = write_client.get_new_batch
           5.times {|i| batch.push(LogStash::Event.new({"message" => "value-#{i}"}))}
           write_client.push_batch(batch)
-          read_batch = read_client.take_batch
+          read_batch = read_client.read_batch
           expect(read_batch.size).to eq(5)
           i = 0
           read_batch.each do |data|

data/spec/logstash/util_spec.rb

@@ -37,7 +37,7 @@ describe LogStash::Util do
       expect(LogStash::Util.stringify_symbols([1, :a])).to eq([1, "a"])
     end
 
-    it "should convert innner array symbol values to strings" do
+    it "should convert inner array symbol values to strings" do
       expect(LogStash::Util.stringify_symbols({:a => [1, :b]})).to eq({"a" => [1, "b"]})
       expect(LogStash::Util.stringify_symbols([:a, [1, :b]])).to eq(["a", [1, "b"]])
     end

data/spec/logstash/webserver_spec.rb

@@ -139,7 +139,7 @@ describe LogStash::IOWrappedLogger do
     expect(logger).to have_received(:debug).with(message)
   end
 
-  it "reponds to <<" do
+  it "responds to <<" do
     subject << message
     expect(logger).to have_received(:debug).with(message)
   end

data/spec/support/mocks_classes.rb

@@ -1,79 +1,91 @@
 # encoding: utf-8
 require "logstash/outputs/base"
+require "logstash/inputs/base"
 require "thread"
 
-module LogStash module Outputs
-  class DummyOutput < LogStash::Outputs::Base
-    config_name "dummyoutput"
-    milestone 2
+module LogStash
+  module Inputs
+    class DummyInput < LogStash::Inputs::Base
+      config_name "dummyinput"
 
-    attr_reader :num_closes, :events
-
-    def initialize(params={})
-      super
-      @num_closes = 0
-      @events = []
+      def run(queue)
+        # noop
+      end
     end
+  end
+  module Outputs
+    class DummyOutput < LogStash::Outputs::Base
+      config_name "dummyoutput"
+      milestone 2
 
-    def register
-    end
+      attr_reader :num_closes, :events
 
-    def receive(event)
-      @events << event
-    end
+      def initialize(params={})
+        super
+        @num_closes = 0
+        @events = []
+      end
 
-    def close
-      @num_closes += 1
+      def register
+      end
+
+      def receive(event)
+        @events << event
+      end
+
+      def close
+        @num_closes += 1
+      end
     end
-  end
 
-  class DummyOutputWithEventsArray < LogStash::Outputs::Base
-    config_name "dummyoutput2"
-    milestone 2
+    class DummyOutputWithEventsArray < LogStash::Outputs::Base
+      config_name "dummyoutput2"
+      milestone 2
 
-    attr_reader :events
+      attr_reader :events
 
-    def initialize(params={})
-      super
-      @events = []
-    end
+      def initialize(params={})
+        super
+        @events = []
+      end
 
-    def register
-    end
+      def register
+      end
 
-    def receive(event)
-      @events << event
-    end
+      def receive(event)
+        @events << event
+      end
 
-    def close
+      def close
+      end
     end
-  end
 
-  class DroppingDummyOutput < LogStash::Outputs::Base
-    config_name "droppingdummyoutput"
-    milestone 2
+    class DroppingDummyOutput < LogStash::Outputs::Base
+      config_name "droppingdummyoutput"
+      milestone 2
 
-    attr_reader :num_closes
+      attr_reader :num_closes
 
-    def initialize(params={})
-      super
-      @num_closes = 0
-      @events_received = Concurrent::AtomicFixnum.new(0)
-    end
+      def initialize(params={})
+        super
+        @num_closes = 0
+        @events_received = Concurrent::AtomicFixnum.new(0)
+      end
 
-    def register
-    end
+      def register
+      end
 
-    def receive(event)
-      @events_received.increment
-    end
+      def receive(event)
+        @events_received.increment
+      end
 
-    def events_received
-      @events_received.value
-    end
+      def events_received
+        @events_received.value
+      end
 
-    def close
-      @num_closes = 1
+      def close
+        @num_closes = 1
+      end
     end
   end
-end end
+end