logstash-core 6.8.20-java → 7.0.0.alpha1-java

data/lib/logstash/instrument/periodic_poller/pq.rb

@@ -11,12 +11,14 @@ module LogStash module Instrument module PeriodicPoller
     end
 
     def collect
-      pipelines = @agent.running_user_defined_pipelines
-      pipelines.each do |_, pipeline|
-        unless pipeline.nil?
-          pipeline.collect_stats
-        end
+      pipelines = @agent.with_running_user_defined_pipelines {|pipelines| pipelines}
+      unless pipelines.nil?
+        pipelines.each {|_, pipeline|
+          unless pipeline.nil?
+            pipeline.collect_stats
+          end
+        }
       end
     end
   end
-end end end
+end; end; end

data/lib/logstash/instrument/periodic_pollers.rb

@@ -11,12 +11,12 @@ module LogStash module Instrument
   class PeriodicPollers
     attr_reader :metric
 
-    def initialize(metric, queue_type, agent)
+    def initialize(metric, queue_type, pipelines)
       @metric = metric
       @periodic_pollers = [PeriodicPoller::Os.new(metric),
                            PeriodicPoller::JVM.new(metric),
-                           PeriodicPoller::PersistentQueue.new(metric, queue_type, agent),
-                           PeriodicPoller::DeadLetterQueue.new(metric, agent)]
+                           PeriodicPoller::PersistentQueue.new(metric, queue_type, pipelines),
+                           PeriodicPoller::DeadLetterQueue.new(metric, pipelines)]
     end
 
     def start

data/lib/logstash/java_pipeline.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 require "thread"
 require "concurrent"
-require "logstash/event"
 require "logstash/filters/base"
 require "logstash/inputs/base"
 require "logstash/outputs/base"
@@ -39,23 +38,9 @@ module LogStash; class JavaPipeline < JavaBasePipeline
     @flushRequested = java.util.concurrent.atomic.AtomicBoolean.new(false)
     @shutdownRequested = java.util.concurrent.atomic.AtomicBoolean.new(false)
     @outputs_registered = Concurrent::AtomicBoolean.new(false)
-
-    # @finished_execution signals that the pipeline thread has finished its execution
-    # regardless of any exceptions; it will always be true when the thread completes
     @finished_execution = Concurrent::AtomicBoolean.new(false)
-
-    # @finished_run signals that the run methods called in the pipeline thread was completed
-    # without errors and it will NOT be set if the run method exits from an exception; this
-    # is by design and necessary for the wait_until_started semantic
-    @finished_run = Concurrent::AtomicBoolean.new(false)
-
-    @thread = nil
   end # def initialize
 
-  def finished_execution?
-    @finished_execution.true?
-  end
-
   def ready?
     @ready.value
   end
@@ -97,18 +82,15 @@ module LogStash; class JavaPipeline < JavaBasePipeline
     @logger.debug("Starting pipeline", default_logging_keys)
 
     @finished_execution.make_false
-    @finished_run.make_false
 
     @thread = Thread.new do
       begin
         LogStash::Util.set_thread_name("pipeline.#{pipeline_id}")
         run
-        @finished_run.make_true
+        @finished_execution.make_true
       rescue => e
         close
         logger.error("Pipeline aborted due to error", default_logging_keys(:exception => e, :backtrace => e.backtrace))
-      ensure
-        @finished_execution.make_true
       end
     end
 
@@ -123,14 +105,15 @@ module LogStash; class JavaPipeline < JavaBasePipeline
 
   def wait_until_started
     while true do
-      if @finished_run.true?
-        # it completed run without exception
+      # This should be changed with an appropriate FSM
+      # It's an edge case, if we have a pipeline with
+      # a generator { count => 1 } its possible that `Thread#alive?` doesn't return true
+      # because the execution of the thread was successful and complete
+      if @finished_execution.true?
         return true
       elsif thread.nil? || !thread.alive?
