logstash-core 2.4.1-java → 5.0.0.alpha1-java

data/spec/logstash/plugin_spec.rb

@@ -1,18 +1,19 @@
 # encoding: utf-8
+require "spec_helper"
 require "logstash/plugin"
+require "logstash/outputs/base"
+require "logstash/codecs/base"
 require "logstash/inputs/base"
 require "logstash/filters/base"
-require "logstash/outputs/base"
-require "spec_helper"
 
 describe LogStash::Plugin do
   it "should fail lookup on inexisting type" do
-    #expect_any_instance_of(Cabin::Channel).to receive(:debug).once
+    expect_any_instance_of(Cabin::Channel).to receive(:debug).once
     expect { LogStash::Plugin.lookup("badbadtype", "badname") }.to raise_error(LogStash::PluginLoadingError)
   end
 
   it "should fail lookup on inexisting name" do
-    #expect_any_instance_of(Cabin::Channel).to receive(:debug).once
+    expect_any_instance_of(Cabin::Channel).to receive(:debug).once
     expect { LogStash::Plugin.lookup("filter", "badname") }.to raise_error(LogStash::PluginLoadingError)
   end
 
@@ -169,26 +170,90 @@ describe LogStash::Plugin do
 
     end
   end
-  context "Collecting Metric in the plugin" do
-    [LogStash::Inputs::Base, LogStash::Filters::Base, LogStash::Outputs::Base].each do |type|
+
+  describe "#id" do
+    plugin_types = [
+      LogStash::Filters::Base,
+      LogStash::Codecs::Base,
+      LogStash::Outputs::Base,
+      LogStash::Inputs::Base
+    ]
+
+    plugin_types.each do |plugin_type|
       let(:plugin) do
-        Class.new(type) do
-          config_name "goku"
+        Class.new(plugin_type) do
+          config_name "simple_plugin"
+
+          config :host, :validate => :string
+          config :export, :validte => :boolean
+
+          def register; end
+        end
+      end
+
+      let(:config) do
+        {
+          "host" => "127.0.0.1",
+          "export" => true
+        }
+      end
+
+      subject { plugin.new(config) }
+
+      context "plugin type is #{plugin_type}" do
+        context "when there is not ID configured for the output" do
+          it "it uses a UUID to identify this plugins" do
+            expect(subject.id).not_to eq(nil)
+          end
 
-          def register
-            metric.gauge("power-level", 9000)
+          it "will be different between instance of plugins" do
+            expect(subject.id).not_to eq(plugin.new(config).id)
+          end
+        end
+
+        context "When a user provide an ID for the plugin" do
+          let(:id) { "ABC" }
+          let(:config) { super.merge("id" => id) }
+
+          it "uses the user provided ID" do
+            expect(subject.id).to eq(id)
           end
         end
       end
+    end
+  end
 
-      subject { plugin.new }
+  describe "#plugin_unique_name" do
+    let(:plugin) do
+      Class.new(LogStash::Filters::Base,) do
+        config_name "simple_plugin"
+        config :host, :validate => :string
 
-      it "should not raise an exception when recoding a metric" do
-        expect { subject.register }.not_to raise_error
+        def register; end
       end
+    end
+
+    let(:config) do
+      {
+        "host" => "127.0.0.1"
+      }
+    end
+
+    context "when the id is provided" do
+      let(:my_id) { "mysuper-plugin" }
+      let(:config) { super.merge({ "id" => my_id })}
+      subject { plugin.new(config) }
+
+      it "return a human readable ID" do
+        expect(subject.plugin_unique_name).to eq("simple_plugin_#{my_id}")
+      end
+    end
+
+    context "when the id is not provided provided" do
+      subject { plugin.new(config) }
 
-      it "should use a `NullMetric`" do
-        expect(subject.metric).to be_kind_of(LogStash::Instrument::NullMetric)
+      it "return a human readable ID" do
+        expect(subject.plugin_unique_name).to match(/^simple_plugin_/)
       end
     end
   end

data/spec/logstash/runner_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 require "logstash/runner"
 require "stud/task"
 require "stud/trap"
-require "stud/temporary"
+require "logstash/util/java_version"
 
 class NullRunner
   def run(args); end
