logstash-core 5.0.2-java → 5.1.1.1-java

data/lib/logstash/util/wrapped_synchronous_queue.rb

@@ -5,8 +5,8 @@ module LogStash; module Util
     java_import java.util.concurrent.SynchronousQueue
     java_import java.util.concurrent.TimeUnit
 
-    def initialize()
-      @queue = java.util.concurrent.SynchronousQueue.new()
+    def initialize
+      @queue = java.util.concurrent.SynchronousQueue.new
     end
 
     # Push an object to the queue if the queue is full
@@ -30,7 +30,7 @@ module LogStash; module Util
 
     # Blocking
     def take
-      @queue.take()
+      @queue.take
     end
 
     # Block for X millis
@@ -42,16 +42,20 @@ module LogStash; module Util
       WriteClient.new(self)
     end
 
-    def read_client()
+    def read_client
       ReadClient.new(self)
     end
 
+    def close
+      # ignore
+    end
+
     class ReadClient
       # We generally only want one thread at a time able to access pop/take/poll operations
       # from this queue. We also depend on this to be able to block consumers while we snapshot
       # in-flight buffers
 
-      def initialize(queue, batch_size = 125, wait_for = 5)
+      def initialize(queue, batch_size = 125, wait_for = 250)
         @queue = queue
         @mutex = Mutex.new
         # Note that @infilght_batches as a central mechanism for tracking inflight
@@ -64,6 +68,10 @@ module LogStash; module Util
         @wait_for = wait_for
       end
 
+      def close
+        # noop, compat with acked queue read client
+      end
+
       def set_batch_dimensions(batch_size, wait_for)
         @batch_size = batch_size
         @wait_for = wait_for
@@ -145,8 +153,6 @@ module LogStash; module Util
 
     class ReadBatch
       def initialize(queue, size, wait)
-        @shutdown_signal_received = false
-        @flush_signal_received = false
         @originals = Hash.new
 
         # TODO: disabled for https://github.com/elastic/logstash/issues/6055 - will have to properly refactor
@@ -210,14 +216,6 @@ module LogStash; module Util
         # @cancelled.size
       end
 
-      def shutdown_signal_received?
-        @shutdown_signal_received
-      end
-
-      def flush_signal_received?
-        @flush_signal_received
-      end
-
       private
 
       def iterating?
@@ -231,24 +229,10 @@ module LogStash; module Util
 
       def take_originals_from_queue(queue, size, wait)
         size.times do |t|
-          event = (t == 0) ? queue.take : queue.poll(wait)
-          if event.nil?
-            # queue poll timed out
-            next
-          elsif event.is_a?(LogStash::SignalEvent)
-            # We MUST break here. If a batch consumes two SHUTDOWN events
-            # then another worker may have its SHUTDOWN 'stolen', thus blocking
-            # the pipeline.
-            @shutdown_signal_received = event.shutdown?
-
-            # See comment above
-            # We should stop doing work after flush as well.
-            @flush_signal_received = event.flush?
-
-            break
-          else
-            @originals[event] = true
-          end
+          event = queue.poll(wait)
+          return if event.nil? # queue poll timed out
+
+          @originals[event] = true
         end
       end
     end

data/lib/logstash/version.rb

@@ -11,4 +11,4 @@
 #       eventually this file should be in the root logstash lib fir and dependencies in logstash-core should be
 #       fixed.
 
-LOGSTASH_VERSION = "5.0.2"
+LOGSTASH_VERSION = "5.1.1.1"

data/locales/en.yml

@@ -246,7 +246,7 @@ en:
         rubyshell: |+
           Drop to shell instead of running as normal.
           Valid shells are "irb" and "pry"
-        node_name: |+
+        name: |+
           Specify the name of this logstash instance, if no value is given
           it will default to the current hostname.
         agent: |+

data/logstash-core.gemspec

@@ -11,13 +11,16 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://www.elastic.co/guide/en/logstash/current/index.html"
   gem.license       = "Apache License (2.0)"
 
-  gem.files         = Dir.glob(["logstash-core.gemspec", "lib/**/*.rb", "spec/**/*.rb", "locales/*", "lib/logstash/api/init.ru", "vendor/jars/**/*.jar"])
+  gem.files         = Dir.glob(["logstash-core.gemspec", "gemspec_jars.rb", "lib/**/*.rb", "spec/**/*.rb", "locales/*", "lib/logstash/api/init.ru", "lib/logstash-core/logstash-core.jar"])
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "logstash-core"
-  gem.require_paths = ["lib", "vendor/jars"]
+  gem.require_paths = ["lib"]
   gem.version       = LOGSTASH_CORE_VERSION
 