-        # some exception occurred and the thread is dead
         return false
       elsif running?
-        # fully initialized and running
         return true
       else
         sleep 0.01
@@ -232,11 +215,11 @@ module LogStash; class JavaPipeline < JavaBasePipeline
 
       pipeline_workers.times do |t|
         thread = Thread.new do
-          Util.set_thread_name("[#{pipeline_id}]>worker#{t}")
           org.logstash.execution.WorkerLoop.new(
               lir_execution, filter_queue_client, @events_filtered, @events_consumed,
               @flushRequested, @flushing, @shutdownRequested, @drain_queue).run
         end
+        Util.set_thread_name("[#{pipeline_id}]>worker#{t}")
         @worker_threads << thread
       end
 
@@ -257,13 +240,7 @@ module LogStash; class JavaPipeline < JavaBasePipeline
   end
 
   def wait_inputs
-    @input_threads.each do |thread|
-      if thread.class == Java::JavaObject
-        thread.to_java.join
-      else
-        thread.join
-      end
-    end
+    @input_threads.each(&:join)
   end
 
   def start_inputs
@@ -285,11 +262,7 @@ module LogStash; class JavaPipeline < JavaBasePipeline
   end
 
   def start_input(plugin)
-    if plugin.class == LogStash::JavaInputDelegator
-      @input_threads << plugin.start
-    else
-      @input_threads << Thread.new { inputworker(plugin) }
-    end
+    @input_threads << Thread.new { inputworker(plugin) }
   end
 
   def inputworker(plugin)
@@ -335,7 +308,7 @@ module LogStash; class JavaPipeline < JavaBasePipeline
 
     stop_inputs
 
-    # We make this call blocking, so we know for sure when the method return the shtudown is
+    # We make this call blocking, so we know for sure when the method return the shutdown is
     # stopped
     wait_for_workers
     clear_pipeline_metrics
@@ -399,7 +372,7 @@ module LogStash; class JavaPipeline < JavaBasePipeline
   end
 
   def plugin_threads_info
-    input_threads = @input_threads.select {|t| t.class == Thread && t.alive? }
+    input_threads = @input_threads.select {|t| t.alive? }
     worker_threads = @worker_threads.select {|t| t.alive? }
     (input_threads + worker_threads).map {|t| Util.thread_info(t) }
   end

data/lib/logstash/modules/kibana_config.rb

@@ -8,7 +8,7 @@ module LogStash module Modules class KibanaConfig
   include LogStash::Util::Loggable
 
   ALLOWED_DIRECTORIES = ["search", "visualization"]
-  attr_reader :index_name # not used when importing via kibana but for BWC with ElastsearchConfig
+  attr_reader :index_name # not used when importing via kibana but for BWC with ElasticsearchConfig
 
   # We name it `modul` here because `module` has meaning in Ruby.
   def initialize(modul, settings)

data/lib/logstash/modules/logstash_config.rb

@@ -39,7 +39,7 @@ module LogStash module Modules class LogStashConfig
   def get_setting(setting_class)
     raw_value = @settings[setting_class.name]
     # If we dont check for NIL, the Settings class will try to coerce the value
-    # and most of the it will fails when a NIL value is explicitely set.
+    # and most of the it will fails when a NIL value is explicitly set.
     # This will be fixed once we wrap the plugins settings into a Settings class
     setting_class.set(raw_value) unless raw_value.nil?
     setting_class.value

data/lib/logstash/patches/resolv.rb

@@ -1,25 +1,40 @@
 require "resolv"
 
-# ref:
-#   https://github.com/logstash-plugins/logstash-filter-dns/issues/51
-#   https://github.com/jruby/jruby/pull/5722
+# ref: https://github.com/logstash-plugins/logstash-filter-dns/issues/40
 #