@@ -11,73 +11,169 @@ end
 
 describe LogStash::Runner do
 
+  subject { LogStash::Runner }
   let(:channel) { Cabin::Channel.new }
 
   before :each do
     allow(Cabin::Channel).to receive(:get).with(LogStash).and_return(channel)
-    allow(channel).to receive(:subscribe).with(any_args).and_call_original
+    allow(channel).to receive(:subscribe).with(any_args)
   end
 
-  context "argument parsing" do
-    it "should run agent" do
-      expect(Stud::Task).to receive(:new).once.and_return(nil)
-      args = ["agent", "-e", ""]
-      expect(subject.run(args)).to eq(nil)
+  describe "argument parsing" do
+    subject { LogStash::Runner.new("") }
+    context "when -e is given" do
+
+      let(:args) { ["-e", "input {} output {}"] }
+      let(:agent) { double("agent") }
+      let(:agent_logger) { double("agent logger") }
+
+      before do
+        allow(agent).to receive(:logger=).with(anything)
+        allow(agent).to receive(:shutdown)
+        allow(agent).to receive(:register_pipeline)
+      end
+
+      it "should execute the agent" do
+        expect(subject).to receive(:create_agent).and_return(agent)
+        expect(agent).to receive(:execute).once
+        subject.run(args)
+      end
+    end
+
+    context "with no arguments" do
+      let(:args) { [] }
+      let(:agent) { double("agent") }
+
+      before(:each) do
+        allow(LogStash::Agent).to receive(:new).and_return(agent)
+        allow(LogStash::Util::JavaVersion).to receive(:warn_on_bad_java_version)
+      end
+
+      it "should show help" do
+        expect($stderr).to receive(:puts).once
+        expect(subject).to receive(:signal_usage_error).once.and_call_original
+        expect(subject).to receive(:show_short_help).once
+        subject.run(args)
+      end
     end
+  end
 
-    it "should run agent help" do
-      expect(subject).to receive(:show_help).once.and_return(nil)
-      args = ["agent", "-h"]
-      expect(subject.run(args).wait).to eq(0)
+  context "--pluginpath" do
+    subject { LogStash::Runner.new("") }
+    let(:single_path) { "/some/path" }
+    let(:multiple_paths) { ["/some/path1", "/some/path2"] }
+
+    it "should add single valid dir path to the environment" do
+      expect(File).to receive(:directory?).and_return(true)
+      expect(LogStash::Environment).to receive(:add_plugin_path).with(single_path)
+      subject.configure_plugin_paths(single_path)
     end
 
-    it "should show help with no arguments" do
-      expect($stderr).to receive(:puts).once.and_return("No command given")
-      expect($stderr).to receive(:puts).once
-      args = []
-      expect(subject.run(args).wait).to eq(1)
+    it "should fail with single invalid dir path" do
+      expect(File).to receive(:directory?).and_return(false)
+      expect(LogStash::Environment).not_to receive(:add_plugin_path)
+      expect{subject.configure_plugin_paths(single_path)}.to raise_error(Clamp::UsageError)
     end
 
-    it "should show help for unknown commands" do
-      expect($stderr).to receive(:puts).once.and_return("No such command welp")
-      expect($stderr).to receive(:puts).once
-      args = ["welp"]
-      expect(subject.run(args).wait).to eq(1)
+    it "should add multiple valid dir path to the environment" do
+      expect(File).to receive(:directory?).exactly(multiple_paths.size).times.and_return(true)
+      multiple_paths.each{|path| expect(LogStash::Environment).to receive(:add_plugin_path).with(path)}
+      subject.configure_plugin_paths(multiple_paths)
     end
   end
 
   context "--auto-reload" do
+    subject { LogStash::Runner.new("") }
     context "when -f is not given" do
 
-      let(:args) { ["agent", "-r", "-e", "input {} output {}"] }
+      let(:args) { ["-r", "-e", "input {} output {}"] }
 
       it "should exit immediately" do
-        expect(subject.run(args).wait).to eq(1)
+        expect(subject).to receive(:signal_usage_error).and_call_original
+        expect(subject).to receive(:show_short_help)
+        expect(subject.run(args)).to eq(1)
       end
     end
   end
 