-  gem.add_runtime_dependency "logstash-core-event-java", "5.0.2"
+  gem.platform = "java"
+
+  gem.add_runtime_dependency "logstash-core-event-java", LOGSTASH_CORE_VERSION
+  gem.add_runtime_dependency "logstash-core-queue-jruby", LOGSTASH_CORE_VERSION
 
   gem.add_runtime_dependency "pry", "~> 0.10.1"  #(Ruby license)
   gem.add_runtime_dependency "stud", "~> 0.0.19" #(Apache 2.0 license)
@@ -43,21 +46,13 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "rubyzip", "~> 1.1.7"
   gem.add_runtime_dependency "thread_safe", "~> 0.3.5" #(Apache 2.0 license)
 
-  if RUBY_PLATFORM == 'java'
-    gem.platform = RUBY_PLATFORM
-    gem.add_runtime_dependency "jrjackson", "~> 0.4.0" #(Apache 2.0 license)
-  else
-    gem.add_runtime_dependency "oj" #(MIT-style license)
-  end
-
-  if RUBY_ENGINE == "rbx"
-    # rubinius puts the ruby stdlib into gems.
-    gem.add_runtime_dependency "rubysl"
+  gem.add_runtime_dependency "jrjackson", "~> 0.4.0" #(Apache 2.0 license)
 
-    # Include racc to make the xml tests pass.
-    # https://github.com/rubinius/rubinius/issues/2632#issuecomment-26954565
-    gem.add_runtime_dependency "racc"
-  end
+  gem.add_runtime_dependency "jar-dependencies"
+  # as of Feb 3rd 2016, the ruby-maven gem is resolved to version 3.3.3 and that version
+  # has an rdoc problem that causes a bundler exception. 3.3.9 is the current latest version
+  # which does not have this problem.
+  gem.add_runtime_dependency "ruby-maven", "~> 3.3.9"
 
-  gem.add_runtime_dependency 'jar-dependencies', '~> 0.3.4'
+  eval(File.read(File.expand_path("../gemspec_jars.rb", __FILE__)))
 end

data/spec/api/lib/api/node_stats_spec.rb

