logstash-core 5.6.16-java → 6.0.0.alpha1-java

data/spec/logstash/config/source_loader_spec.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+require "logstash/config/source_loader"
+require "logstash/config/source/base"
+require_relative "../../support/helpers"
+
+def temporary_pipeline_config(id, source, reader = "random_reader")
+  config_part = org.logstash.common.SourceWithMetadata.new("local", "...", "input {} output {}")
+  LogStash::Config::PipelineConfig.new(source, id, [config_part], LogStash::SETTINGS)
+end
+
+class DummySource < LogStash::Config::Source::Base
+  def pipeline_configs
+    [temporary_pipeline_config("dummy_source_id", self.class)]
+  end
+
+  def match?
+    @settings.get("path.config") =~ /dummy/
+  end
+end
+
+class AnotherDummySource < LogStash::Config::Source::Base
+  def pipeline_configs
+    [temporary_pipeline_config("another_dummy_source_id", self.class)]
+  end
+
+  def match?
+    @settings.get("path.config") =~ /another/
+  end
+end
+
+class FailingSource < LogStash::Config::Source::Base
+  def pipeline_configs
+    raise "Something went wrong"
+  end
+
+  def match?
+    @settings.get("path.config") =~ /fail/
+  end
+end
+
+describe LogStash::Config::SourceLoader do
+  subject { described_class.new }
+
+  it "default to local source" do
+    expect(subject.sources.size).to eq(0)
+  end
+
+  it "allows to override the available source loaders" do
+    subject.configure_sources(DummySource)
+    expect(subject.sources.size).to eq(1)
+    expect(subject.sources).to include(DummySource)
+  end
+
+  it "allows to add a new sources" do
+    subject.add_source(DummySource)
+    subject.add_source(LogStash::Config::Source::Local)
+
+    expect(subject.sources.size).to eq(2)
+    expect(subject.sources).to include(DummySource, LogStash::Config::Source::Local)
+  end
+
+  context "when no source match" do
+    let(:settings) { mock_settings("path.config" => "make it not match") } # match both regex
+
+    it "raises an exception" do
+      subject.configure_sources([DummySource.new(settings), AnotherDummySource.new(settings)])
+
+      expect { subject.fetch }.to raise_error
+    end
+  end
+
+  context "when source loader match" do
+    context "when an happen in the source" do
+      let(:settings) { mock_settings("path.config" => "dummy fail") }
+
+      it "wraps the error in a failed result" do
+        subject.configure_sources([DummySource.new(settings), FailingSource.new(settings)])
+
+        result = subject.fetch
+
+        expect(result.success?).to be_falsey
+        expect(result.error).not_to be_nil
+      end
+    end
+
+    context "when multiple match" do
+      let(:settings) { mock_settings("path.config" => "another dummy") } # match both regex
+
+      it "return the loaders with the matched sources" do
+        subject.configure_sources([DummySource.new(settings), AnotherDummySource.new(settings)])
+
+        result = subject.fetch
+
+        expect(result.success?).to be_truthy
+        expect(result.response.size).to eq(2)
+        expect(result.response.collect(&:pipeline_id)).to include("dummy_source_id", "another_dummy_source_id")
+      end
+
+      context "when duplicate id is returned" do
+        it "fails to return pipeline" do
+          subject.configure_sources([AnotherDummySource.new(settings), AnotherDummySource.new(settings)])
+          result = subject.fetch
+          expect(result.success?).to be_falsey
+        end
+      end
+    end
+
+    context "when one match" do
+      let(:settings) { mock_settings("path.config" => "another") } # match both regex
+
+      it "return the loaders with the matched sources" do
+        subject.configure_sources([DummySource.new(settings), AnotherDummySource.new(settings)])
+
+        result = subject.fetch
+
+        expect(result.success?).to be_truthy
+        expect(result.response.size).to eq(1)
+        expect(result.response.collect(&:pipeline_id)).to include("another_dummy_source_id")
+      end
+    end
+  end
+end

