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

data/lib/logstash/util/environment_variables.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module ::LogStash::Util::EnvironmentVariables
+
+  ENV_PLACEHOLDER_REGEX = /\${(?<name>[a-zA-Z_.][a-zA-Z0-9_.]*)(:(?<default>[^}]*))?}/
+
+  # Recursive method to replace environment variable references in parameters
+  def deep_replace(value)
+    if value.is_a?(Hash)
+      value.each do |valueHashKey, valueHashValue|
+        value[valueHashKey.to_s] = deep_replace(valueHashValue)
+      end
+    else
+      if value.is_a?(Array)
+        value.each_index do | valueArrayIndex|
+          value[valueArrayIndex] = deep_replace(value[valueArrayIndex])
+        end
+      else
+        return replace_env_placeholders(value)
+      end
+    end
+  end
+
+  # Replace all environment variable references in 'value' param by environment variable value and return updated value
+  # Process following patterns : $VAR, ${VAR}, ${VAR:defaultValue}
+  def replace_env_placeholders(value)
+    return value unless value.is_a?(String)
+
+    value.gsub(ENV_PLACEHOLDER_REGEX) do |placeholder|
+      # Note: Ruby docs claim[1] Regexp.last_match is thread-local and scoped to
+      # the call, so this should be thread-safe.
+      #
+      # [1] http://ruby-doc.org/core-2.1.1/Regexp.html#method-c-last_match
+      name = Regexp.last_match(:name)
+      default = Regexp.last_match(:default)
+
+      replacement = ENV.fetch(name, default)
+      if replacement.nil?
+        raise LogStash::ConfigurationError, "Cannot evaluate `#{placeholder}`. Environment variable `#{name}` is not set and there is no default value given."
+      end
+      replacement
+    end
+  end # def replace_env_placeholders
+end

data/lib/logstash/util/thread_dump.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+java_import 'org.logstash.instrument.reports.ThreadsReport'
+
 module LogStash
   module Util
     class ThreadDump
@@ -10,7 +12,7 @@ module LogStash
 
       def initialize(options={})
         @options   = options
-        @dump = options.fetch(:dump, JRMonitor.threads.generate({}))
+        @dump = options.fetch(:dump, ThreadsReport.generate({}))
         @top_count = options.fetch(:threads, THREADS_COUNT_DEFAULT)
         @ignore    = options.fetch(:ignore_idle_threads, IGNORE_IDLE_THREADS_DEFAULT)
       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 = "6.0.0-alpha1"
+LOGSTASH_VERSION = "6.0.0-alpha2"

data/locales/en.yml

@@ -98,8 +98,12 @@ en:
       missing-configuration: >-
         No configuration file was specified. Perhaps you forgot to provide
         the '-f yourlogstash.conf' flag?
+      config-string-path-exclusive:
+        Settings 'path.config' (-f) and 'config.string' (-e) can't be used simultaneously.
       reload-without-config-path: >-
         Configuration reloading also requires passing a configuration path with '-f yourlogstash.conf'
+      reload-with-config-string: >-
+        Configuration reloading can't be used with 'config.string' (-e).
       locked-data-path: >-
         Logstash could not be started because there is already another instance using the configured data directory.  If you wish to run multiple instances, you must change the "path.data" setting.
       invalid-shell: >-

data/logstash-core.gemspec

@@ -25,11 +25,14 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "filesize", "0.0.4" #(MIT license) for :bytes config validator
   gem.add_runtime_dependency "gems", "~> 0.8.3"  #(MIT license)
   gem.add_runtime_dependency "concurrent-ruby", "1.0.0"
+
+  # Later versions are ruby 2.0 only. We should remove the rack dep once we support 9k
+  gem.add_runtime_dependency "rack", '1.6.6'
+  
   gem.add_runtime_dependency "sinatra", '~> 1.4', '>= 1.4.6'
   gem.add_runtime_dependency 'puma', '~> 2.16'
   gem.add_runtime_dependency "jruby-openssl", "0.9.16" # >= 0.9.13 Required to support TLSv1.2
   gem.add_runtime_dependency "chronic_duration", "0.10.6"
