logstash-core 6.0.1-java → 6.1.0-java

data/spec/logstash/api/modules/node_spec.rb

@@ -46,6 +46,17 @@ describe LogStash::Api::Modules::Node do
       end
     end
 
+    context "broken params in URL" do
+
+      before(:all) do
+        get "/hot_threads?human=?threads=5"
+      end
+
+      it "should return http status 400" do
+        expect(last_response.status).to eq(400)
+      end
+    end
+
     context "when asking for human output" do
       [
         "/hot_threads?human",

data/spec/logstash/compiler/compiler_spec.rb

@@ -47,7 +47,7 @@ describe LogStash::Compiler do
         end
       end
 
-      subject(:pipeline) { described_class.compile_sources(sources_with_metadata, settings) }
+      subject(:pipeline) { described_class.compile_sources(sources_with_metadata, false) }
 
       it "should generate a hash" do
         expect(pipeline.unique_hash).to be_a(String)
@@ -100,7 +100,7 @@ describe LogStash::Compiler do
   describe "compiling imperative" do
     let(:source_id) { "fake_sourcefile" }
     let(:source_with_metadata) { org.logstash.common.SourceWithMetadata.new(source_protocol, source_id, 0, 0, source) }
-    subject(:compiled) { described_class.compile_imperative(source_with_metadata, settings) }
+    subject(:compiled) { described_class.compile_imperative(source_with_metadata, settings.get_value("config.support_escapes")) }
 
     context "when config.support_escapes" do
       let(:parser) { LogStashCompilerLSCLGrammarParser.new }
@@ -194,6 +194,32 @@ describe LogStash::Compiler do
         end
       end
 
+      describe "a plugin with multiple array parameter types" do
+        let(:plugin_source) { "generator { aarg => [1] aarg => [2] aarg => [3]}" }
+        let(:expected_plugin_args) do
+          {
+              "aarg" => [1, 2, 3]
+          }
+        end
+
+        it "should contain the plugin" do
+          expect(c_plugin).to ir_eql(j.iPlugin(INPUT, "generator", expected_plugin_args))
+        end
+      end
+
+      describe "a plugin with multiple parameter types that converge to an array" do
+        let(:plugin_source) { "generator { aarg => [1] aarg => 2 aarg => '3' aarg => [4] }"}
+        let(:expected_plugin_args) do
+          {
+              "aarg" => [1, 2, "3", 4]
+          }
+        end
+
+        it "should contain the plugin" do
+          expect(c_plugin).to ir_eql(j.iPlugin(INPUT, "generator", expected_plugin_args))
+        end
+      end
+
       describe "a filter plugin that repeats a Hash directive" do
         let(:source) { "input { } filter { #{plugin_source} } output { } " }
         subject(:c_plugin) { compiled[:filter] }

data/spec/logstash/environment_spec.rb

@@ -10,11 +10,6 @@ describe LogStash::Environment do
     let(:default_runtime_location) { File.join(default_jars_location,"runtime-jars","*.jar") }
     let(:default_test_location)    { File.join(default_jars_location,"test-jars","*.jar") }
 
-    it "raises an exception if jruby is not available" do
-      expect(subject).to receive(:jruby?).and_return(false)
-      expect { subject.load_runtime_jars! }.to raise_error
-    end
-
     it "find runtime jars in the default location" do
       expect(subject).to receive(:find_jars).with(default_runtime_location).and_return([])
       subject.load_runtime_jars!

data/spec/logstash/event_spec.rb

@@ -10,6 +10,11 @@ TIMESTAMP = "@timestamp"
 
 describe LogStash::Event do
   context "to_json" do
+    it "should correctly serialize RubyNil values a Null values" do
+      e = LogStash::Event.new({ "null_value" => nil, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
+      expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"null_value\":null,\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\"}"))
+    end
+
     it "should serialize simple values" do
       e = LogStash::Event.new({"foo" => "bar", "bar" => 1, "baz" => 1.0, TIMESTAMP => "2015-05-28T23:02:05.350Z"})
       expect(JSON.parse(e.to_json)).to eq(JSON.parse("{\"foo\":\"bar\",\"bar\":1,\"baz\":1.0,\"@timestamp\":\"2015-05-28T23:02:05.350Z\",\"@version\":\"1\"}"))
@@ -141,7 +146,7 @@ describe LogStash::Event do
     end
 
     it "should set XXJavaProxy Jackson crafted" do
-      proxy = org.logstash.Util.getMapFixtureJackson()
+      proxy = org.logstash.RspecTestUtils.getMapFixtureJackson()
       # proxy is {"string": "foo", "int": 42, "float": 42.42, "array": ["bar","baz"], "hash": {"string":"quux"} }
       e = LogStash::Event.new()
       e.set("[proxy]", proxy)
@@ -154,7 +159,7 @@ describe LogStash::Event do
     end
 
     it "should set XXJavaProxy hand crafted" do
-      proxy = org.logstash.Util.getMapFixtureHandcrafted()
+      proxy = org.logstash.RspecTestUtils.getMapFixtureHandcrafted()
       # proxy is {"string": "foo", "int": 42, "float": 42.42, "array": ["bar","baz"], "hash": {"string":"quux"} }
       e = LogStash::Event.new()
       e.set("[proxy]", proxy)

data/spec/logstash/filter_delegator_spec.rb

@@ -14,7 +14,7 @@ describe LogStash::FilterDelegator do
   end
 
   include_context "execution_context"
-
+  
   let(:logger) { double(:logger) }
   let(:filter_id) { "my-filter" }
   let(:config) do

data/spec/logstash/filters/base_spec.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 require "spec_helper"
 require "logstash/json"
+require 'support/pipeline/pipeline_helpers'
 
 # use a dummy NOOP filter to test Filters::Base
 class LogStash::Filters::NOOP < LogStash::Filters::Base
@@ -50,6 +51,7 @@ describe LogStash::Filters::Base do
 end
 
 describe LogStash::Filters::NOOP do
+  extend PipelineHelpers
 
   describe "adding multiple values to one field" do
     config <<-CONFIG
@@ -61,7 +63,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample "example" do
+    sample_one("example") do
       insist { subject.get("new_field") } == ["new_value", "new_value_2"]
     end
   end
@@ -75,7 +77,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop") do
+    sample_one("type" => "noop") do
       insist { subject.get("tags") } == ["test"]
     end
   end
@@ -89,11 +91,11 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop") do
+    sample_one("type" => "noop") do
       insist { subject.get("tags") } == ["test"]
     end
 
-    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+    sample_one("type" => "noop", "tags" => ["t1", "t2"]) do
       insist { subject.get("tags") } == ["t1", "t2", "test"]
     end
   end
@@ -107,11 +109,11 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop") do
+    sample_one("type" => "noop") do
       insist { subject.get("tags") } == ["bar"]
     end
 
-    sample("type" => "noop", "tags" => "foo") do
+    sample_one("type" => "noop", "tags" => "foo") do
       insist { subject.get("tags") } == ["foo", "bar"]
     end
   end
@@ -125,7 +127,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "tags" => "foo") do
+    sample_one("type" => "noop", "tags" => "foo") do
       # this is completely weird but seems to be already expected in other specs
       insist { subject.get("tags") } == ["foo", "foo"]
     end