-# JRuby versions starting at 9.2.0.0 have a bug in resolv.rb with a leak between the
-# DNS.allocate_request_id/DNS.free_request_id methods.
+# JRuby 9k versions prior to 9.1.16.0 have a bug which crashes IP address
+# resolution after 64k unique IP addresses resolutions.
 #
-# We are opting to load a patched full resolv.rb instead of monkey patching the
-# offending methods because we do not yet know in which upcoming version of JRuby
-# this will be fixed and we want to avoid potential conflicting monkey patches.
-# A spec which will break on JRuby upgrade will redirect here
-# to make a manual verification and eventually remove that patch here once the fix is
-# made in the JRuby version of resolv.rb.
+# Note that the oldest JRuby version in LS 6 is 9.1.13.0 and
+# JRuby 1.7.25 and 1.7.27 (the 2 versions used across LS 5) are not affected by this bug.
 
-if Gem::Version.new(JRUBY_VERSION) >= Gem::Version.new("9.2.0.0")
-  # save verbose level and mute the "warning: already initialized constant"
-  warn_level = $VERBOSE
-  $VERBOSE = nil
+# make sure we abort if a known correct JRuby version is installed 
+# to avoid having an unnecessary legacy patch being applied in the future.
+raise("Unnecessary patch on resolv.rb for JRuby version 9.1.16+") if Gem::Version.new(JRUBY_VERSION) >= Gem::Version.new("9.1.16.0")
 
-  require_relative "resolv_9270"
+# The code below is copied from JRuby 9.1.16.0 resolv.rb:
+# https://github.com/jruby/jruby/blob/9.1.16.0/lib/ruby/stdlib/resolv.rb#L775-L784
+#
+# JRuby is Copyright (c) 2007-2017 The JRuby project, and is released
+# under a tri EPL/GPL/LGPL license.
+# Full license available at https://github.com/jruby/jruby/blob/9.1.16.0/COPYING
 
-  $VERBOSE = warn_level
+class Resolv
+  class DNS
+    class Requester
+      class UnconnectedUDP
+        def sender(msg, data, host, port=Port)
+          sock = @socks_hash[host.index(':') ? "::" : "0.0.0.0"]
+          return nil if !sock
+          service = [IPAddr.new(host), port]
+          id = DNS.allocate_request_id(service[0], service[1])
+          request = msg.encode
+          request[0,2] = [id].pack('n')
+          return @senders[[service, id]] =
+              Sender.new(request, data, sock, host, port)
+        end
+      end
+    end
+  end
 end
+

data/lib/logstash/pipeline.rb

@@ -107,23 +107,8 @@ module LogStash; class Pipeline < BasePipeline
     @flushing = Concurrent::AtomicReference.new(false)
     @outputs_registered = Concurrent::AtomicBoolean.new(false)
     @worker_shutdown = java.util.concurrent.atomic.AtomicBoolean.new(false)
-
-    # @finished_execution signals that the pipeline thread has finished its execution
-    # regardless of any exceptions; it will always be true when the thread completes
-    @finished_execution = Concurrent::AtomicBoolean.new(false)
-
-    # @finished_run signals that the run methods called in the pipeline thread was completed
-    # without errors and it will NOT be set if the run method exits from an exception; this
-    # is by design and necessary for the wait_until_started semantic
-    @finished_run = Concurrent::AtomicBoolean.new(false)
-
-    @thread = nil
   end # def initialize
 
-  def finished_execution?
-    @finished_execution.true?
-  end
-
   def ready?
     @ready.value
   end
@@ -167,19 +152,16 @@ module LogStash; class Pipeline < BasePipeline
       "pipeline.batch.size" => settings.get("pipeline.batch.size"),
       "pipeline.batch.delay" => settings.get("pipeline.batch.delay")))
 
-    @finished_execution.make_false
-    @finished_run.make_false
+    @finished_execution = Concurrent::AtomicBoolean.new(false)
 
     @thread = Thread.new do
       begin
         LogStash::Util.set_thread_name("pipeline.#{pipeline_id}")
         run