-  gem.add_runtime_dependency "jrmonitor", '~> 0.4.2'
 
   # TODO(sissel): Treetop 1.5.x doesn't seem to work well, but I haven't
   # investigated what the cause might be. -Jordan

data/spec/logstash/agent/converge_spec.rb

@@ -26,18 +26,6 @@ describe LogStash::Agent do
     expect(converge_result).to be_a_successful_converge
   end
 
-
-  describe "passing the agent to the pipeline" do
-    let(:source_loader) { TestSourceLoader.new(pipeline_config) }
-    let(:pipeline_config) { mock_pipeline_config(:main, "input { generator { count => 10 } } output { null {} }") }
-      
-    before { subject.execute }
-
-    it "execute the pipeline and stop execution" do
-      expect(subject.get_pipeline(:main).execution_context.agent).to eq(subject)
-    end
-  end
-
   context "Agent execute options" do
     let(:source_loader) do
       TestSourceLoader.new(finite_pipeline_config)
@@ -60,33 +48,46 @@ describe LogStash::Agent do
     end
 
     context "system pipeline" do
-      let(:finite_pipeline_config) { mock_pipeline_config(:main, "input { generator { count => 1000 } } output { null {} }") }
+      
       let(:system_pipeline_config) { mock_pipeline_config(:system_pipeline, "input { generator { } } output { null {} }", { "pipeline.system" => true }) }
 
-      let(:source_loader) do
-        TestSourceLoader.new(finite_pipeline_config, system_pipeline_config)
-      end
-
       context "when we have a finite pipeline and a system pipeline running" do
+
+        let(:finite_pipeline_config) { mock_pipeline_config(:main, "input { generator { count => 1000 } } output { null {} }") }
+
+        let(:source_loader) do
+          TestSourceLoader.new(finite_pipeline_config, system_pipeline_config)
+        end
+
         it "execute the pipeline and stop execution" do
           expect(subject.execute).to eq(0)
         end
       end
 
-      describe "#running_user_defined_pipelines" do
-        it "returns the user defined pipelines" do
-          agent_task = start_agent(subject)
-          expect(subject.running_user_defined_pipelines.keys).to include(:main)
-          expect(subject.running_user_defined_pipelines.keys).not_to include(:system_pipeline)
-          subject.shutdown
+      context "when we have an infinite pipeline and a system pipeline running" do
+        let(:infinite_pipeline_config) { mock_pipeline_config(:main, "input { generator { } } output { null {} }") }
+
+        let(:source_loader) do
+          TestSourceLoader.new(infinite_pipeline_config, system_pipeline_config)
         end
-      end
 
-      describe "#running_user_defined_pipelines?" do
-        it "returns true" do
-          agent_task = start_agent(subject)
-          expect(subject.running_user_defined_pipelines?).to be_truthy
-          subject.shutdown
+        describe "#running_user_defined_pipelines" do
+          it "returns the user defined pipelines" do
+            start_agent(subject)
+            subject.with_running_user_defined_pipelines do |pipelines|
+              expect(pipelines).to include(:main)
+              expect(pipelines).not_to include(:system_pipeline)
+            end
+            subject.shutdown
+          end
+        end
+
+        describe "#running_user_defined_pipelines?" do
+          it "returns true" do
+            start_agent(subject)
+            expect(subject.running_user_defined_pipelines?).to be_truthy
+            subject.shutdown
+          end
         end
       end
     end
@@ -186,7 +187,7 @@ describe LogStash::Agent do
 
     it "stops the running pipelines" do
       expect(subject.converge_state_and_update).to be_a_successful_converge
-      expect { subject.shutdown }.to change { subject.running_pipelines.size }.from(2).to(0)
+      expect { subject.shutdown }.to change { subject.running_pipelines_count }.from(2).to(0)
     end
   end
 
@@ -207,7 +208,7 @@ describe LogStash::Agent do
       it "creates and starts the new pipeline" do
         expect {
           expect(subject.converge_state_and_update).to be_a_successful_converge
-        }.to change { subject.running_pipelines.count }.from(0).to(1)
+        }.to change { subject.running_pipelines_count }.from(0).to(1)
         expect(subject).to have_running_pipeline?(pipeline_config)
       end
     end