-  context "--log-in-json" do
-    let(:logfile) { Stud::Temporary.file }
-    let(:args) { [ "agent", "--log-in-json", "-l", logfile.path, "-e", "some-invalid-config" ] }
+  describe "--config-test" do
+    subject { LogStash::Runner.new("") }
+    let(:args) { ["-t", "-e", pipeline_string] }
 
-    after do
-      logfile.close
-      File.unlink(logfile.path)
+    context "with a good configuration" do
+      let(:pipeline_string) { "input { } filter { } output { }" }
+      it "should exit successfuly" do
+        expect(channel).to receive(:terminal)
+        expect(subject.run(args)).to eq(0)
+      end
     end
 
-    before do
-      expect(channel).to receive(:subscribe).with(kind_of(LogStash::Logging::JSON)).and_call_original
-      subject.run(args).wait
+    context "with a bad configuration" do
+      let(:pipeline_string) { "rlwekjhrewlqrkjh" }
+      it "should fail by returning a bad exit code" do
+        expect(channel).to receive(:fatal)
+        expect(subject.run(args)).to eq(1)
+      end
+    end
+  end
+  describe "pipeline settings" do
+    let(:pipeline_string) { "input { stdin {} } output { stdout {} }" }
+    let(:main_pipeline_settings) { { :pipeline_id => "main" } }
+    let(:pipeline) { double("pipeline") }
+
+    before(:each) do
+      allow_any_instance_of(LogStash::Agent).to receive(:execute).and_return(true)
+      task = Stud::Task.new { 1 }
+      allow(pipeline).to receive(:run).and_return(task)
+      allow(pipeline).to receive(:shutdown)
+    end
+
+    context "when :pipeline_workers is not defined by the user" do
+      it "should not pass the value to the pipeline" do
+        expect(LogStash::Pipeline).to receive(:new).once.with(pipeline_string, hash_excluding(:pipeline_workers)).and_return(pipeline)
+
+        args = ["-e", pipeline_string]
+        subject.run("bin/logstash", args)
+      end
+    end
 
-      # Log file should have stuff in it.
-      expect(logfile.stat.size).to be > 0
+    context "when :pipeline_workers is defined by the user" do
+      it "should pass the value to the pipeline" do
+        main_pipeline_settings[:pipeline_workers] = 2
+        expect(LogStash::Pipeline).to receive(:new).with(pipeline_string, hash_including(main_pipeline_settings)).and_return(pipeline)
+
+        args = ["-w", "2", "-e", pipeline_string]
+        subject.run("bin/logstash", args)
+      end
     end
 
-    it "should log in valid json. One object per line." do
-      logfile.each_line do |line|
-        expect(line).not_to be_empty
-        expect { LogStash::Json.load(line) }.not_to raise_error
+    describe "debug_config" do
+      it "should set 'debug_config' to false by default" do
+        expect(LogStash::Config::Loader).to receive(:new).with(anything, false).and_call_original
+        expect(LogStash::Pipeline).to receive(:new).with(pipeline_string, hash_including(:debug_config => false)).and_return(pipeline)
+        args = ["--debug", "-e", pipeline_string]
+        subject.run("bin/logstash", args)
+      end
+
+      it "should allow overriding debug_config" do
+        expect(LogStash::Config::Loader).to receive(:new).with(anything, true).and_call_original
+        expect(LogStash::Pipeline).to receive(:new).with(pipeline_string, hash_including(:debug_config => true)).and_return(pipeline)
+        args = ["--debug", "--debug-config",  "-e", pipeline_string]
+        subject.run("bin/logstash", args)
+      end
+    end
+
+    context "when configuring environment variable support" do
+      it "should set 'allow_env' to false by default" do
+        args = ["-e", pipeline_string]
+        expect(LogStash::Pipeline).to receive(:new).with(pipeline_string, hash_including(:allow_env => false)).and_return(pipeline)
+        subject.run("bin/logstash", args)
+      end
+
+      it "should support templating environment variables" do
+        args = ["-e", pipeline_string, "--allow-env"]
+        expect(LogStash::Pipeline).to receive(:new).with(pipeline_string, hash_including(:allow_env => true)).and_return(pipeline)
+        subject.run("bin/logstash", args)
       end
     end
   end