@@ -140,19 +142,19 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop") do
+    sample_one("type" => "noop") do
       insist { subject.get("tags") } == ["test"]
     end
 
-    sample("type" => "noop", "tags" => ["t1"]) do
+    sample_one("type" => "noop", "tags" => ["t1"]) do
       insist { subject.get("tags") } == ["t1", "test"]
     end
 
-    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+    sample_one("type" => "noop", "tags" => ["t1", "t2"]) do
       insist { subject.get("tags") } == ["t1", "t2", "test"]
     end
 
-    sample("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
+    sample_one("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
       insist { subject.get("tags") } == ["t1", "t2", "t3", "test"]
     end
   end
@@ -166,39 +168,39 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "tags" => "foo") do
+    sample_one("type" => "noop", "tags" => "foo") do
       insist { subject.get("tags") } == ["foo"]
     end
 
-    sample("type" => "noop", "tags" => "t2") do
+    sample_one("type" => "noop", "tags" => "t2") do
       insist { subject.get("tags") } == []
     end
 
-    sample("type" => "noop", "tags" => ["t2"]) do
+    sample_one("type" => "noop", "tags" => ["t2"]) do
       insist { subject.get("tags") } == []
     end
 
-    sample("type" => "noop", "tags" => ["t4"]) do
+    sample_one("type" => "noop", "tags" => ["t4"]) do
       insist { subject.get("tags") } == ["t4"]
     end
 
-    sample("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
+    sample_one("type" => "noop", "tags" => ["t1", "t2", "t3"]) do
       insist { subject.get("tags") } == ["t1"]
     end
 
     # also test from Json deserialized data to test the handling of native Java collections by JrJackson
     # see https://github.com/elastic/logstash/issues/2261
-    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\", \"t3\"]}")) do
+    sample_one(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\", \"t3\"]}")) do
       insist { subject.get("tags") } == ["t1"]
     end
 