data/spec/logstash/converge_result_spec.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+require "logstash/converge_result"
+require "logstash/pipeline_action/stop"
+require "spec_helper"
+
+describe LogStash::ConvergeResult do
+  let(:expected_actions_count) { 2 }
+  let(:action) { LogStash::PipelineAction::Stop.new(:main) }
+
+  subject { described_class.new(expected_actions_count) }
+
+
+  context "When the action was executed" do
+    it "returns the time of execution" do
+      expect(LogStash::ConvergeResult::FailedAction.new("testing").executed_at.class).to eq(LogStash::Timestamp)
+      expect(LogStash::ConvergeResult::SuccessfulAction.new.executed_at.class).to eq(LogStash::Timestamp)
+    end
+  end
+
+  context "conversion of action result" do
+    let(:action) { LogStash::PipelineAction::Stop.new(:an_action) }
+
+    context "booleans" do
+      context "True" do
+        it "converts to a `SuccessfulAction`" do
+          subject.add(action, true)
+          expect(subject.successful_actions.keys).to include(action)
+        end
+      end
+
+      context "False" do
+        it "converts to a `FailedAction`" do
+          subject.add(action, false)
+          expect(subject.failed_actions.keys).to include(action)
+          expect(subject.failed_actions.values.pop.message).to match(/Could not execute action: #{action}/)
+        end
+      end
+    end
+
+    context "`ActionResult` classes" do
+      context "SuccessfulAction" do
+        let(:result) { LogStash::ConvergeResult::SuccessfulAction.new }
+
+        it "doesn't convert the class" do
+          subject.add(action, result)
+          expect(subject.successful_actions.keys).to include(action)
+          expect(subject.successful_actions.values).to include(result)
+        end
+      end
+
+      context "FailedAction" do
+        let(:result) { LogStash::ConvergeResult::FailedAction.new("could be worse") }
+
+        it "doesn't convert the class" do
+          subject.add(action, result)
+          expect(subject.failed_actions.keys).to include(action)
+          expect(subject.failed_actions.values).to include(result)
+        end
+      end
+    end
+
+    context "Exception" do
+      it "converts to a `FailedAction" do
+        begin
+          raise ArgumentError, "hello world"
+        rescue => e
+          subject.add(action, e)
+
+          expect(subject.failed_actions.keys).to include(action)
+          failed_action = subject.failed_actions.values.pop
+
+          expect(failed_action.message).to eq("hello world")
+          expect(failed_action.backtrace).not_to be_nil
+        end
+      end
+    end
+  end
+
+  context "when not all the actions are executed" do
+    context "#complete?" do
+      it "returns false" do
+        expect(subject.complete?).to be_falsey
+      end
+    end
+
+    context "#success?" do
+      it "returns false" do
+        expect(subject.success?).to be_falsey
+      end
+    end
+  end
+
+  context "when all the actions are executed" do
+    context "all succesfull" do
+      let(:success_action) { LogStash::PipelineAction::Stop.new(:success) }
+      let(:success_action_2) { LogStash::PipelineAction::Stop.new(:success_2) }
+
+      before do
+        subject.add(success_action, true)
+        subject.add(success_action_2, true)
+      end
+
+      context "#success?" do
+        it "returns true" do
+          expect(subject.success?).to be_truthy
+        end
+      end
+
+      context "#complete?" do
+        it "returns true" do
+          expect(subject.complete?).to be_truthy
+        end
+      end
+
+      context "filtering on the actions result" do
+        it "returns the successful actions" do
+          expect(subject.successful_actions.size).to eq(2)
+          expect(subject.successful_actions.keys).to include(success_action, success_action_2)
+        end
+
+        it "returns the failed actions" do
+          expect(subject.failed_actions.size).to eq(0)
+        end
+      end
+    end
+
+    context "not successfully" do
+      let(:success_action) { LogStash::PipelineAction::Stop.new(:success) }
+      let(:failed_action) { LogStash::PipelineAction::Stop.new(:failed) }
+
+      before do
+        subject.add(failed_action, false)
+        subject.add(success_action, true)
+      end
+
+      context "#success?" do
+        it "returns false" do
+          expect(subject.success?).to be_falsey
+        end
+      end
+
+      context "#complete?" do
+        it "returns true" do
+          expect(subject.complete?).to be_truthy
+        end
+      end
+
+      context "#total" do
+        it "returns the number of actions" do
+          expect(subject.total).to eq(2)
+        end
+      end
+
+      context "#fails_count" do
+        it "returns the number of actions" do
+          expect(subject.fails_count).to eq(1)
+        end
+      end
+
+      context "#success_count" do
+        it "returns the number of actions" do
+          expect(subject.success_count).to eq(1)
+        end
+      end
+
+      context "filtering on the actions result" do
+        it "returns the successful actions" do
+          expect(subject.successful_actions.size).to eq(1)
+          expect(subject.successful_actions.keys).to include(success_action)
+        end
+
+        it "returns the failed actions" do
+          expect(subject.failed_actions.size).to eq(1)
+          expect(subject.failed_actions.keys).to include(failed_action)
+        end
+      end
+    end
+  end
+end

data/spec/logstash/event_spec.rb

@@ -84,15 +84,6 @@ describe LogStash::Event do
       expect(e.get("foo")).to eq("bar")
     end
 
-    it "should propagate changes to mutable strings to java APIs" do
-      e = LogStash::Event.new()
-      e.to_java.setField("foo", "bar")
-      expect(e.get("foo")).to eq("bar")
-      e.get("foo").gsub!(/bar/, 'pff')
-      expect(e.get("foo")).to eq("pff")
-      expect(e.to_java.getField("foo")).to eq("pff")
-    end
-
     it "should set deep hash values" do
       e = LogStash::Event.new()
       expect(e.set("[foo][bar]", "baz")).to eq("baz")
@@ -352,61 +343,4 @@ describe LogStash::Event do
       expect { subject.baz() }.to raise_error(NoMethodError, /undefined method `baz' for/)
     end
   end
-
-  describe "#clone" do
-    let(:fieldref) { "[@metadata][fancy]" }
-    let(:event1) { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => "pants" }) }
-    let(:event2) { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => {"fancy2" => "pants2"} }) }
-    let(:event3) { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => {"fancy2" => {"fancy3" => "pants2"}} }) }
-    let(:event4) { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => {"fancy2" => ["pants1", "pants2"]} }) }
-    let(:event5) { LogStash::Event.new("hello" => "world", "@metadata" => { "fancy" => "pants", "smarty" => "pants2" }) }
-
-    it "should clone metadata fields" do
-      cloned = event1.clone
-      expect(cloned.get(fieldref)).to eq("pants")
-      expect(cloned.to_hash_with_metadata).to include("@metadata")
-    end
-
-    it "should clone metadata fields with nested json" do
-      cloned = event2.clone
-      expect(cloned.get(fieldref)).to eq({"fancy2" => "pants2"})
-      expect(cloned.get("hello")).to eq("world")
-      expect(cloned.to_hash).not_to include("@metadata")
-      expect(cloned.to_hash_with_metadata).to include("@metadata")
-    end
-
-    it "should clone metadata fields with 2-level nested json" do
-      cloned = event3.clone
-      expect(cloned.get(fieldref)).to eq({"fancy2" => {"fancy3" => "pants2"}})
-      expect(cloned.to_hash).not_to include("@metadata")
-      expect(cloned.to_hash_with_metadata).to include("@metadata")
-    end
-
-    it "should clone metadata fields with nested json and array value" do
-      cloned = event4.clone
-      expect(cloned.get(fieldref)).to eq({"fancy2" => ["pants1", "pants2"]})
-      expect(cloned.to_hash_with_metadata).to include("@metadata")
-    end
-
-    it "should clone metadata fields with multiple keys" do
-      cloned = event5.clone
-      expect(cloned.get(fieldref)).to eq("pants")
-      expect(cloned.get("[@metadata][smarty]")).to eq("pants2")
-      expect(cloned.to_hash_with_metadata).to include("@metadata")
-    end
-
-    it "mutating cloned event should not affect the original event" do
-      cloned = event1.clone
-      cloned.set("hello", "foobar")
-      expect(cloned.get("hello")).to eq("foobar")
-      expect(event1.get("hello")).to eq("world")
-    end
-
-    it "mutating cloned event's metadata should not affect the original event metadata" do
-      cloned = event1.clone
-      cloned.set("[@metadata][fancy]", "foobar")
-      expect(cloned.get("[@metadata][fancy]")).to eq("foobar")
-      expect(event1.get("[@metadata][fancy]")).to eq("pants")
-    end
-  end
 end

data/spec/logstash/execution_context_spec.rb

@@ -1,32 +1,28 @@
 # encoding: utf-8
 require "spec_helper"
-require "logstash/util/dead_letter_queue_manager"
 require "logstash/execution_context"
 
 describe LogStash::ExecutionContext do
   let(:pipeline) { double("pipeline") }
   let(:pipeline_id) { :main }
-  let(:plugin_id) { "plugin_id" }
-  let(:plugin_type) { "plugin_type" }
-  let(:dlq_writer) { LogStash::Util::DummyDeadLetterQueueWriter.new }
-
+  let(:agent) { double("agent") }
+  
   before do
+    allow(pipeline).to receive(:agent).and_return(agent)
     allow(pipeline).to receive(:pipeline_id).and_return(pipeline_id)
   end
 
-  subject { described_class.new(pipeline, plugin_id, plugin_type, dlq_writer) }
+  subject { described_class.new(pipeline, agent) }
 
   it "returns the `pipeline_id`" do
     expect(subject.pipeline_id).to eq(pipeline_id)
   end
-
+  
   it "returns the pipeline" do
     expect(subject.pipeline).to eq(pipeline)
   end
-
-  it "returns the plugin-specific dlq writer" do
-    expect(subject.dlq_writer.plugin_type).to eq(plugin_type)
-    expect(subject.dlq_writer.plugin_id).to eq(plugin_id)
-    expect(subject.dlq_writer.inner_writer).to eq(dlq_writer)
+  
+  it "returns the agent" do
+    expect(subject.agent).to eq(agent)
   end
 end

data/spec/logstash/filter_delegator_spec.rb

@@ -4,35 +4,23 @@ require "logstash/filter_delegator"
 require "logstash/instrument/null_metric"
 require "logstash/event"
 require "logstash/execution_context"
+require "support/shared_contexts"
 
 describe LogStash::FilterDelegator 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] }
-  let(:default_execution_context) { LogStash::ExecutionContext.new(:main, filter_id, "filter",
-                                                                   LogStash::Util::DummyDeadLetterQueueWriter.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
@@ -43,11 +31,11 @@ describe LogStash::FilterDelegator do
     end
   end
 
-  subject { described_class.new(logger, plugin_klass, metric, default_execution_context, config) }
+  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, default_execution_context, config)
+    described_class.new(logger, plugin_klass, metric, execution_context, config)
   end
 
   context "when the plugin support flush" do
@@ -72,7 +60,7 @@ describe LogStash::FilterDelegator do
     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)
+        expect(metric).to receive(:increment).with(:out, 1)
         subject.flush({})
       end
     end
@@ -90,12 +78,12 @@ describe LogStash::FilterDelegator do
       end
 
       it "has incremented :in" do
-        expect(counter_in).to receive(:increment).with(events.size)
+        expect(metric).to receive(:increment).with(:in, events.size)
         subject.multi_filter(events)
       end
 
       it "has not incremented :out" do
-        expect(counter_out).not_to receive(:increment).with(anything)
+        expect(metric).not_to receive(:increment).with(:out, anything)
         subject.multi_filter(events)
       end
     end
@@ -121,8 +109,8 @@ describe LogStash::FilterDelegator do
       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)
+        expect(metric).to receive(:increment).with(:in, events.size)
+        expect(metric).to receive(:increment).with(:out, events.size * 2)
 
         subject.multi_filter(events)
       end
@@ -150,8 +138,8 @@ describe LogStash::FilterDelegator do
     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)
+      expect(metric).to receive(:increment).with(:in, events.size)
+      expect(metric).to receive(:increment).with(:out, events.size)
 
       subject.multi_filter(events)
     end