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

data/spec/logstash/config/config_ast_spec.rb

@@ -144,49 +144,6 @@ describe LogStashConfigParser do
     end
   end
 
-  context "when using two plugin sections of the same type" do
-    let(:pipeline_klass) do
-      Class.new do
-        def initialize(config)
-          grammar = LogStashConfigParser.new
-          @config = grammar.parse(config)
-          @code = @config.compile
-          eval(@code)
-        end
-        def plugin(*args);end
-      end
-    end
-    context "(filters)" do
-      let(:config_string) {
-        "input { generator { } }
-         filter { filter1 { } }
-         filter { filter1 { } }
-         output { output1 { } }"
-      }
-
-
-      it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string).instance_variable_get("@generated_objects")
-        filters = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^filter.+?_\d+$/) }
-        expect(filters.size).to eq(2)
-      end
-    end
-
-    context "(filters)" do
-      let(:config_string) {
-        "input { generator { } }
-         output { output1 { } }
-         output { output1 { } }"
-      }
-
-
-      it "should create a pipeline with both sections" do
-        generated_objects = pipeline_klass.new(config_string).instance_variable_get("@generated_objects")
-        outputs = generated_objects.keys.map(&:to_s).select {|obj_name| obj_name.match(/^output.+?_\d+$/) }
-        expect(outputs.size).to eq(2)
-      end
-    end
-  end
   context "when creating two instances of the same configuration" do
 
     let(:config_string) {
@@ -212,12 +169,10 @@ describe LogStashConfigParser do
     end
 
     describe "generated conditional functionals" do
-      it "should be created per instance" do
+      it "should be defined at instance level" do
         instance_1 = pipeline_klass.new(config_string)
         instance_2 = pipeline_klass.new(config_string)
-        generated_method_1 = instance_1.instance_variable_get("@generated_objects")[:cond_func_1]
-        generated_method_2 = instance_2.instance_variable_get("@generated_objects")[:cond_func_1]
-        expect(generated_method_1).to_not be(generated_method_2)
+        expect(instance_1.method(:cond_func_1).owner).to_not be(instance_2.method(:cond_func_1).owner)
       end
     end
   end

data/spec/logstash/config/mixin_spec.rb

@@ -68,74 +68,6 @@ describe LogStash::Config::Mixin do
     end
   end
 
-  context "when validating lists of items" do
-    let(:klass) do
-      Class.new(LogStash::Filters::Base)  do
-        config_name "multiuri"
-        config :uris, :validate => :uri, :list => true
-        config :strings, :validate => :string, :list => true
-        config :required_strings, :validate => :string, :list => true, :required => true
-      end
-    end
-
-    let(:uris) { ["http://example.net/1", "http://example.net/2"] }
-    let(:safe_uris) { uris.map {|str| ::LogStash::Util::SafeURI.new(str) } }
-    let(:strings) { ["I am a", "modern major general"] }
-    let(:required_strings) { ["required", "strings"] }
-
-    subject { klass.new("uris" => uris, "strings" => strings, "required_strings" => required_strings) }
-
-    it "a URI list should return an array of URIs" do
-      expect(subject.uris).to match_array(safe_uris)
-    end
-
-    it "a string list should return an array of strings" do
-      expect(subject.strings).to match_array(strings)
-    end
-
-    context "with a scalar value" do
-      let(:strings) { "foo" }
-
-      it "should return the scalar value as a single element array" do
-        expect(subject.strings).to match_array([strings])
-      end
-    end
-
-    context "with an empty list" do
-      let(:strings) { [] }
-
-      it "should return nil" do
-        expect(subject.strings).to be_nil
-      end
-    end
-
-    describe "with required => true" do
-      context "and a single element" do
-        let(:required_strings) { ["foo"] }
-
-        it "should return the single value" do
-          expect(subject.required_strings).to eql(required_strings)
-        end
-      end
-
-      context "with an empty list" do
-        let (:required_strings) { [] }
-
-        it "should raise a configuration error" do
-          expect { subject.required_strings }.to raise_error(LogStash::ConfigurationError)
-        end        
-      end
-
-      context "with no value specified" do
-        let (:required_strings) { nil }
-
-        it "should raise a configuration error" do
-          expect { subject.required_strings }.to raise_error(LogStash::ConfigurationError)
-        end
-      end          
-    end
-  end
-
   context "when validating :password" do
     let(:klass) do
       Class.new(LogStash::Filters::Base)  do
@@ -170,95 +102,6 @@ describe LogStash::Config::Mixin do
     end
   end
 
-  context "when validating :uri" do
-    let(:klass) do
-      Class.new(LogStash::Filters::Base)  do
-        config_name "fakeuri"
-        config :uri, :validate => :uri
-      end
-    end
-
-    shared_examples("safe URI") do |options|
-      options ||= {}
-      
-      subject { klass.new("uri" => uri_str) }
-
-      it "should be a SafeURI object" do
-        expect(subject.uri).to(be_a(LogStash::Util::SafeURI))
-      end
-
-      it "should correctly copy URI types" do
-        clone = subject.class.new(subject.params)
-        expect(clone.uri.to_s).to eql(uri_hidden)
-      end
-
-      it "should make the real URI object availale under #uri" do
-        expect(subject.uri.uri).to be_a(::URI)
-      end
-
-      it "should obfuscate original_params" do
-        expect(subject.original_params['uri']).to(be_a(LogStash::Util::SafeURI))
-      end
-
-      if !options[:exclude_password_specs]
-        describe "passwords" do
-          it "should make password values hidden with #to_s" do
-            expect(subject.uri.to_s).to eql(uri_hidden)
-          end
-
-          it "should make password values hidden with #inspect" do
-            expect(subject.uri.inspect).to eql(uri_hidden)
-          end
-        end
-      end
-
-      context "attributes" do
-        [:scheme, :user, :password, :hostname, :path].each do |attr|
-          it "should make #{attr} available" do
-            expect(subject.uri.send(attr)).to eql(self.send(attr))
-          end
-        end
-      end
-    end
-
-    context "with a host:port combination" do
-      let(:scheme) { nil }
-      let(:user) { nil }
-      let(:password) { nil }
-      let(:hostname) { "myhostname" }
-      let(:port) { 1234 }
-      let(:path) { "" }
-      let(:uri_str) { "#{hostname}:#{port}" }
-      let(:uri_hidden) { "//#{hostname}:#{port}" }
-
-      include_examples("safe URI", :exclude_password_specs => true)
-    end
-
-    context "with a username / password" do
-      let(:scheme) { "myscheme" }
-      let(:user) { "myuser" }
-      let(:password) { "fancypants" }
-      let(:hostname) { "myhostname" }
-      let(:path) { "/my/path" }
-      let(:uri_str) { "#{scheme}://#{user}:#{password}@#{hostname}#{path}" }
-      let(:uri_hidden) { "#{scheme}://#{user}:#{LogStash::Util::SafeURI::PASS_PLACEHOLDER}@#{hostname}#{path}" }
-
-      include_examples("safe URI")
-    end
-
-    context "without a username / password" do
-      let(:scheme) { "myscheme" }
-      let(:user) { nil }
-      let(:password) { nil }
-      let(:hostname) { "myhostname" }
-      let(:path) { "/my/path" }
-      let(:uri_str) { "#{scheme}://#{hostname}#{path}" }
-      let(:uri_hidden) { "#{scheme}://#{hostname}#{path}" }
-
-      include_examples("safe URI")
-    end
-  end
-
   describe "obsolete settings" do
     let(:plugin_class) do
       Class.new(LogStash::Inputs::Base) do

data/spec/logstash/filter_delegator_spec.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+require "spec_helper"
+require "logstash/filter_delegator"
+require "logstash/instrument/null_metric"
+require "logstash/event"
+
+describe LogStash::FilterDelegator do
+  let(:logger) { double(:logger) }
+  let(:filter_id) { "my-filter" }
+  let(:config) do
+    { "host" => "127.0.0.1", "id" => filter_id }
+  end
+  let(:metric) { LogStash::Instrument::NullMetric.new }
+  let(:events) { [LogStash::Event.new, LogStash::Event.new] }
+
+  before :each do
+    allow(metric).to receive(:namespace).with(anything).and_return(metric)
+  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, 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, 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(metric).to receive(:increment).with(:out, 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
+      it "doesn't increment out" do
+        expect(metric).to receive(:increment).with(:in, events.size)
+        expect(metric).not_to receive(:increment)
+
+        subject.multi_filter(events)
+      end
+    end
+
+    context "when the fitler 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
+
+      it "increments the in/out of the metric" do
+        expect(metric).to receive(:increment).with(:in, events.size)
+        expect(metric).to receive(:increment).with(:out, 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
+
+    it "doesnt define a flush method" do
+      expect(subject.respond_to?(:flush)).to be_falsey
+    end
+
+    it "increments the in/out of the metric" do
+      expect(metric).to receive(:increment).with(:in, events.size)
+      expect(metric).to receive(:increment).with(:out, 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::FilterDelegator::DELEGATED_METHODS.each do |method|
+      it "delegate method: `#{method}` to the filter" do
+        expect(subject.respond_to?(method))
+      end
+    end
+  end
+end

data/spec/logstash/inputs/metrics_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require "logstash/inputs/metrics"
+require "spec_helper"
+
+describe LogStash::Inputs::Metrics do
+  before :each do
+    LogStash::Instrument::Collector.instance.clear
+  end
+
+  let(:queue) { [] }
+
+  describe "#run" do
+    it "should register itself to the collector observer" do
+      expect(LogStash::Instrument::Collector.instance).to receive(:add_observer).with(subject)
+      t = Thread.new { subject.run(queue) }
+      sleep(0.1) # give a bit of time to the thread to start
+      subject.stop
+    end
+  end
+
+  describe "#update" do
+    let(:namespaces)  { [:root, :base] }
+    let(:key)        { :foo }
+    let(:metric_store) { LogStash::Instrument::MetricStore.new }
+
+    it "should fill up the queue with received events" do
+      Thread.new { subject.run(queue) }
+      sleep(0.1)
+      subject.stop
+
+      metric_store.fetch_or_store(namespaces, key, LogStash::Instrument::MetricType::Counter.new(namespaces, key))
+      subject.update(LogStash::Instrument::Snapshot.new(metric_store))
+      expect(queue.count).to eq(1)
+    end
+  end
+
+  describe "#stop" do
+    it "should remove itself from the the collector observer" do
+      expect(LogStash::Instrument::Collector.instance).to receive(:delete_observer).with(subject)
+      t = Thread.new { subject.run(queue) }
+      sleep(0.1) # give a bit of time to the thread to start
+      subject.stop
+    end
+
+    it "should unblock the input" do
+      t = Thread.new { subject.run(queue) }
+      sleep(0.1) # give a bit of time to the thread to start
+      subject.do_stop
+      wait_for { t.status }.to be_falsey
+    end
+  end
+end

data/spec/logstash/instrument/collector_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require "logstash/instrument/collector"
+require "spec_helper"
+
+describe LogStash::Instrument::Collector do
+  subject { LogStash::Instrument::Collector.instance }
+  describe "#push" do
+    let(:namespaces_path) { [:root, :pipelines, :pipelines01] }
+    let(:key) { :my_key }
+
+    context "when the `MetricType` exist" do
+      it "store the metric of type `counter`" do
+        subject.push(namespaces_path, key, :counter, :increment)
+      end
+    end
+
+    context "when the `MetricType` doesn't exist" do
+      let(:wrong_type) { :donotexist }
+
+      it "logs an error but dont crash" do
+        expect(subject.logger).to receive(:error)
+          .with("Collector: Cannot create concrete class for this metric type",
+        hash_including({ :type => wrong_type, :namespaces_path => namespaces_path }))
+
+          subject.push(namespaces_path, key, wrong_type, :increment)
+      end
+    end
+
+    context "when there is a conflict with the metric key" do
+      let(:conflicting_namespaces) { [namespaces_path, key].flatten }
+
+      it "logs an error but dont crash" do
+        subject.push(namespaces_path, key, :counter, :increment)
+
+        expect(subject.logger).to receive(:error)
+          .with("Collector: Cannot record metric",
+          hash_including({ :exception => instance_of(LogStash::Instrument::MetricStore::NamespacesExpectedError) }))
+
+          subject.push(conflicting_namespaces, :random_key, :counter, :increment)
+      end
+    end
+  end
+
+  describe "#snapshot_metric" do
+    it "return a `LogStash::Instrument::MetricStore`" do
+      expect(subject.snapshot_metric).to be_kind_of(LogStash::Instrument::Snapshot)
+    end
+  end
+end