-    sample("type" => "noop", "tags" => ["t1", "t2"]) do
+    sample_one("type" => "noop", "tags" => ["t1", "t2"]) do
       insist { subject.get("tags") } == ["t1"]
     end
 
     # also test from Json deserialized data to test the handling of native Java collections by JrJackson
     # see https://github.com/elastic/logstash/issues/2261
-    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\"]}")) do
+    sample_one(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"t2\"]}")) do
       insist { subject.get("tags") } == ["t1"]
     end
   end
@@ -212,13 +214,13 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "tags" => ["t1", "goaway", "t3"], "blackhole" => "goaway") do
+    sample_one("type" => "noop", "tags" => ["t1", "goaway", "t3"], "blackhole" => "goaway") do
       insist { subject.get("tags") } == ["t1", "t3"]
     end
 
     # also test from Json deserialized data to test the handling of native Java collections by JrJackson
     # see https://github.com/elastic/logstash/issues/2261
-    sample(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"goaway\", \"t3\"], \"blackhole\":\"goaway\"}")) do
+    sample_one(LogStash::Json.load("{\"type\":\"noop\", \"tags\":[\"t1\", \"goaway\", \"t3\"], \"blackhole\":\"goaway\"}")) do
       insist { subject.get("tags") } == ["t1", "t3"]
     end
   end
@@ -232,17 +234,17 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "t4" => "four") do
+    sample_one("type" => "noop", "t4" => "four") do
       insist { subject }.include?("t4")
     end
 
-    sample("type" => "noop", "t1" => "one", "t2" => "two", "t3" => "three") do
+    sample_one("type" => "noop", "t1" => "one", "t2" => "two", "t3" => "three") do
       insist { subject }.include?("t1")
       reject { subject }.include?("t2")
       reject { subject }.include?("t3")
     end
 
-    sample("type" => "noop", "t1" => "one", "t2" => "two") do
+    sample_one("type" => "noop", "t1" => "one", "t2" => "two") do
       insist { subject }.include?("t1")
       reject { subject }.include?("t2")
     end
@@ -257,7 +259,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("tags" => "foo") do
+    sample_one("tags" => "foo") do
       reject { subject }.include?("tags")
     end
   end
@@ -271,7 +273,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "t1" => {"t2" => "two", "t3" => "three"}) do
+    sample_one("type" => "noop", "t1" => {"t2" => "two", "t3" => "three"}) do
       insist { subject }.include?("t1")
       reject { subject }.include?("[t1][t2]")
       insist { subject }.include?("[t1][t3]")
@@ -287,7 +289,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "t1" => ["t2", "t3"]) do
+    sample_one("type" => "noop", "t1" => ["t2", "t3"]) do
       insist { subject }.include?("t1")
       insist { subject.get("[t1][0]") } == "t3"
     end
@@ -302,7 +304,7 @@ describe LogStash::Filters::NOOP do
     }
     CONFIG
 
-    sample("type" => "noop", "blackhole" => "go", "go" => "away") do
+    sample_one("type" => "noop", "blackhole" => "go", "go" => "away") do
       insist { subject }.include?("blackhole")
       reject { subject }.include?("go")
     end

data/spec/logstash/instrument/wrapped_write_client_spec.rb

@@ -47,7 +47,7 @@ describe LogStash::Instrument::WrappedWriteClient do
     end
 
     it "pushes batch to the `WriteClient`" do
-      batch = write_client.get_new_batch
+      batch = []
       batch << event
 
       pusher_thread = Thread.new(subject, batch) do |_subject, _batch|
@@ -101,7 +101,7 @@ describe LogStash::Instrument::WrappedWriteClient do
   end
 
   context "WrappedSynchronousQueue" do
-    let(:queue) { LogStash::Util::WrappedSynchronousQueue.new }
+    let(:queue) { LogStash::Util::WrappedSynchronousQueue.new(1024) }
 
     before do
       read_client.set_events_metric(metric.namespace([:stats, :events]))

data/spec/logstash/java_filter_delegator_spec.rb