-        @finished_run.make_true
+        @finished_execution.make_true
       rescue => e
         close
         @logger.error("Pipeline aborted due to error", default_logging_keys(:exception => e, :backtrace => e.backtrace))
-      ensure
-        @finished_execution.make_true
       end
     end
 
@@ -194,14 +176,15 @@ module LogStash; class Pipeline < BasePipeline
 
   def wait_until_started
     while true do
-      if @finished_run.true?
-        # it completed run without exception
+      # This should be changed with an appropriate FSM
+      # It's an edge case, if we have a pipeline with
+      # a generator { count => 1 } its possible that `Thread#alive?` doesn't return true
+      # because the execution of the thread was successful and complete
+      if @finished_execution.true?
         return true
-      elsif thread.nil? || !thread.alive?
-        # some exception occured and the thread is dead
+      elsif !thread.alive?
         return false
       elsif running?
-        # fully initialized and running
         return true
       else
         sleep 0.01
@@ -300,9 +283,9 @@ module LogStash; class Pipeline < BasePipeline
 
       pipeline_workers.times do |t|
         thread = Thread.new(batch_size, batch_delay, self) do |_b_size, _b_delay, _pipeline|
-          Util.set_thread_name("[#{pipeline_id}]>worker#{t}")
           _pipeline.worker_loop(_b_size, _b_delay)
         end
+        Util.set_thread_name("[#{pipeline_id}]>worker#{t}")
         @worker_threads << thread
       end
 
@@ -463,7 +446,7 @@ module LogStash; class Pipeline < BasePipeline
 
     stop_inputs
 
-    # We make this call blocking, so we know for sure when the method return the shtudown is
+    # We make this call blocking, so we know for sure when the method return the shutdown is
     # stopped
     wait_for_workers
     clear_pipeline_metrics
@@ -542,7 +525,7 @@ module LogStash; class Pipeline < BasePipeline
 
   # Calculate the uptime in milliseconds
   #
-  # @return [Integer] Uptime in milliseconds, 0 if the pipeline is not started
+  # @return [Fixnum] Uptime in milliseconds, 0 if the pipeline is not started
   def uptime
     return 0 if started_at.nil?
     ((Time.now.to_f - started_at.to_f) * 1000.0).to_i

data/lib/logstash/pipeline_action/base.rb

@@ -12,7 +12,7 @@ module LogStash module PipelineAction
     end
     alias_method :to_s, :inspect
 
-    def execute(agent, pipelines_registry)
+    def execute(agent, pipelines)
       raise "`#execute` Not implemented!"
     end
 

data/lib/logstash/pipeline_action/create.rb

@@ -3,7 +3,6 @@ require "logstash/pipeline_action/base"
 require "logstash/pipeline"
 require "logstash/java_pipeline"
 
-
 module LogStash module PipelineAction
   class Create < Base
     include LogStash::Util::Loggable
@@ -31,26 +30,33 @@ module LogStash module PipelineAction
 
     # The execute assume that the thread safety access of the pipeline
     # is managed by the caller.
-    def execute(agent, pipelines_registry)
-      new_pipeline =
+    def execute(agent, pipelines)
+      pipeline =
         if @pipeline_config.settings.get_value("pipeline.java_execution")
           LogStash::JavaPipeline.new(@pipeline_config, @metric, agent)
         else
           agent.exclusive do
             # The Ruby pipeline initialization is not thread safe because of the module level
             # shared state in LogsStash::Config::AST. When using multiple pipelines this gets
-            # executed simultaneously in different threads and we need to synchronize this initialization.
+            # executed simultaneously in different threads and we need to synchonize this initialization.
             LogStash::Pipeline.new(@pipeline_config, @metric, agent)
           end
         end
 
