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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86884463d88f17e77269fe7bfa8fdd61c822e2d43c8d21b12262650d7e8c3476
-  data.tar.gz: b94069de9fe9657a676d96cc6895802baadf68d28fc7c79a9b64e018908df820
+  metadata.gz: aac6580e3fcdb7a4ef97667263de8081ef5f747948508322dc44dcf58f649102
+  data.tar.gz: 62fe96390ead958576494f6507200be79183eb4d36daf3724b9b3f9116f686ea
 SHA512:
-  metadata.gz: 1dd9828e9f195068d02df9e1f46298dcf8c5d355a710f8224148ee670683f9e9807648467e5313edc481f9806bba76e8336bcd7a468f581633e6b95e60fc9286
-  data.tar.gz: 9455bc170fa62b85ced1121c2337834af54d1b4389b047b9a0e700e5aa71d7a38c81a2bf3520bbe58e0ce16db7ff585925a7fd22a6c8d5de52602bef277f08aa
+  metadata.gz: 551463904e10b3d091962829e5f55c6a32435d6f39799d725a72c8b5fa7bf5051abc4cfdd2ab6e8b509a70d28b33e9cce1deedaae16e70fefd49fb7100a61b07
+  data.tar.gz: '08c65c30b5223731ff293615a5c321262eb2e93d6fa896d25b064ccc52de2e2b9b877e01976b156919f3e0bf4852f3c3ae261f40375332217ad246ebbb982d85'

data/lib/logstash/agent.rb

@@ -8,7 +8,6 @@ require "logstash/webserver"
 require "logstash/config/source_loader"
 require "logstash/pipeline_action"
 require "logstash/state_resolver"
-require "logstash/pipelines_registry"
 require "stud/trap"
 require "uri"
 require "socket"
@@ -20,7 +19,7 @@ class LogStash::Agent
   include LogStash::Util::Loggable
   STARTED_AT = Time.now.freeze
 
-  attr_reader :metric, :name, :settings, :dispatcher, :ephemeral_id, :pipeline_bus
+  attr_reader :metric, :name, :settings, :webserver, :dispatcher, :ephemeral_id, :pipelines, :pipeline_bus
   attr_accessor :logger
 
   # initialize method for LogStash::Agent
@@ -37,14 +36,11 @@ class LogStash::Agent
     # Mutex to synchonize in the exclusive method
     # Initial usage for the Ruby pipeline initialization which is not thread safe
     @exclusive_lock = Mutex.new
-    @webserver_control_lock = Mutex.new
-
-    @convergence_lock = Mutex.new
 
     # Special bus object for inter-pipelines communications. Used by the `pipeline` input/output
     @pipeline_bus = org.logstash.plugins.pipeline.PipelineBus.new
 
-    @pipelines_registry = LogStash::PipelinesRegistry.new
+    @pipelines = java.util.concurrent.ConcurrentHashMap.new();
 
     @name = setting("node.name")
     @http_host = setting("http.host")
@@ -54,14 +50,10 @@ class LogStash::Agent
     id
 
     # Set the global FieldReference parsing mode
-    parsing_mode = case setting('config.field_reference.parser')
-                   when 'COMPAT' then org.logstash.FieldReference::ParsingMode::COMPAT;
-                   when 'LEGACY' then org.logstash.FieldReference::ParsingMode::LEGACY;
-                   when 'STRICT' then org.logstash.FieldReference::ParsingMode::STRICT;
-                   else fail('Unsupported FieldReference parsing mode')
-                   end
-    logger.debug("Setting global FieldReference parsing mode: #{parsing_mode}")
-    org.logstash.FieldReference::set_parsing_mode(parsing_mode)
+    if @settings.set?('config.field_reference.parser')
+      # TODO: i18n
+      logger.warn("deprecated setting `config.field_reference.parser` set; field reference parsing is strict by default")
+    end
 
     # This is for backward compatibility in the tests
     if source_loader.nil?
@@ -122,17 +114,14 @@ class LogStash::Agent
         converge_state_and_update unless stopped?
       end
     else
-      # exit with error status if the initial converge_state_and_update did not create any pipeline
-      return 1 if @pipelines_registry.empty?
+      return 1 if clean_state?
 
       while !Stud.stop?
-        # exit if all pipelines are terminated and none are reloading
-        break if no_pipeline?
-
-        # exit if there are no user defined pipelines (not system pipeline) and none are reloading
-        break if !running_user_defined_pipelines?
-
-        sleep(0.5)
+        if clean_state? || running_user_defined_pipelines?
+          sleep(0.5)
+        else
+          break
+        end
       end
     end
 