@@ -224,7 +225,7 @@ describe LogStash::Agent do
         it "start a new pipeline and keep the original" do
           expect {
             expect(subject.converge_state_and_update).to be_a_successful_converge
-          }.to change { subject.running_pipelines.count }.from(1).to(2)
+          }.to change { subject.running_pipelines_count }.from(1).to(2)
           expect(subject).to have_running_pipeline?(pipeline_config)
           expect(subject).to have_running_pipeline?(new_pipeline_config)
         end
@@ -241,7 +242,7 @@ describe LogStash::Agent do
         it "stops the missing pipeline and start the new one" do
           expect {
             expect(subject.converge_state_and_update).to be_a_successful_converge
-          }.not_to change { subject.running_pipelines.count }
+          }.not_to change { subject.running_pipelines_count }
           expect(subject).not_to have_pipeline?(pipeline_config)
           expect(subject).to have_running_pipeline?(new_pipeline_config)
         end
@@ -261,7 +262,7 @@ describe LogStash::Agent do
       it "reloads the modified pipeline" do
         expect {
           expect(subject.converge_state_and_update).to be_a_successful_converge
-        }.not_to change { subject.running_pipelines.count }
+        }.not_to change { subject.running_pipelines_count }
         expect(subject).to have_running_pipeline?(modified_pipeline_config)
         expect(subject).not_to have_pipeline?(pipeline_config)
       end
@@ -278,7 +279,7 @@ describe LogStash::Agent do
       it "stops all the pipelines" do
         expect {
           expect(subject.converge_state_and_update).to be_a_successful_converge
-        }.to change { subject.running_pipelines.count }.from(2).to(0)
+        }.to change { subject.running_pipelines_count }.from(2).to(0)
         expect(subject).not_to have_pipeline?(pipeline_config)
       end
     end

data/spec/logstash/agent_spec.rb

@@ -10,18 +10,20 @@ require_relative "../support/helpers"
 require_relative "../support/matchers"
 
 describe LogStash::Agent do
-  let(:agent_settings) { mock_settings("config.string" => "input {}") }
-  let(:default_pipeline_id) { LogStash::SETTINGS.get("pipeline.id") }
+  let(:agent_settings) { mock_settings({}) }
   let(:agent_args) { {} }
   let(:pipeline_settings) { agent_settings.clone }
   let(:pipeline_args) { {} }
+  let(:default_pipeline_id) { agent_settings.get("pipeline.id") }
+  let(:config_string) { "input { } filter { } output { }" }
   let(:config_file) { Stud::Temporary.pathname }
-  let(:config_file_txt) { "input { generator { id => 'initial' } } output { }" }
+  let(:config_file_txt) { config_string }
   let(:default_source_loader) do
     sl = LogStash::Config::SourceLoader.new
     sl.add_source(LogStash::Config::Source::Local.new(agent_settings))
     sl
   end
+  let(:logger) { double("logger") }
 
   subject { LogStash::Agent.new(agent_settings, default_source_loader) }
 
@@ -38,31 +40,24 @@ describe LogStash::Agent do
     pipeline_args.each do |key, value|
       pipeline_settings.set(key, value)
     end
+    allow(described_class).to receive(:logger).and_return(logger)
+    [:debug, :info, :error, :fatal, :trace].each {|level| allow(logger).to receive(level) }
+    [:debug?, :info?, :error?, :fatal?, :trace?].each {|level| allow(logger).to receive(level) }
   end
 
   after :each do
+    subject.shutdown
     LogStash::SETTINGS.reset
     File.unlink(config_file)
+    File.unlink(subject.id_path)
   end
 
   it "fallback to hostname when no name is provided" do
     expect(LogStash::Agent.new(agent_settings, default_source_loader).name).to eq(Socket.gethostname)
   end
 
-  after(:each) do
-    subject.shutdown # shutdown/close the pipelines
-  end
-
   describe "adding a new pipeline" do
-    let(:config_string) { "input { } filter { } output { }" }
-    let(:agent_args) do
-      {
-        "config.string" => config_string,
-        "config.reload.automatic" => true,
-        "config.reload.interval" => 0.01,
-        "pipeline.workers" => 4,
-      }
-    end
+    let(:agent_args) { { "config.string" => config_string } }
 
     it "should delegate settings to new pipeline" do
       expect(LogStash::Pipeline).to receive(:new) do |arg1, arg2|