-      success = pipelines_registry.create_pipeline(pipeline_id, new_pipeline) do
-        new_pipeline.start # block until the pipeline is correctly started or crashed
+      status = nil
+      pipelines.compute(pipeline_id) do |id,value|
+        if value
+          LogStash::ConvergeResult::ActionResult.create(self, true)
+        end
+        status = pipeline.start # block until the pipeline is correctly started or crashed
+        pipeline # The pipeline is successfully started we can add it to the map
       end
 
-      LogStash::ConvergeResult::ActionResult.create(self, success)
+
+      LogStash::ConvergeResult::ActionResult.create(self, status)
     end
 
+
     def to_s
       "PipelineAction::Create<#{pipeline_id}>"
     end

data/lib/logstash/pipeline_action/reload.rb

@@ -20,12 +20,8 @@ module LogStash module PipelineAction
       "PipelineAction::Reload<#{pipeline_id}>"
     end
 
-    def execute(agent, pipelines_registry)
-      old_pipeline = pipelines_registry.get_pipeline(pipeline_id)
-
-      if old_pipeline.nil?
-        return LogStash::ConvergeResult::FailedAction.new("Cannot reload pipeline, because the pipeline does not exist")
-      end
+    def execute(agent, pipelines)
+      old_pipeline = pipelines[pipeline_id]
 
       if !old_pipeline.reloadable?
         return LogStash::ConvergeResult::FailedAction.new("Cannot reload pipeline, because the existing pipeline is not reloadable")
@@ -38,8 +34,8 @@ module LogStash module PipelineAction
           else
             agent.exclusive do
               # The Ruby pipeline initialization is not thread safe because of the module level
-              # shared state in LogsStash::Config::AST. When using multiple pipelines this gets
-              # executed simultaneously in different threads and we need to synchronize this initialization.
+              # shared state in LogsStash::Config::AST. When using multiple pipelines this can gets
+              # executed simultaneously in different threads and we need to synchonize this initialization.
               LogStash::BasePipeline.new(@pipeline_config)
             end
           end
@@ -53,35 +49,16 @@ module LogStash module PipelineAction
 
       logger.info("Reloading pipeline", "pipeline.id" => pipeline_id)
 
-      success = pipelines_registry.reload_pipeline(pipeline_id) do
-        # important NOT to explicitly return from block here
-        # the block must emit a success boolean value
+      pipelines.compute(pipeline_id) do |_,pipeline|
+        status = Stop.new(pipeline_id).execute(agent, pipelines)
 
-        # First shutdown old pipeline
-        old_pipeline.shutdown { LogStash::ShutdownWatcher.start(old_pipeline) }
-        old_pipeline.thread.join
-
-        # Then create a new pipeline
-        new_pipeline =
-          if @pipeline_config.settings.get_value("pipeline.java_execution")
-            LogStash::JavaPipeline.new(@pipeline_config, @metric, agent)
-          else
-            agent.exclusive do
-              # The Ruby pipeline initialization is not thread safe because of the module level
-              # shared state in LogsStash::Config::AST. When using multiple pipelines this gets
-              # executed simultaneously in different threads and we need to synchronize this initialization.
-              LogStash::Pipeline.new(@pipeline_config, @metric, agent)
-            end
-          end
-
-        success = new_pipeline.start # block until the pipeline is correctly started or crashed
-
-        # return success and new_pipeline to registry reload_pipeline
-        [success, new_pipeline]
+        if status
+          return Create.new(@pipeline_config, @metric).execute(agent, pipelines)
+        else
+          return status
+        end
+        pipeline
       end
-
-      LogStash::ConvergeResult::ActionResult.create(self, success)
     end
-
   end
 end end

data/lib/logstash/pipeline_action/stop.rb

@@ -9,13 +9,15 @@ module LogStash module PipelineAction
       @pipeline_id = pipeline_id
     end
 
-    def execute(agent, pipelines_registry)
-      pipelines_registry.terminate_pipeline(pipeline_id) do |pipeline|
+    def execute(agent, pipelines)
+      pipelines.compute(pipeline_id) do |_,pipeline|
         pipeline.shutdown { LogStash::ShutdownWatcher.start(pipeline) }
         pipeline.thread.join