@@ -14,6 +14,7 @@ describe LogStash::Api::Modules::NodeStats do
   # DSL describing response structure
   root_structure = {
     "jvm"=>{
+      "uptime_in_millis" => Numeric,
       "threads"=>{
         "count"=>Numeric,
         "peak_count"=>Numeric
@@ -68,7 +69,8 @@ describe LogStash::Api::Modules::NodeStats do
       },
       "cpu"=>{
         "total_in_millis"=>Numeric,
-        "percent"=>Numeric
+        "percent"=>Numeric,
+        "load_average" => { "1m" => Numeric }
       }
     },
    "pipeline" => {

data/spec/api/lib/api/support/resource_dsl_methods.rb

@@ -25,16 +25,16 @@ module ResourceDSLMethods
   def test_api(expected, path)
     context "GET #{path}" do
       let(:payload) { LogStash::Json.load(last_response.body) }
-      
+
       before(:all) do
         do_request { get path }
-      end      
-      
+      end
+
       it "should respond OK" do
         expect(last_response).to be_ok
       end
 
-      
+
       describe "the default metadata" do
         it "should include the host" do
           expect(payload["host"]).to eql(Socket.gethostname)
@@ -47,11 +47,19 @@ module ResourceDSLMethods
         it "should include the http address" do
           expect(payload["http_address"]).to eql("#{Socket.gethostname}:#{::LogStash::WebServer::DEFAULT_PORTS.first}")
         end
+
+        it "should include the node name" do
+          expect(payload["name"]).to eql(@runner.agent.name)
+        end
+
+        it "should include the node id" do
+          expect(payload["id"]).to eql(@runner.agent.id)
+        end
       end
-      
+
       hash_to_mapping(expected).each do |resource_path,klass|
         dotted = resource_path.join(".")
-        
+
         it "should set '#{dotted}' at '#{path}' to be a '#{klass}'" do
           expect(last_response).to be_ok # fail early if need be
           resource_path_value = resource_path.reduce(payload) do |acc,v|

data/spec/api/spec_helper.rb

@@ -5,6 +5,7 @@ require "stud/task"
 require "logstash/devutils/rspec/spec_helper"
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
 require "lib/api/support/resource_dsl_methods"
+require_relative "../support/mocks_classes"
 require 'rspec/expectations'
 require "logstash/settings"
 require 'rack/test'

data/spec/conditionals_spec.rb

@@ -26,6 +26,8 @@ describe "conditionals in output" do
   extend ConditionalFanciness
 
   class DummyNullOutput < LogStash::Outputs::Base
+    config_name "dummynull"
+
     def register
     end
     def multi_receive(events)
@@ -33,7 +35,7 @@ describe "conditionals in output" do
   end
 
   before do
-    LogStash::Registry.instance.register("logstash/outputs/dummynull", DummyNullOutput)
+    LogStash::PLUGIN_REGISTRY.add(:output, "dummynull", DummyNullOutput)
   end
 
   describe "simple" do
@@ -436,5 +438,4 @@ describe "conditionals in filter" do
       expect(subject[2].get("cond2")).to eq("true")
     end
   end
-
 end

data/spec/logstash/agent_spec.rb

@@ -3,10 +3,11 @@ require "spec_helper"
 require "stud/temporary"
 require "logstash/inputs/generator"
 require_relative "../support/mocks_classes"
+require "fileutils"
+require_relative "../support/helpers"
 
 describe LogStash::Agent do
 
-  let(:logger) { double("logger") }
   let(:agent_settings) { LogStash::SETTINGS }
   let(:agent_args) { {} }
   let(:pipeline_settings) { agent_settings.clone }
@@ -14,15 +15,12 @@ describe LogStash::Agent do
   let(:config_file) { Stud::Temporary.pathname }
   let(:config_file_txt) { "input { generator { count => 100000 } } output { }" }
 
-  subject { LogStash::Agent.new(agent_settings) }
+    subject { LogStash::Agent.new(agent_settings) }
 
   before :each do
-    [:info, :warn, :error, :fatal, :debug].each do |level|
-      allow(logger).to receive(level)
-    end
-    [:info?, :warn?, :error?, :fatal?, :debug?].each do |level|
-      allow(logger).to receive(level)
-    end
+    # This MUST run first, before `subject` is invoked to ensure clean state
+    clear_data_dir
+
     File.open(config_file, "w") { |f| f.puts config_file_txt }
     agent_args.each do |key, value|
       agent_settings.set(key, value)
@@ -31,7 +29,6 @@ describe LogStash::Agent do
     pipeline_args.each do |key, value|
       pipeline_settings.set(key, value)
     end
-    #subject.logger = logger
   end
 
   after :each do
@@ -40,7 +37,7 @@ describe LogStash::Agent do
   end
 
   it "fallback to hostname when no name is provided" do
-    expect(LogStash::Agent.new.node_name).to eq(Socket.gethostname)
+    expect(LogStash::Agent.new.name).to eq(Socket.gethostname)
   end
 
   describe "register_pipeline" do
@@ -58,13 +55,27 @@ describe LogStash::Agent do
     it "should delegate settings to new pipeline" do
       expect(LogStash::Pipeline).to receive(:new) do |arg1, arg2|
         expect(arg1).to eq(config_string)
-	expect(arg2.to_hash).to include(agent_args)
+        expect(arg2.to_hash).to include(agent_args)
       end
       subject.register_pipeline(pipeline_id, agent_settings)
     end
   end
 
-  describe "#execute" do
+  describe "#id" do
+    let(:config_file_txt) { "" }
+    let(:id_file_data) { File.open(subject.id_path) {|f| f.read } }
+
+    it "should return a UUID" do
+      expect(subject.id).to be_a(String)
+      expect(subject.id.size).to be > 0
+    end
+
+    it "should write out the persistent UUID" do
+      expect(id_file_data).to eql(subject.id)
+    end
+  end
+
+    describe "#execute" do
     let(:config_file_txt) { "input { generator { count => 100000 } } output { }" }
 
     before :each do
@@ -102,7 +113,7 @@ describe LogStash::Agent do
         end
       end
 
-      context "when calling reload_state!" do
+      context "when calling reload_pipeline!" do
         context "with a config that contains reload incompatible plugins" do
           let(:second_pipeline_config) { "input { stdin {} } filter { } output { }" }
 
@@ -111,7 +122,7 @@ describe LogStash::Agent do
             sleep 0.01 until subject.running_pipelines? && subject.pipelines.values.first.ready?
             expect(subject).to_not receive(:upgrade_pipeline)
             File.open(config_file, "w") { |f| f.puts second_pipeline_config }
-            subject.send(:reload_state!)
+            subject.send(:"reload_pipeline!", "main")
             sleep 0.1
             Stud.stop!(t)
             t.join
@@ -127,7 +138,45 @@ describe LogStash::Agent do
             sleep 0.01 until subject.running_pipelines? && subject.pipelines.values.first.ready?
             expect(subject).to receive(:upgrade_pipeline).once.and_call_original
             File.open(config_file, "w") { |f| f.puts second_pipeline_config }
-            subject.send(:reload_state!)
+            subject.send(:"reload_pipeline!", "main")
+            sleep 0.1
+            Stud.stop!(t)
+            t.join
+
+            subject.shutdown
+          end
+        end
+
+      end
+      context "when calling reload_state!" do
+        context "with a pipeline with auto reloading turned off" do
+          let(:second_pipeline_config) { "input { generator { } } filter { } output { }" }
+          let(:pipeline_args) { { "config.reload.automatic" => false } }
+
+          it "does not try to reload the pipeline" do
+            t = Thread.new { subject.execute }
+            sleep 0.01 until subject.running_pipelines? && subject.pipelines.values.first.ready?
+            expect(subject).to_not receive(:reload_pipeline!)
+            File.open(config_file, "w") { |f| f.puts second_pipeline_config }
+            subject.reload_state!
+            sleep 0.1
+            Stud.stop!(t)
+            t.join
+
+            subject.shutdown
+          end
+        end
+
+        context "with a pipeline with auto reloading turned on" do
+          let(:second_pipeline_config) { "input { generator { } } filter { } output { }" }
+          let(:pipeline_args) { { "config.reload.automatic" => true } }
+
+          it "tries to reload the pipeline" do
+            t = Thread.new { subject.execute }
+            sleep 0.01 until subject.running_pipelines? && subject.pipelines.values.first.ready?
+            expect(subject).to receive(:reload_pipeline!).once.and_call_original
+            File.open(config_file, "w") { |f| f.puts second_pipeline_config }
+            subject.reload_state!
             sleep 0.1
             Stud.stop!(t)
             t.join
@@ -155,9 +204,9 @@ describe LogStash::Agent do
       context "if state is clean" do
         it "should periodically reload_state" do
           allow(subject).to receive(:clean_state?).and_return(false)
-          expect(subject).to receive(:reload_state!).at_least(3).times
           t = Thread.new { subject.execute }
           sleep 0.01 until subject.running_pipelines? && subject.pipelines.values.first.ready?
+          expect(subject).to receive(:reload_state!).at_least(2).times
           sleep 0.1
           Stud.stop!(t)
           t.join
@@ -205,7 +254,8 @@ describe LogStash::Agent do
     let(:second_pipeline_config) { "input { generator {} } filter { } output { }" }
     let(:pipeline_args) { {
       "config.string" => first_pipeline_config,
-      "pipeline.workers" => 4
+      "pipeline.workers" => 4,
+      "config.reload.automatic" => true
     } }
 
     before(:each) do
@@ -216,14 +266,14 @@ describe LogStash::Agent do
       it "upgrades the state" do
         expect(subject).to receive(:fetch_config).and_return(second_pipeline_config)
         expect(subject).to receive(:upgrade_pipeline).with(pipeline_id, kind_of(LogStash::Pipeline))
-        subject.send(:reload_state!)
+        subject.reload_state!
       end
     end
     context "when fetching the same state" do
       it "doesn't upgrade the state" do
         expect(subject).to receive(:fetch_config).and_return(first_pipeline_config)
         expect(subject).to_not receive(:upgrade_pipeline)
-        subject.send(:reload_state!)
+        subject.reload_state!
       end
     end
   end
@@ -268,6 +318,10 @@ describe LogStash::Agent do
       subject.register_pipeline(pipeline_id, pipeline_settings)
     end
 
+    after(:each) do
+      subject.shutdown
+    end
+
     context "when the upgrade fails" do
       before :each do
         allow(subject).to receive(:fetch_config).and_return(new_pipeline_config)
@@ -276,14 +330,14 @@ describe LogStash::Agent do
       end
 
       it "leaves the state untouched" do
-        subject.send(:reload_state!)
+        subject.send(:"reload_pipeline!", pipeline_id)
         expect(subject.pipelines[pipeline_id].config_str).to eq(pipeline_config)
       end
 
       context "and current state is empty" do
         it "should not start a pipeline" do
           expect(subject).to_not receive(:start_pipeline)
-          subject.send(:reload_state!)
+          subject.send(:"reload_pipeline!", pipeline_id)
         end
       end
     end
@@ -293,15 +347,16 @@ describe LogStash::Agent do
       before :each do
         allow(subject).to receive(:fetch_config).and_return(new_config)
         allow(subject).to receive(:stop_pipeline)
+        allow(subject).to receive(:start_pipeline)
       end
       it "updates the state" do
-        subject.send(:reload_state!)
+        subject.send(:"reload_pipeline!", pipeline_id)
         expect(subject.pipelines[pipeline_id].config_str).to eq(new_config)
       end
       it "starts the pipeline" do
         expect(subject).to receive(:stop_pipeline)
         expect(subject).to receive(:start_pipeline)
-        subject.send(:reload_state!)
+        subject.send(:"reload_pipeline!", pipeline_id)
       end
     end
   end
@@ -330,41 +385,45 @@ describe LogStash::Agent do
 
 
   context "metrics after config reloading" do
-    let(:config) { "input { generator { } } output { dummyoutput { } }" }
-    let(:config_path) do
+    let!(:config) { "input { generator { } } output { dummyoutput { } }" }
+    let!(:config_path) do
       f = Stud::Temporary.file
       f.write(config)
+      f.fsync
       f.close
       f.path
     end
-    let(:interval) { 0.2 }
     let(:pipeline_args) do
       {
-        "pipeline.workers" => 4,
+        "pipeline.workers" => 2,
         "path.config" => config_path
       }
     end
 
     let(:agent_args) do
-      super.merge({ "config.reload.automatic" => true,
-                    "config.reload.interval" => interval,
-                    "metric.collect" => true })
+      {
+        "config.reload.automatic" => false,
+        "pipeline.batch.size" => 1,
+        "metric.collect" => true
+      }
     end
 
     # We need to create theses dummy classes to know how many
     # events where actually generated by the pipeline and successfully send to the output.
     # Theses values are compared with what we store in the metric store.
-    let!(:dummy_output) { DummyOutput.new }
-    let!(:dummy_output2) { DummyOutput.new }
-    class DummyOutput2 < LogStash::Outputs::Base; end
+    class DummyOutput2 < LogStash::Outputs::DroppingDummyOutput; end
+
+    let!(:dummy_output) { LogStash::Outputs::DroppingDummyOutput.new }
+    let!(:dummy_output2) { DummyOutput2.new }
+    let(:initial_generator_threshold) { 1000 }
 
     before :each do
-      allow(DummyOutput).to receive(:new).at_least(:once).with(anything).and_return(dummy_output)
+      allow(LogStash::Outputs::DroppingDummyOutput).to receive(:new).at_least(:once).with(anything).and_return(dummy_output)
       allow(DummyOutput2).to receive(:new).at_least(:once).with(anything).and_return(dummy_output2)
 
       allow(LogStash::Plugin).to receive(:lookup).with("input", "generator").and_return(LogStash::Inputs::Generator)
       allow(LogStash::Plugin).to receive(:lookup).with("codec", "plain").and_return(LogStash::Codecs::Plain)
-      allow(LogStash::Plugin).to receive(:lookup).with("output", "dummyoutput").and_return(DummyOutput)
+      allow(LogStash::Plugin).to receive(:lookup).with("output", "dummyoutput").and_return(LogStash::Outputs::DroppingDummyOutput)
       allow(LogStash::Plugin).to receive(:lookup).with("output", "dummyoutput2").and_return(DummyOutput2)
 
       @abort_on_exception = Thread.abort_on_exception
@@ -375,7 +434,8 @@ describe LogStash::Agent do
         subject.execute
       end
 
-      sleep(2)
+      # wait for some events to reach the dummy_output
+      sleep(0.01) until dummy_output.events_received > initial_generator_threshold
     end
 
     after :each do
@@ -392,43 +452,34 @@ describe LogStash::Agent do
       let(:new_config_generator_counter) { 500 }
       let(:new_config) { "input { generator { count => #{new_config_generator_counter} } } output { dummyoutput2 {} }" }
       before :each do
-        # We know that the store has more events coming in.
-        i = 0
-        while dummy_output.events.size <= new_config_generator_counter
-          i += 1
-          raise "Waiting too long!" if i > 20
-          sleep(0.1)
-        end
-
 
-        # Also force a flush to disk to make sure ruby reload it.
         File.open(config_path, "w") do |f|
           f.write(new_config)
           f.fsync
         end
 
-        sleep(interval * 3) # Give time to reload the config
+        subject.send(:"reload_pipeline!", "main")
 
-        # be eventually consistent.
-        sleep(0.01) while dummy_output2.events.size < new_config_generator_counter
+        # wait until pipeline restarts
+        sleep(0.01) until dummy_output2.events_received > 0
       end
 
       it "resets the pipeline metric collector" do
         snapshot = subject.metric.collector.snapshot_metric
         value = snapshot.metric_store.get_with_path("/stats/pipelines")[:stats][:pipelines][:main][:events][:in].value
-        expect(value).to eq(new_config_generator_counter)
+        expect(value).to be <= new_config_generator_counter
       end
 
       it "does not reset the global event count" do
         snapshot = subject.metric.collector.snapshot_metric
         value = snapshot.metric_store.get_with_path("/stats/events")[:stats][:events][:in].value
-        expect(value).to be > new_config_generator_counter
+        expect(value).to be > initial_generator_threshold
       end
 
       it "increases the successful reload count" do
         snapshot = subject.metric.collector.snapshot_metric
         value = snapshot.metric_store.get_with_path("/stats/pipelines")[:stats][:pipelines][:main][:reloads][:successes].value
-        expect(value).to be(1)
+        expect(value).to eq(1)
       end
 
       it "does not set the failure reload timestamp" do
@@ -455,28 +506,19 @@ describe LogStash::Agent do
       let(:new_config) { "input { generator { count => " }
       let(:new_config_generator_counter) { 500 }
       before :each do
-        # We know that the store has more events coming in.
-        i = 0
-        while dummy_output.events.size <= new_config_generator_counter
-          i += 1
-          raise "Waiting too long!" if i > 20
-          sleep(0.1)
-        end
 
-
-        # Also force a flush to disk to make sure ruby reload it.
         File.open(config_path, "w") do |f|
           f.write(new_config)
           f.fsync
         end
 
-        sleep(interval * 3) # Give time to reload the config
+        subject.send(:"reload_pipeline!", "main")
       end
 
       it "does not increase the successful reload count" do
         snapshot = subject.metric.collector.snapshot_metric
         value = snapshot.metric_store.get_with_path("/stats/pipelines")[:stats][:pipelines][:main][:reloads][:successes].value
-        expect(value).to be(0)
+        expect(value).to eq(0)
       end
 
       it "does not set the successful reload timestamp" do
@@ -504,5 +546,43 @@ describe LogStash::Agent do
         expect(value).to be > 0
       end
     end
+
+    context "when reloading a config that raises exception on pipeline.run" do
+      let(:new_config) { "input { generator { count => 10000 } }" }
+      let(:new_config_generator_counter) { 500 }
+
+      class BrokenGenerator < LogStash::Inputs::Generator
+        def register
+          raise ArgumentError
+        end
+      end
+
+      before :each do
+
+        allow(LogStash::Plugin).to receive(:lookup).with("input", "generator").and_return(BrokenGenerator)
+
+        File.open(config_path, "w") do |f|
+          f.write(new_config)
+          f.fsync
+        end
+
+      end
+
+      it "does not increase the successful reload count" do
+        expect { subject.send(:"reload_pipeline!", "main") }.to_not change {
+          snapshot = subject.metric.collector.snapshot_metric
+          reload_metrics = snapshot.metric_store.get_with_path("/stats/pipelines")[:stats][:pipelines][:main][:reloads]
+          reload_metrics[:successes].value
+        }
+      end
+
+      it "increases the failured reload count" do
+        expect { subject.send(:"reload_pipeline!", "main") }.to change {
+          snapshot = subject.metric.collector.snapshot_metric
+          reload_metrics = snapshot.metric_store.get_with_path("/stats/pipelines")[:stats][:pipelines][:main][:reloads]
+          reload_metrics[:failures].value
+        }.by(1)
+      end
+    end
   end
 end