@@ -146,11 +135,11 @@ class LogStash::Agent
   end
 
   def running?
-    @running.true?
+    @running.value
   end
 
   def stopped?
-    @running.false?
+    !@running.value
   end
 
   def converge_state_and_update
@@ -165,7 +154,12 @@ class LogStash::Agent
       end
     end
 
-    converge_result = resolve_actions_and_converge_state(results.response)
+    # We Lock any access on the pipelines, since the actions will modify the
+    # content of it.
+    converge_result = nil
+
+    pipeline_actions = resolve_actions(results.response)
+    converge_result = converge_state(pipeline_actions)
     update_metrics(converge_result)
 
     logger.info(
@@ -184,7 +178,7 @@ class LogStash::Agent
 
   # Calculate the Logstash uptime in milliseconds
   #
-  # @return [Integer] Uptime in milliseconds
+  # @return [Fixnum] Uptime in milliseconds
   def uptime
     ((Time.now.to_f - STARTED_AT.to_f) * 1000.0).to_i
   end
@@ -239,48 +233,43 @@ class LogStash::Agent
     @id_path ||= ::File.join(settings.get("path.data"), "uuid")
   end
 
-  #
-  # Backward compatibility proxies to the PipelineRegistry
-  #
-
   def get_pipeline(pipeline_id)
-    @pipelines_registry.get_pipeline(pipeline_id)
+    pipelines.get(pipeline_id)
   end
 
   def pipelines_count
-    @pipelines_registry.size
+    pipelines.size
   end
 
   def running_pipelines
-    @pipelines_registry.running_pipelines
-   end
+    pipelines.select {|id,pipeline| running_pipeline?(id) }
+  end
 
   def non_running_pipelines
-    @pipelines_registry.non_running_pipelines
+    pipelines.select {|id,pipeline| !running_pipeline?(id) }
   end
 
   def running_pipelines?
-    @pipelines_registry.running_pipelines.any?
+    running_pipelines_count > 0
   end
 
   def running_pipelines_count
-    @pipelines_registry.running_pipelines.size
+    running_pipelines.size
   end
 
   def running_user_defined_pipelines?
-    @pipelines_registry.running_user_defined_pipelines.any?
+    !running_user_defined_pipelines.empty?
   end
 
   def running_user_defined_pipelines
-    @pipelines_registry.running_user_defined_pipelines
+    pipelines.select {|id, pipeline| running_pipeline?(id) && !pipeline.system? }
   end
 
-  def no_pipeline?
-    @pipelines_registry.running_pipelines.empty?
+  def with_running_user_defined_pipelines
+    yield running_user_defined_pipelines
   end
 
   private
-
   def transition_to_stopped
     @running.make_false
   end
@@ -289,15 +278,6 @@ class LogStash::Agent
     @running.make_true
   end
 
-  # @param pipeline_configs [Array<Config::PipelineConfig>]
-  # @return [ConvergeResult]
-  def resolve_actions_and_converge_state(pipeline_configs)
-    @convergence_lock.synchronize do
-      pipeline_actions = resolve_actions(pipeline_configs)
-      converge_state(pipeline_actions)
-    end
-  end
-
   # We depends on a series of task derived from the internal state and what
   # need to be run, theses actions are applied to the current pipelines to converge to
   # the desired state.
@@ -310,12 +290,11 @@ class LogStash::Agent
   #
   def converge_state(pipeline_actions)
     logger.debug("Converging pipelines state", :actions_count => pipeline_actions.size)
-    fail("Illegal access to `LogStash::Agent#converge_state()` without exclusive lock at #{caller[1]}") unless @convergence_lock.owned?
 
     converge_result = LogStash::ConvergeResult.new(pipeline_actions.size)
 
     pipeline_actions.map do |action|
-      Thread.new(action, converge_result) do |action, converge_result|
+      Thread.new do
         java.lang.Thread.currentThread().setName("Converge #{action}");
         # We execute every task we need to converge the current state of pipelines
         # for every task we will record the action result, that will help us
@@ -331,36 +310,34 @@ class LogStash::Agent
         # that we currently have.
         begin
           logger.debug("Executing action", :action => action)
-          action_result = action.execute(self, @pipelines_registry)
+          action_result = action.execute(self, pipelines)
           converge_result.add(action, action_result)
 
           unless action_result.successful?
-            logger.error("Failed to execute action",
-              :id => action.pipeline_id,
-              :action_type => action_result.class,
-              :message => action_result.message,
-              :backtrace => action_result.backtrace
-            )
+            logger.error("Failed to execute action", :id => action.pipeline_id,
+                         :action_type => action_result.class, :message => action_result.message,
+                         :backtrace => action_result.backtrace)
           end
-        rescue SystemExit, Exception => e
+        rescue SystemExit => e
+          converge_result.add(action, e)
+        rescue Exception => e
           logger.error("Failed to execute action", :action => action, :exception => e.class.name, :message => e.message, :backtrace => e.backtrace)
           converge_result.add(action, e)
         end
       end
     end.each(&:join)
 
-    logger.trace? && logger.trace("Converge results",
-      :success => converge_result.success?,
-      :failed_actions => converge_result.failed_actions.collect { |a, r| "id: #{a.pipeline_id}, action_type: #{a.class}, message: #{r.message}" },
-      :successful_actions => converge_result.successful_actions.collect { |a, r| "id: #{a.pipeline_id}, action_type: #{a.class}" }
-    )
+    if logger.trace?
+      logger.trace("Converge results", :success => converge_result.success?,
+                   :failed_actions => converge_result.failed_actions.collect { |a, r| "id: #{a.pipeline_id}, action_type: #{a.class}, message: #{r.message}" },
+                   :successful_actions => converge_result.successful_actions.collect { |a, r| "id: #{a.pipeline_id}, action_type: #{a.class}" })
+    end
 
     converge_result
   end
 
   def resolve_actions(pipeline_configs)
-    fail("Illegal access to `LogStash::Agent#resolve_actions()` without exclusive lock at #{caller[1]}") unless @convergence_lock.owned?
-    @state_resolver.resolve(@pipelines_registry, pipeline_configs)
+    @state_resolver.resolve(@pipelines, pipeline_configs)
   end
 
   def dispatch_events(converge_results)
@@ -377,24 +354,20 @@ class LogStash::Agent
   end
 
   def start_webserver
-    @webserver_control_lock.synchronize do
-      options = {:http_host => @http_host, :http_ports => @http_port, :http_environment => @http_environment }
-      @webserver = LogStash::WebServer.new(@logger, self, options)
-      @webserver_thread = Thread.new(@webserver) do |webserver|
-        LogStash::Util.set_thread_name("Api Webserver")
-        webserver.run
-      end
+    options = {:http_host => @http_host, :http_ports => @http_port, :http_environment => @http_environment }
+    @webserver = LogStash::WebServer.new(@logger, self, options)
+    @webserver_thread = Thread.new(@webserver) do |webserver|
+      LogStash::Util.set_thread_name("Api Webserver")
+      webserver.run
     end
   end
 
   def stop_webserver
-    @webserver_control_lock.synchronize do
-      if @webserver
-        @webserver.stop
-        if @webserver_thread.join(5).nil?
-          @webserver_thread.kill
-          @webserver_thread.join
-        end
+    if @webserver
+      @webserver.stop
+      if @webserver_thread.join(5).nil?
+        @webserver_thread.kill
+        @webserver_thread.join
       end
     end
   end
@@ -422,14 +395,25 @@ class LogStash::Agent
   end
 
   def shutdown_pipelines
-    logger.debug("Shutting down all pipelines", :pipelines_count => running_pipelines_count)
+    logger.debug("Shutting down all pipelines", :pipelines_count => pipelines_count)
 
     # In this context I could just call shutdown, but I've decided to
     # use the stop action implementation for that so we have the same code.
     # This also give us some context into why a shutdown is failing
-    resolve_actions_and_converge_state([]) # We stop all the pipeline, so we converge to a empty state
+    pipeline_actions = resolve_actions([]) # We stop all the pipeline, so we converge to a empty state
+    converge_state(pipeline_actions)
   end
 
+  def running_pipeline?(pipeline_id)
+    pipeline = get_pipeline(pipeline_id)
+    return false unless pipeline
+    thread = pipeline.thread
+    thread.is_a?(Thread) && thread.alive?
+  end
+
+  def clean_state?
+    pipelines.empty?
+  end
 
   def setting(key)
     @settings.get(key)

data/lib/logstash/api/modules/stats.rb

@@ -10,7 +10,7 @@ module LogStash
         # return hot threads information
         get "/jvm/hot_threads" do
           begin
-            top_threads_count = params["threads"] || 10
+            top_threads_count = params["threads"] || 3
             ignore_idle_threads = params["ignore_idle_threads"] || true
             options = {
               :threads => top_threads_count.to_i,

data/lib/logstash/compiler/lscl.rb

@@ -3,7 +3,6 @@ require "treetop"
 require "logstash/compiler/treetop_monkeypatches"
 require "logstash/compiler/lscl/helpers"
 require "logstash/config/string_escape"
-require "logstash/util"
 
 java_import org.logstash.config.ir.DSL
 java_import org.logstash.common.SourceWithMetadata
@@ -112,11 +111,11 @@ module LogStashCompilerLSCLGrammar; module LogStash; module Compiler; module LSC
           # hash value; e.g., `{"match" => {"baz" => "bar"}, "match" => {"foo" => "bulb"}}` is
           # interpreted as `{"match" => {"baz" => "bar", "foo" => "blub"}}`.
           # (NOTE: this bypasses `AST::Hash`'s ability to detect duplicate keys)
-          hash[k] = ::LogStash::Util.hash_merge_many(existing, v)
+          hash[k] = existing.merge(v)
         elsif existing.kind_of?(::Array)
           hash[k] = existing.push(*v)
         else
-          hash[k] = [existing, v] unless v == existing
+          hash[k] = existing + v
         end
         hash
       end
@@ -165,8 +164,8 @@ module LogStashCompilerLSCLGrammar; module LogStash; module Compiler; module LSC
   class Number < Value
     def expr
       jdsl.eValue(source_meta, text_value.include?(".") ?
-                                   Float(text_value) :
-                                   Integer(text_value))
+        text_value.to_f :
+        text_value.to_i)
     end
   end
 
@@ -318,9 +317,10 @@ module LogStashCompilerLSCLGrammar; module LogStash; module Compiler; module LSC
 
     def precedence(op)
       #  Believe this is right for logstash?
-      if op == AND_METHOD
+      case op
+      when AND_METHOD
         2
-      elsif op == OR_METHOD
+      when OR_METHOD
         1
       else
         raise ArgumentError, "Unexpected operator #{op}"

data/lib/logstash/config/config_ast.rb

@@ -136,7 +136,7 @@ module LogStash; module Config; module AST
               events.each{|e| block.call(e)}
             end
 
-            if !@generated_objects[:#{name}].nil? && @generated_objects[:#{name}].has_flush
+            if @generated_objects[:#{name}].respond_to?(:flush)
               @periodic_flushers << @generated_objects[:#{name}_flush] if @generated_objects[:#{name}].periodic_flush
               @shutdown_flushers << @generated_objects[:#{name}_flush]
             end

data/lib/logstash/config/mixin.rb

@@ -323,7 +323,7 @@ module LogStash::Config::Mixin
       if config_settings[:list]
         value = Array(value) # coerce scalars to lists
         # Empty lists are converted to nils
-        return true, [] if value.empty?
+        return true, nil if value.empty?
 
         validated_items = value.map {|v| validate_value(v, config_val)}
         is_valid = validated_items.all? {|sr| sr[0] }

data/lib/logstash/config/modules_common.rb

@@ -27,7 +27,7 @@ module LogStash module Config
           end
 
       if modules_array.empty?
-        # no specifed modules
+        # no specified modules
         return pipelines
       end
       logger.debug("Specified modules", :modules_array => modules_array.to_s)
@@ -73,9 +73,9 @@ module LogStash module Config
           LogStash::Modules::SettingsMerger.merge_kibana_auth!(module_hash)
           current_module.with_settings(module_hash)
           config_test = settings.get("config.test_and_exit")
-          modul_setup = settings.get("modules_setup")
+          module_setup = settings.get("modules_setup")
           # Only import data if it's not a config test and --setup is true
-          if !config_test && modul_setup
+          if !config_test && module_setup
             logger.info("Setting up the #{module_name} module")
             esclient = LogStash::ElasticsearchClient.build(module_hash)
             kbnclient = LogStash::Modules::KibanaClient.new(module_hash)

data/lib/logstash/dependency_report.rb

@@ -32,9 +32,8 @@ class LogStash::DependencyReport < Clamp::Command
     command = ["./gradlew", "generateLicenseReport", "-PlicenseReportInputCSV=#{ruby_output_path}", "-PlicenseReportOutputCSV=#{output_path}"]
     puts "Executing #{command}"
     system(*command)
-
     if $?.exitstatus != 0
-      raise "generateLicenseReport failed with exit status #{$?.exitstatus}"
+      raise "Could not run gradle java deps! Exit status #{$?.exitstatus}"
     end
 
     nil

data/lib/logstash/environment.rb

@@ -33,7 +33,7 @@ module LogStash
            Setting::Boolean.new("config.reload.automatic", false),
            Setting::TimeValue.new("config.reload.interval", "3s"), # in seconds
            Setting::Boolean.new("config.support_escapes", false),
-            Setting::String.new("config.field_reference.parser", "COMPAT", true, %w(STRICT COMPAT LEGACY)),
+            Setting::String.new("config.field_reference.parser", "STRICT", true, %w(STRICT)),
            Setting::Boolean.new("metric.collect", true),
             Setting::String.new("pipeline.id", "main"),
            Setting::Boolean.new("pipeline.system", false),
@@ -42,7 +42,7 @@ module LogStash
    Setting::PositiveInteger.new("pipeline.batch.size", 125),
            Setting::Numeric.new("pipeline.batch.delay", 50), # in milliseconds
            Setting::Boolean.new("pipeline.unsafe_shutdown", false),
-           Setting::Boolean.new("pipeline.java_execution", false),
+           Setting::Boolean.new("pipeline.java_execution", true),
            Setting::Boolean.new("pipeline.reloadable", true),
                     Setting.new("path.plugins", Array, []),
     Setting::NullableString.new("interactive", nil, false),
@@ -62,7 +62,6 @@ module LogStash
             Setting::Numeric.new("queue.checkpoint.acks", 1024), # 0 is unlimited
             Setting::Numeric.new("queue.checkpoint.writes", 1024), # 0 is unlimited
             Setting::Numeric.new("queue.checkpoint.interval", 1000), # 0 is no time-based checkpointing
-            Setting::Boolean.new("queue.checkpoint.retry", false),
             Setting::Boolean.new("dead_letter_queue.enable", false),
             Setting::Bytes.new("dead_letter_queue.max_bytes", "1024mb"),
             Setting::TimeValue.new("slowlog.threshold.warn", "-1"),
@@ -164,15 +163,11 @@ module LogStash
     end
 
     def windows?
-      host_os =~ WINDOW_OS_RE
+      RbConfig::CONFIG['host_os'] =~ WINDOW_OS_RE
     end
 
     def linux?
-      host_os =~ LINUX_OS_RE
-    end
-
-    def host_os
-      RbConfig::CONFIG['host_os']
+      RbConfig::CONFIG['host_os'] =~ LINUX_OS_RE
     end
 
     def locales_path(path)

data/lib/logstash/event.rb

@@ -1,12 +1,6 @@
 # encoding: utf-8
 
-require "logstash/json"
-
-# transient pipeline events for normal in-flow signaling as opposed to
-# flow altering exceptions. for now having base classes is adequate and
-# in the future it might be necessary to refactor using like a BaseEvent
-# class to have a common interface for all pipeline events to support
-# eventual queueing persistence for example, TBD.
+# used only in the Ruby execution engine
 module LogStash
   class SignalEvent
     def flush?; raise "abstract method"; end;
@@ -31,21 +25,4 @@ module LogStash
   FLUSH = FlushEvent.new
   SHUTDOWN = ShutdownEvent.new
   NO_SIGNAL = NoSignal.new
-
-  class Event
-    MSG_BRACKETS_METHOD_MISSING = "Direct event field references (i.e. event['field']) have been disabled in favor of using event get and set methods (e.g. event.get('field')). Please consult the Logstash 5.0 breaking changes documentation for more details.".freeze
-    MSG_BRACKETS_EQUALS_METHOD_MISSING = "Direct event field references (i.e. event['field'] = 'value') have been disabled in favor of using event get and set methods (e.g. event.set('field', 'value')). Please consult the Logstash 5.0 breaking changes documentation for more details.".freeze
-    RE_BRACKETS_METHOD = /^\[\]$/.freeze
-    RE_BRACKETS_EQUALS_METHOD = /^\[\]=$/.freeze
-
-    def method_missing(method_name, *arguments, &block)
-      if RE_BRACKETS_METHOD.match(method_name.to_s)
-        raise NoMethodError.new(MSG_BRACKETS_METHOD_MISSING)
-      end
-      if RE_BRACKETS_EQUALS_METHOD.match(method_name.to_s)
-        raise NoMethodError.new(MSG_BRACKETS_EQUALS_METHOD_MISSING)
-      end
-      super
-    end
-  end
 end

data/lib/logstash/filter_delegator.rb

@@ -1,2 +1,69 @@
-# The contents of this file have been ported to Java. It is included for for compatibility
-# with plugins that directly include it.
+# encoding: utf-8
+#
+module LogStash
+  class FilterDelegator
+    extend Forwardable
+    DELEGATED_METHODS = [
+      :register,
+      :close,
+      :threadsafe?,
+      :do_close,
+      :do_stop,
+      :periodic_flush,
+      :reloadable?
+    ]
+    def_delegators :@filter, *DELEGATED_METHODS
+
+    attr_reader :id
+
+    def initialize(filter, id)
+      @klass = filter.class
+      @id = id
+      @filter = filter
+
+      # Scope the metrics to the plugin
+      namespaced_metric = filter.metric
+      @metric_events = namespaced_metric.namespace(:events)
+      @metric_events_in = @metric_events.counter(:in)
+      @metric_events_out = @metric_events.counter(:out)
+      @metric_events_time = @metric_events.counter(:duration_in_millis)
+      namespaced_metric.gauge(:name, config_name)
+
+      # Not all the filters will do bufferings
+      define_flush_method if @filter.respond_to?(:flush)
+    end
+
+    def config_name
+      @klass.config_name
+    end
+
+    def multi_filter(events)
+      @metric_events_in.increment(events.size)
+
+      start_time = java.lang.System.nano_time
+      new_events = @filter.multi_filter(events)
+      @metric_events_time.increment((java.lang.System.nano_time - start_time) / 1_000_000)
+
+      # There is no guarantee in the context of filter
+      # that EVENTS_IN == EVENTS_OUT, see the aggregates and
+      # the split filter
+      c = new_events.count { |event| !event.cancelled? }
+      @metric_events_out.increment(c) if c > 0
+      new_events
+    end
+
+    private
+    def define_flush_method
+      define_singleton_method(:flush) do |options = {}|
+        # we also need to trace the number of events
+        # coming from a specific filters.
+        new_events = @filter.flush(options)
+
+        # Filter plugins that does buffering or spooling of events like the
+        # `Logstash-filter-aggregates` can return `NIL` and will flush on the next flush ticks.
+        @metric_events_out.increment(new_events.size) if new_events && new_events.size > 0
+        new_events
+      end
+    end
+  end
+end

data/lib/logstash/filters/base.rb

@@ -194,6 +194,8 @@ class LogStash::Filters::Base < LogStash::Plugin
     # this is important because a construct like event["tags"].delete(tag) will not work
     # in the current Java event implementation. see https://github.com/elastic/logstash/issues/4140
 
+    return if @remove_tag.empty?
+
     tags = event.get("tags")
     return unless tags
 

data/lib/logstash/instrument/metric_store.rb

@@ -302,7 +302,7 @@ module LogStash module Instrument
     #
     # @param [Concurrent::Map] Map to search for the key
     # @param [Array] List of path to create
-    # @param [Integer] Which part from the list to create
+    # @param [Fixnum] Which part from the list to create
     #
     def fetch_or_store_namespace_recursively(map, namespaces_path, idx = 0)
       current = namespaces_path[idx]

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

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

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

@@ -20,8 +20,8 @@ java_import 'org.logstash.instrument.reports.ProcessReport'
 module LogStash module Instrument module PeriodicPoller
   class JVM < Base
     class GarbageCollectorName
-      YOUNG_GC_NAMES = Set.new(["Copy", "PS Scavenge", "ParNew", "G1 Young Generation", "scavenge", "GPGC New"])
-      OLD_GC_NAMES = Set.new(["MarkSweepCompact", "PS MarkSweep", "ConcurrentMarkSweep", "G1 Old Generation", "global", "GPGC Old"])
+      YOUNG_GC_NAMES = Set.new(["Copy", "PS Scavenge", "ParNew", "G1 Young Generation", "scavenge"])
+      OLD_GC_NAMES = Set.new(["MarkSweepCompact", "PS MarkSweep", "ConcurrentMarkSweep", "G1 Old Generation", "global"])
 
       YOUNG = :young
       OLD = :old
@@ -68,7 +68,7 @@ module LogStash module Instrument module PeriodicPoller
         logger.debug("collector name", :name => collector_name)
         name = GarbageCollectorName.get(collector_name)
         if name.nil?
-          logger.error("Unknown garbage collector name", :name => collector_name)
+          logger.error("Unknown garbage collector name", :name => name)
         else
           metric.gauge([:jvm, :gc, :collectors, name], :collection_count, collector.getCollectionCount())
           metric.gauge([:jvm, :gc, :collectors, name], :collection_time_in_millis, collector.getCollectionTime())