+        nil # delete the pipeline
       end
-
-      LogStash::ConvergeResult::SuccessfulAction.new
+      # If we reach this part of the code we have succeeded because
+      # the shutdown call will block.
+      return LogStash::ConvergeResult::SuccessfulAction.new
     end
 
     def to_s

data/lib/logstash/pipeline_settings.rb

@@ -28,7 +28,6 @@ module LogStash
       "queue.checkpoint.acks",
       "queue.checkpoint.interval",
       "queue.checkpoint.writes",
-      "queue.checkpoint.retry",
       "queue.drain",
       "queue.max_bytes",
       "queue.max_events",
@@ -47,7 +46,7 @@ module LogStash
 
     def register(setting)
       unless SETTINGS_WHITE_LIST.include?(setting.name)
-        raise ArgumentError.new("Only pipeline related settings can be registed in a PipelineSettings object. Received \"#{setting.name}\". Allowed settings: #{SETTINGS_WHITE_LIST}")
+        raise ArgumentError.new("Only pipeline related settings can be registered in a PipelineSettings object. Received \"#{setting.name}\". Allowed settings: #{SETTINGS_WHITE_LIST}")
       end
       super(setting)
     end

data/lib/logstash/plugins/registry.rb

@@ -262,14 +262,11 @@ module LogStash module Plugins
     # @param name [String] plugin name
     # @return [Boolean] true if klass is a valid plugin for name
     def is_a_plugin?(klass, name)
-      (klass.class == Java::JavaClass && klass.simple_name.downcase == name.gsub('_','')) ||
-      (klass.ancestors.include?(LogStash::Plugin) && klass.respond_to?(:config_name) && klass.config_name == name)
+      klass.ancestors.include?(LogStash::Plugin) && klass.respond_to?(:config_name) && klass.config_name == name
     end
 
     def add_plugin(type, name, klass)
-      if klass.respond_to?("javaClass", true)
-        @registry[key_for(type, name)] = PluginSpecification.new(type, name, klass.javaClass)
-      elsif !exists?(type, name)
+      if !exists?(type, name)
         specification_klass = type == :universal ? UniversalPluginSpecification : PluginSpecification
         @registry[key_for(type, name)] = specification_klass.new(type, name, klass)
       else

data/lib/logstash/runner.rb

@@ -276,17 +276,6 @@ class LogStash::Runner < Clamp::StrictCommand
     LogStash::PLUGIN_REGISTRY.hooks.register_emitter(self.class, @dispatcher)
 
     @settings.validate_all
-
-    if @settings.registered?("xpack.monitoring.enabled")
-      verify_deprecated_setting("xpack.monitoring.elasticsearch.url", "xpack.monitoring.elasticsearch.hosts")
-      verify_deprecated_setting("xpack.monitoring.elasticsearch.ssl.ca", "xpack.monitoring.elasticsearch.ssl.certificate_authority")
-    end
-
-    if @settings.registered?("xpack.management.enabled")
-      verify_deprecated_setting("xpack.management.elasticsearch.url", "xpack.management.elasticsearch.hosts")
-      verify_deprecated_setting("xpack.management.elasticsearch.ssl.ca", "xpack.management.elasticsearch.ssl.certificate_authority")
-    end
-
     @dispatcher.fire(:before_bootstrap_checks)
 
     return start_shell(setting("interactive"), binding) if setting("interactive")
@@ -380,8 +369,6 @@ class LogStash::Runner < Clamp::StrictCommand
 
     @agent.shutdown
 
-    logger.info("Logstash shut down.")
-
     # flush any outstanding log messages during shutdown
     org.apache.logging.log4j.LogManager.shutdown
 
@@ -514,15 +501,4 @@ class LogStash::Runner < Clamp::StrictCommand
     @settings.get_value(key)
   end
 