@@ -74,7 +69,6 @@ describe LogStash::Agent do
   end
 
   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
@@ -88,8 +82,8 @@ describe LogStash::Agent do
   end
 
   describe "#execute" do
-    let(:config_file_txt) { "input { generator { id => 'old'} } output { }" }
-    let(:mock_config_pipeline) { mock_pipeline_config(:main, config_file_txt, pipeline_settings) }
+    let(:config_string) { "input { generator { id => 'old'} } output { }" }
+    let(:mock_config_pipeline) { mock_pipeline_config(:main, config_string, pipeline_settings) }
 
     let(:source_loader) { TestSourceLoader.new(mock_config_pipeline) }
     subject { described_class.new(agent_settings, source_loader) }
@@ -100,13 +94,8 @@ describe LogStash::Agent do
     end
 
     context "when auto_reload is false" do
-      let(:agent_args) do
-        {
-          "config.reload.automatic" => false,
-          "path.config" => config_file
-        }
-      end
-
+      let(:agent_settings) { mock_settings("config.reload.automatic" => false) }
+      let(:agent_args) { { "path.config" => config_file } }
 
       context "if state is clean" do
         before :each do
@@ -118,9 +107,6 @@ describe LogStash::Agent do
           expect(subject).to receive(:converge_state_and_update).once
           t = Thread.new { subject.execute }
 
-          # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-          # a bad test design or missing class functionality.
-          sleep(0.1)
           Stud.stop!(t)
           t.join
           subject.shutdown
@@ -136,14 +122,11 @@ describe LogStash::Agent do
 
           it "does not upgrade the new config" do
             t = Thread.new { subject.execute }
-            sleep(0.1) until subject.running_pipelines? && subject.pipelines.values.first.ready?
+            sleep(0.01) until subject.with_pipelines {|pipelines| subject.running_pipelines? && pipelines.values.first.ready? }
 
             expect(subject.converge_state_and_update).not_to be_a_successful_converge
             expect(subject).to have_running_pipeline?(mock_config_pipeline)
 
-            # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-            # a bad test design or missing class functionality.
-            sleep(0.1)
             Stud.stop!(t)
             t.join
             subject.shutdown
@@ -158,14 +141,11 @@ describe LogStash::Agent do
 
           it "does upgrade the new config" do
             t = Thread.new { subject.execute }
-            sleep(0.1) until subject.pipelines_count > 0 && subject.pipelines.values.first.ready?
+            sleep(0.01) until subject.with_pipelines {|pipelines| subject.pipelines_count > 0 && pipelines.values.first.ready? }
 
             expect(subject.converge_state_and_update).to be_a_successful_converge
             expect(subject).to have_running_pipeline?(mock_second_pipeline_config)
 
-            # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-            # a bad test design or missing class functionality.
-            sleep(0.1)
             Stud.stop!(t)
             t.join
             subject.shutdown
@@ -183,14 +163,11 @@ describe LogStash::Agent do
 
           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.running?
+            sleep(0.01) until subject.with_pipelines {|pipelines| subject.running_pipelines? && pipelines.values.first.running? }
 
             expect(subject.converge_state_and_update).not_to be_a_successful_converge
             expect(subject).to have_running_pipeline?(mock_config_pipeline)
 
-            # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-            # a bad test design or missing class functionality.
-            sleep(0.1)
             Stud.stop!(t)
             t.join
             subject.shutdown
@@ -205,95 +182,16 @@ describe LogStash::Agent do
 
           it "tries to reload the pipeline" do
             t = Thread.new { subject.execute }
-            sleep(0.01) until subject.running_pipelines? && subject.pipelines.values.first.running?
+            sleep(0.01) until subject.with_pipelines {|pipelines| subject.running_pipelines? && pipelines.values.first.running? }
 
             expect(subject.converge_state_and_update).to be_a_successful_converge
             expect(subject).to have_running_pipeline?(mock_second_pipeline_config)
 