data/spec/logstash/shutdown_watcher_spec.rb

@@ -20,7 +20,6 @@ describe LogStash::ShutdownWatcher do
     allow(pipeline).to receive(:thread).and_return(Thread.current)
     allow(reporter).to receive(:snapshot).and_return(reporter_snapshot)
     allow(reporter_snapshot).to receive(:o_simple_hash).and_return({})
-    allow(reporter_snapshot).to receive(:to_json_data).and_return("reporter-double")
 
     allow(subject).to receive(:pipeline_report_snapshot).and_wrap_original do |m, *args|
       report_count += 1

data/spec/logstash/util/duration_formatter_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require "logstash/util/duration_formatter"
+require "spec_helper"
+
+describe LogStash::Util::DurationFormatter do
+  let(:duration) { 3600 * 1000 } # in milliseconds
+
+  it "returns a human format" do
+    expect(subject.human_format(duration)).to eq("1h")
+  end
+end

data/spec/logstash/util/java_version_spec.rb

@@ -19,10 +19,18 @@ describe "LogStash::Util::JavaVersion" do
     expect(mod.bad_java_version?("1.6.0")).to be_truthy
   end
 
+  it "should mark java 7 version as bad" do
+    expect(mod.bad_java_version?("1.7.0_51")).to be_truthy
+  end
+  
+  it "should mark java version 8 as good" do
+    expect(mod.bad_java_version?("1.8.0")).to be_falsey
+  end
+  
   it "should mark a good standard java version as good" do
-    expect(mod.bad_java_version?("1.7.0_51")).to be_falsey
+    expect(mod.bad_java_version?("1.8.0_65")).to be_falsey
   end
-
+  
   it "should mark a good beta version as good" do
     expect(mod.bad_java_version?("1.8.0-beta")).to be_falsey
   end

data/spec/logstash/util_spec.rb

@@ -3,8 +3,18 @@ require 'spec_helper'
 
 require "logstash/util"
 
+class ClassNameTest
+end
+
+module TestingClassName
+  class TestKlass
+  end
+end
+
 describe LogStash::Util do
 
+  subject { described_class }
+
   context "stringify_keys" do
     it "should convert hash symbol keys to strings" do
       expect(LogStash::Util.stringify_symbols({:a => 1, "b" => 2})).to eq({"a" => 1, "b" => 2})
@@ -32,4 +42,22 @@ describe LogStash::Util do
       expect(LogStash::Util.stringify_symbols([:a, [1, :b]])).to eq(["a", [1, "b"]])
     end
   end
+
+  describe ".class_name" do
+    context "when the class is a top level class" do
+      let(:klass) { ClassNameTest.new }
+
+      it "returns the name of the class" do
+        expect(subject.class_name(klass)).to eq("ClassNameTest")
+      end
+    end
+
+    context "when the class is nested inside modules" do
+      let(:klass) { TestingClassName::TestKlass.new }
+
+      it "returns the name of the class" do
+        expect(subject.class_name(klass)).to eq("TestKlass")
+      end
+    end
+  end
 end

data/spec/support/matchers.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require "rspec"
+require "rspec/expectations"
+
+RSpec::Matchers.define :be_a_metric_event do |namespace, type, *args|
+  match do
+    namespace == Array(actual[0]).concat(Array(actual[1])) &&
+      type == actual[2] &&
+      args == actual[3..-1]
+  end
+end
+
+# Match to test `NullObject` pattern
+RSpec::Matchers.define :implement_interface_of do |type, key, value|
+  match do |actual|
+    all_instance_methods_implemented?
+  end
+
+  def missing_methods
+    expected.instance_methods.select { |method| !actual.instance_methods.include?(method) }
+  end
+
+  def all_instance_methods_implemented?
+    expected.instance_methods.all? { |method| actual.instance_methods.include?(method) }
+  end
+
+  failure_message do
+    "Expecting `#{expected}` to implements instance methods of `#{actual}`, missing methods: #{missing_methods.join(",")}"
+  end
+end