-  def verify_deprecated_setting(old_setting, new_setting)
-    if @settings.set?(old_setting)
-      logger.warn("Deprecated setting `#{old_setting}` please use `#{new_setting}`")
-      if @settings.set?(new_setting)
-        signal_usage_error("Both `#{new_setting}` and the deprecated `#{old_setting}` settings are set, please remove `#{old_setting}`")
-      else
-        @settings.set_value(new_setting, @settings.get_value(old_setting))
-      end
-    end
-  end
-
 end

data/lib/logstash/settings.rb

@@ -368,7 +368,7 @@ module LogStash
         case value
         when ::Range
           value
-        when ::Integer
+        when ::Fixnum
           value..value
         when ::String
           first, last = value.split(PORT_SEPARATOR)
@@ -481,11 +481,11 @@ module LogStash
 
     class Bytes < Coercible
       def initialize(name, default=nil, strict=true)
-        super(name, ::Integer, default, strict=true) { |value| valid?(value) }
+        super(name, ::Fixnum, default, strict=true) { |value| valid?(value) }
       end
 
       def valid?(value)
-        value.is_a?(::Integer) && value >= 0
+        value.is_a?(Fixnum) && value >= 0
       end
 
       def coerce(value)
@@ -508,11 +508,11 @@ module LogStash
 
     class TimeValue < Coercible
       def initialize(name, default, strict=true, &validator_proc)
-        super(name, ::Integer, default, strict, &validator_proc)
+        super(name, ::Fixnum, default, strict, &validator_proc)
       end
 
       def coerce(value)
-        return value if value.is_a?(::Integer)
+        return value if value.is_a?(::Fixnum)
         Util::TimeValue.from_value(value).to_nanos
       end
     end

data/lib/logstash/state_resolver.rb

@@ -10,11 +10,11 @@ module LogStash
       @metric = metric
     end
 
-    def resolve(pipelines_registry, pipeline_configs)
+    def resolve(pipelines, pipeline_configs)
       actions = []
 
       pipeline_configs.each do |pipeline_config|
-        pipeline = pipelines_registry.get_pipeline(pipeline_config.pipeline_id)
+        pipeline = pipelines[pipeline_config.pipeline_id]
 
         if pipeline.nil?
           actions << LogStash::PipelineAction::Create.new(pipeline_config, @metric)
@@ -25,12 +25,12 @@ module LogStash
         end
       end
 
-      configured_pipelines = pipeline_configs.collect(&:pipeline_id)
+      running_pipelines = pipeline_configs.collect(&:pipeline_id)
 
       # If one of the running pipeline is not in the pipeline_configs, we assume that we need to
       # stop it.
-      pipelines_registry.running_pipelines.keys
-        .select { |pipeline_id| !configured_pipelines.include?(pipeline_id) }
+      pipelines.keys
+        .select { |pipeline_id| !running_pipelines.include?(pipeline_id) }
         .each { |pipeline_id| actions << LogStash::PipelineAction::Stop.new(pipeline_id) }
 
       actions.sort # See logstash/pipeline_action.rb

data/lib/logstash/util/duration_formatter.rb

@@ -7,7 +7,7 @@ module LogStash::Util::DurationFormatter
   # a format that a human can understand. This is currently used by
   # the API.
   #
-  # @param [Integer] Duration in milliseconds
+  # @param [Fixnum] Duration in milliseconds
   # @return [String] Duration in human format
   def self.human_format(duration)
     ChronicDuration.output(duration / 1000, CHRONIC_OPTIONS)

data/lib/logstash/util/safe_uri.rb

@@ -26,7 +26,6 @@ class LogStash::Util::SafeURI
            else
              raise ArgumentError, "Expected a string, java.net.URI, or URI, got a #{arg.class} creating a URL"
            end
-    raise ArgumentError, "URI is not valid - host is not specified" if @uri.host.nil?
   end
 
   def to_s