-            # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-            # a bad test design or missing class functionality.
-            sleep(0.1)
-            Stud.stop!(t)
-            t.join
-            subject.shutdown
-          end
-        end
-      end
-    end
-
-    context "when auto_reload is true" do
-      subject { described_class.new(agent_settings, default_source_loader) }
-
-      let(:agent_args) do
-        {
-          "config.string" => "",
-          "config.reload.automatic" => true,
-          "config.reload.interval" => 0.01,
-          "path.config" => config_file
-        }
-      end
-
-      context "if state is clean" do
-        it "should periodically reload_state" do
-          allow(subject).to receive(:clean_state?).and_return(false)
-          t = Thread.new { subject.execute }
-          sleep(0.05) until subject.running_pipelines? && subject.pipelines.values.first.running?
-          expect(subject).to receive(:converge_state_and_update).at_least(2).times
-
-          # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-          # a bad test design or missing class functionality.
-          sleep(0.1)
-          Stud.stop!(t)
-          t.join
-          subject.shutdown
-        end
-      end
-
-      context "when calling reload_state!" do
-        xcontext "with a config that contains reload incompatible plugins" do
-          let(:second_pipeline_config) { "input { stdin { id => '123' } } filter { } output { }" }
-
-          it "does not upgrade the new config" do
-            t = Thread.new { subject.execute }
-            sleep(0.05) until subject.running_pipelines? && subject.pipelines.values.first.running?
-            File.open(config_file, "w") { |f| f.puts second_pipeline_config }
-            sleep(0.2) # lets us catch the new file
-
-            try do
-              expect(subject.pipelines[default_pipeline_id.to_sym].config_str).not_to eq(second_pipeline_config)
-            end
-
             Stud.stop!(t)
             t.join
             subject.shutdown
           end
         end
-
-        context "with a config that does not contain reload incompatible plugins" do
-          let(:second_pipeline_config) { "input { generator { id => 'new' } } filter { } output { }" }
-
-          it "does upgrade the new config" do
-            t = Thread.new { subject.execute }
-
-            sleep(0.05) until subject.running_pipelines? && subject.pipelines.values.first.running?
-
-            File.open(config_file, "w") { |f| f.puts second_pipeline_config }
-            sleep(5) # lets us catch the new file
-
-            try do
-              expect(subject.pipelines[default_pipeline_id.to_sym]).not_to be_nil
-              expect(subject.pipelines[default_pipeline_id.to_sym].config_str).to match(second_pipeline_config)
-            end
-
-            # TODO: refactor this. forcing an arbitrary fixed delay for thread concurrency issues is an indication of
-            # a bad test design or missing class functionality.
-            sleep(0.1)
-            Stud.stop!(t)
-            t.join
-            expect(subject.get_pipeline(:main).config_str).to match(second_pipeline_config)
-            subject.shutdown
-          end
-        end
       end
     end
   end
@@ -333,7 +231,7 @@ describe LogStash::Agent do
 
         # Since the pipeline is running in another threads
         # the content of the file wont be instant.
-        sleep(0.1) until ::File.size(temporary_file) > 0
+        sleep(0.01) until ::File.size(temporary_file) > 0
         json_document = LogStash::Json.load(File.read(temporary_file).chomp)
         expect(json_document["message"]).to eq("foo-bar")
       end
@@ -365,7 +263,7 @@ describe LogStash::Agent do
     context "when the upgrade fails" do
       it "leaves the state untouched" do
         expect(subject.converge_state_and_update).not_to be_a_successful_converge
-        expect(subject.pipelines[default_pipeline_id].config_str).to eq(pipeline_config)
+        expect(subject.get_pipeline(default_pipeline_id).config_str).to eq(pipeline_config)
       end
 
       # TODO(ph): This valid?
@@ -383,12 +281,12 @@ describe LogStash::Agent do
 
       it "updates the state" do
         expect(subject.converge_state_and_update).to be_a_successful_converge
-        expect(subject.pipelines[default_pipeline_id].config_str).to eq(new_config)
+        expect(subject.get_pipeline(default_pipeline_id).config_str).to eq(new_config)
       end
 
       it "starts the pipeline" do
         expect(subject.converge_state_and_update).to be_a_successful_converge
-        expect(subject.pipelines[default_pipeline_id].running?).to be_truthy
+        expect(subject.get_pipeline(default_pipeline_id).running?).to be_truthy
       end
     end
   end