@@ -0,0 +1,176 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/java_filter_delegator"
+require "logstash/instrument/null_metric"
+require "logstash/event"
+require "logstash/execution_context"
+require "support/shared_contexts"
+
+describe LogStash::JavaFilterDelegator do
+
+  class MockGauge
+    def increment(_)
+    end
+  end
+
+  include_context "execution_context"
+  
+  let(:logger) { double(:logger) }
+  let(:filter_id) { "my-filter" }
+  let(:config) do
+    { "host" => "127.0.0.1", "id" => filter_id }
+  end
+  let(:collector) { [] }
+  let(:counter_in) { MockGauge.new }
+  let(:counter_out) { MockGauge.new }
+  let(:counter_time) { MockGauge.new }
+  let(:metric) { LogStash::Instrument::NamespacedNullMetric.new(collector, :null) }
+  let(:events) { [LogStash::Event.new, LogStash::Event.new] }
+
+  before :each do
+    allow(pipeline).to receive(:id).and_return(pipeline_id)
+    allow(metric).to receive(:namespace).with(anything).and_return(metric)
+    allow(metric).to receive(:counter).with(:in).and_return(counter_in)
+    allow(metric).to receive(:counter).with(:out).and_return(counter_out)
+    allow(metric).to receive(:counter).with(:duration_in_millis).and_return(counter_time)
+  end
+
+  let(:plugin_klass) do
+    Class.new(LogStash::Filters::Base) do
+      config_name "super_plugin"
+      config :host, :validate => :string
+      def register; end
+    end
+  end
+
+  subject { described_class.new(logger, plugin_klass, metric, execution_context, config) }
+
+  it "create a plugin with the passed options" do
+    expect(plugin_klass).to receive(:new).with(config).and_return(plugin_klass.new(config))
+    described_class.new(logger, plugin_klass, metric, execution_context, config)
+  end
+
+  context "when the plugin support flush" do
+    let(:plugin_klass) do
+      Class.new(LogStash::Filters::Base) do
+        config_name "super_plugin"
+        config :host, :validate => :string
+        def register; end
+        def flush(options = {}); @events ; end
+        def filter(event)
+          @events ||= []
+          @events << event
+          event.cancel
+        end
+      end
+    end
+
+    it "defines a flush method" do
+      expect(subject.respond_to?(:flush)).to be_truthy
+    end
+
+    context "when the flush return events" do
+      it "increments the out" do
+        subject.multi_filter([LogStash::Event.new])
+        expect(counter_out).to receive(:increment).with(1)
+        subject.flush({})
+      end
+    end
+
+    context "when the flush doesn't return anything" do
+      it "doesnt increment the out" do
+        expect(metric).not_to receive(:increment)
+        subject.flush({})
+      end
+    end
+
+    context "when the filter buffer events" do
+      before do
+        allow(metric).to receive(:increment).with(anything, anything)
+      end
+
+      it "has incremented :in" do
+        expect(counter_in).to receive(:increment).with(events.size)
+        subject.multi_filter(events)
+      end
+
+      it "has not incremented :out" do
+        expect(counter_out).not_to receive(:increment).with(anything)
+        subject.multi_filter(events)
+      end
+    end
+
+    context "when the filter create more events" do
+      let(:plugin_klass) do
+        Class.new(LogStash::Filters::Base) do
+          config_name "super_plugin"
+          config :host, :validate => :string
+          def register; end
+          def flush(options = {}); @events ; end
+
+          # naive split filter implementation
+          def filter(event)
+            event.cancel
+            2.times { yield LogStash::Event.new }
+          end
+        end
+      end
+
+      before do
+        allow(metric).to receive(:increment).with(anything, anything)
+      end
+
+      it "increments the in/out of the metric" do
+        expect(counter_in).to receive(:increment).with(events.size)
+        expect(counter_out).to receive(:increment).with(events.size * 2)
+
+        subject.multi_filter(events)
+      end
+    end
+  end
+
+  context "when the plugin doesnt support flush" do
+    let(:plugin_klass) do
+      Class.new(LogStash::Filters::Base) do
+        config_name "super_plugin"
+        config :host, :validate => :string
+        def register; end
+        def filter(event)
+          event
+        end
+      end
+    end
+
+    before do
+      allow(metric).to receive(:increment).with(anything, anything)
+    end
+
+    it "doesnt define a flush method" do
+      expect(subject.has_flush).to be_falsey
+    end
+
+    it "increments the in/out of the metric" do
+      expect(counter_in).to receive(:increment).with(events.size)
+      expect(counter_out).to receive(:increment).with(events.size)
+
+      subject.multi_filter(events)
+    end
+  end
+
+  context "#config_name" do
+    it "proxy the config_name to the class method" do
+      expect(subject.config_name).to eq("super_plugin")
+    end
+  end
+
+  context "delegate methods to the original plugin" do
+    # I am not testing the behavior of these methods
+    # this is done in the plugin tests. I just want to make sure
+    # the proxy delegates the methods.
+    LogStash::JavaFilterDelegator::DELEGATED_METHODS.each do |method|
+      it "delegate method: `#{method}` to the filter" do
+        expect(subject.respond_to?(method))
+      end
+    end
+  end
+end