@@ -406,53 +304,39 @@ describe LogStash::Agent do
   end
 
   context "metrics after config reloading" do
+
+    let(:initial_generator_threshold) { 1000 }
     let(:temporary_file) { Stud::Temporary.file.path }
-    let(:config) { "input { generator { } } output { file { path => '#{temporary_file}' } }" }
-
-    let(:config_path) do
-      f = Stud::Temporary.file
-      f.write(config)
-      f.fsync
-      f.close
-      f.path
-    end
+    let(:config_file_txt) { "input { generator { count => #{initial_generator_threshold*2} } } output { file { path => '#{temporary_file}'} }" }
 
     let(:agent_args) do
       {
-        "config.reload.automatic" => true,
-        "config.reload.interval" => 0.01,
-        "pipeline.batch.size" => 1,
         "metric.collect" => true,
-        "path.config" => config_path
+        "path.config" => config_file
       }
     end
 
-    let(:initial_generator_threshold) { 1000 }
-    let(:pipeline_thread) do
-      Thread.new do
-        subject.execute
-      end
-    end
-
     subject { described_class.new(agent_settings, default_source_loader) }
 
-    before :each do
+    before(:each) do
       @abort_on_exception = Thread.abort_on_exception
       Thread.abort_on_exception = true
 
-      @t = Thread.new do
-        subject.execute
-      end
+      @t = Thread.new { subject.execute }
 
       # wait for some events to reach the dummy_output
-      sleep(0.1) until IO.readlines(temporary_file).size > initial_generator_threshold
+      sleep(0.01) until IO.readlines(temporary_file).size > initial_generator_threshold
+
+      # write new config
+      File.open(config_file, "w") { |f| f.write(new_config) }
     end
 
     after :each do
       begin
         subject.shutdown
-        Stud.stop!(pipeline_thread)
-        pipeline_thread.join
+        Stud.stop!(@t) rescue nil # it may be dead already
+        @t.join
+        File.unlink(temporary_file)
       ensure
         Thread.abort_on_exception = @abort_on_exception
       end
@@ -460,19 +344,19 @@ describe LogStash::Agent do
 
     context "when reloading a good config" do
       let(:new_config_generator_counter) { 500 }
-      let(:output_file) { Stud::Temporary.file.path }
-      let(:new_config) { "input { generator { count => #{new_config_generator_counter} } } output { file { path => '#{output_file}'} }" }
+      let(:new_file) { Stud::Temporary.file.path }
+      let(:new_config) { "input { generator { count => #{new_config_generator_counter} } } output { file { path => '#{new_file}'} }" }
 
       before :each do
-        File.open(config_path, "w") do |f|
-          f.write(new_config)
-          f.fsync
-        end
-
-        # wait until pipeline restarts
-        sleep(1) if ::File.read(output_file).empty?
+        subject.converge_state_and_update
+        sleep(0.01) while ::File.read(new_file).chomp.empty?
+        # ensure the converge_state_and_update method has updated metrics by
+        # invoking the mutex
+        subject.running_pipelines?
       end
 
+      after(:each) { File.unlink(new_file) }
+
       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
@@ -488,9 +372,9 @@ describe LogStash::Agent do
       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 eq(1)
         instance_value = snapshot.metric_store.get_with_path("/stats")[:stats][:reloads][:successes].value
         expect(instance_value).to eq(1)
-        expect(value).to eq(1)
       end
 
       it "does not set the failure reload timestamp" do
@@ -514,15 +398,7 @@ describe LogStash::Agent do
 
     context "when reloading a bad config" do
       let(:new_config) { "input { generator { count => " }
-      before :each do
-
-        File.open(config_path, "w") do |f|
-          f.write(new_config)
-          f.fsync
-        end
-
-        sleep(1)
-      end
+      before(:each) { subject.converge_state_and_update }
 
       it "does not increase the successful reload count" do
         snapshot = subject.metric.collector.snapshot_metric
@@ -563,7 +439,7 @@ describe LogStash::Agent do
           "config.reload.automatic" => false,
           "pipeline.batch.size" => 1,
           "metric.collect" => true,
-          "path.config" => config_path
+          "path.config" => config_file
         }
       end
 
@@ -575,11 +451,6 @@ describe LogStash::Agent do
 
       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