logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/plugin.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+require "logstash/namespace"
+require "logstash/logging"
+require "logstash/config/mixin"
+require "logstash/instrument/null_metric"
+require "logstash/util/dead_letter_queue_manager"
+require "concurrent"
+require "securerandom"
+
+class LogStash::Plugin
+  include LogStash::Util::Loggable
+
+  attr_accessor :params, :execution_context
+
+  NL = "\n"
+
+  include LogStash::Config::Mixin
+
+  # Disable or enable metric logging for this specific plugin instance
+  # by default we record all the metrics we can, but you can disable metrics collection
+  # for a specific plugin.
+  config :enable_metric, :validate => :boolean, :default => true
+
+  # Add a unique `ID` to the plugin configuration. If no ID is specified, Logstash will generate one. 
+  # It is strongly recommended to set this ID in your configuration. This is particularly useful 
+  # when you have two or more plugins of the same type, for example, if you have 2 grok filters. 
+  # Adding a named ID in this case will help in monitoring Logstash when using the monitoring APIs.
+  #
+  # [source,ruby]
+  # ---------------------------------------------------------------------------------------------------
+  # output {
+  #  stdout {
+  #    id => "my_plugin_id"
+  #  }
+  # }
+  # ---------------------------------------------------------------------------------------------------
+  #
+  config :id, :validate => :string
+
+  def hash
+    params.hash ^
+    self.class.name.hash
+  end
+
+  def eql?(other)
+    self.class.name == other.class.name && @params == other.params
+  end
+
+  def initialize(params=nil)
+    @logger = self.logger
+    # need to access settings statically because plugins are initialized in config_ast with no context.
+    settings = LogStash::SETTINGS
+    @slow_logger = self.slow_logger(settings.get("slowlog.threshold.warn"),
+                                    settings.get("slowlog.threshold.info"),
+                                    settings.get("slowlog.threshold.debug"),
+                                    settings.get("slowlog.threshold.trace"))
+    @params = LogStash::Util.deep_clone(params)
+    # The id should always be defined normally, but in tests that might not be the case
+    # In the future we may make this more strict in the Plugin API
+    @params["id"] ||= "#{self.class.config_name}_#{SecureRandom.uuid}"
+  end
+
+  # Return a uniq ID for this plugin configuration, by default
+  # we will generate a UUID
+  #
+  # If the user defines a `id => 'ABC'` in the configuration we will return
+  #
+  # @return [String] A plugin ID
+  def id
+    @params["id"]
+  end
+
+  # close is called during shutdown, after the plugin worker
+  # main task terminates
+  def do_close
+    @logger.debug("closing", :plugin => self.class.name)
+    close
+  end
+
+  # Subclasses should implement this close method if you need to perform any
+  # special tasks during shutdown (like flushing, etc.)
+  def close
+    # ..
+  end
+
+  def to_s
+    return "#{self.class.name}: #{@params}"
+  end
+
+  def inspect
+    if !@params.nil?
+      description = @params
+        .reject { |k, v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        .collect { |k, v| "#{k}=>#{v.inspect}" }
+      return "<#{self.class.name} #{description.join(", ")}>"
+    else
+      return "<#{self.class.name} --->"
+    end
+  end
+
+  def reloadable?
+    self.class.reloadable?
+  end
+
+  def self.reloadable?
+    true
+  end
+
+  def debug_info
+    [self.class.to_s, original_params]
+  end
+
+  def metric=(new_metric)
+    @metric = new_metric
+  end
+
+  def metric
+    # We can disable metric per plugin if we want in the configuration
+    # we will use the NullMetric in this case.
+    @metric_plugin ||= if @enable_metric
+                         # Fallback when testing plugin and no metric collector are correctly configured.
+                         @metric.nil? ? LogStash::Instrument::NamespacedNullMetric.new : @metric
+                       else
+                         LogStash::Instrument::NamespacedNullMetric.new(@metric, :null)
+                       end
+  end
+
+  # return the configured name of this plugin
+  # @return [String] The name of the plugin defined by `config_name`
+  def config_name
+    self.class.config_name
+  end
+
+  # This is keep for backward compatibility, the logic was moved into the registry class
+  # but some plugins use this method to return a specific instance on lookup
+  #
+  # Should I remove this now and make sure the pipeline invoke the Registry or I should wait for 6.0
+  # Its not really part of the public api but its used by the tests a lot to mock the plugins.
+  def self.lookup(type, name)
+    LogStash::PLUGIN_REGISTRY.lookup_pipeline_plugin(type, name)
+  end
+end # class LogStash::Plugin

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/plugins/registry.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+require "rubygems/package"
+require "logstash/util/loggable"
+require "logstash/plugin"
+require "logstash/plugins/hooks_registry"
+require "logstash/modules/scaffold"
+
+module LogStash module Plugins
+  class Registry
+    include LogStash::Util::Loggable
+
+    # Add a bit more sanity with when interacting with the rubygems'
+    # specifications database, most of out code interact directly with really low level
+    # components of bundler/rubygems we need to encapsulate that and this is a start.
+    class GemRegistry
+      LOGSTASH_METADATA_KEY = "logstash_plugin"
+
+      class << self
+        def installed_gems
+          ::Gem::Specification
+        end
+
+        def logstash_plugins
+          installed_gems
+            .select { |spec| spec.metadata && spec.metadata[LOGSTASH_METADATA_KEY] }
+            .collect { |spec| PluginRawContext.new(spec) }
+        end
+      end
+    end
+
+    class PluginRawContext
+      HOOK_FILE = "logstash_registry.rb"
+      NAME_DELIMITER = "-"
+
+      attr_reader :spec
+
+      def initialize(spec)
+        @spec = spec
+        @destructured_name = spec.name.split(NAME_DELIMITER)
+      end
+
+      def name
+        @destructured_name[2..-1].join(NAME_DELIMITER)
+      end
+
+      def type
+        @destructured_name[1]
+      end
+
+      # In the context of the plugin, the hook file available  need to exist in any top level
+      # required paths.
+      #
+      # Example for the logstash-output-elasticsearch we have this line in the gemspec.
+      #
+      # s.require_paths = ["lib"], so the we will expect to have a `logstash_registry.rb` file in the `lib`
+      # directory.
+      def hooks_file
+        @hook_file ||= spec.full_require_paths.collect do |path|
+          f = ::File.join(path, HOOK_FILE)
+          ::File.exist?(f) ? f : nil
+        end.compact.first
+      end
+
+      def has_hooks?
+        !hooks_file.nil?
+      end
+
+      def execute_hooks!
+        require hooks_file
+      end
+    end
+
+    class PluginSpecification
+      attr_reader :type, :name, :klass
+
+      def initialize(type, name, klass)
+        @type  = type.to_sym
+        @name  = name
+        @klass = klass
+      end
+    end
+
+    class UniversalPluginSpecification < PluginSpecification
+      def initialize(type, name, klass)
+        super(type, name, klass)
+        @instance = klass.new
+      end
+
+      def register(hooks, settings)
+        @instance.register_hooks(hooks)
+        @instance.additionals_settings(settings)
+      end
+    end
+
+    attr_reader :hooks
+
+    def initialize
+      @registry = {}
+      @hooks = HooksRegistry.new
+    end
+
+    def setup!
+      load_available_plugins
+      execute_universal_plugins
+    end
+
+    def execute_universal_plugins
+      @registry.values
+        .select { |specification| specification.is_a?(UniversalPluginSpecification) }
+        .each { |specification| specification.register(hooks, LogStash::SETTINGS) }
+    end
+
+    def plugins_with_type(type)
+      @registry.values.select { |specification| specification.type.to_sym == type.to_sym }.collect(&:klass)
+    end
+
+    def load_available_plugins
+      GemRegistry.logstash_plugins.each do |plugin_context|
+        # When a plugin has a HOOK_FILE defined, its the responsibility of the plugin
+        # to register itself to the registry of available plugins.
+        #
+        # Legacy plugin will lazy register themselves
+        if plugin_context.has_hooks?
+          begin
+            logger.debug("Executing hooks", :name => plugin_context.name, :type => plugin_context.type, :hooks_file => plugin_context.hooks_file)
+            plugin_context.execute_hooks!
+          rescue => e
+            logger.error("error occured when loading plugins hooks file", :name => plugin_context.name, :type => plugin_context.type, :exception => e.message, :stacktrace => e.backtrace )
+          end
+        end
+      end
+    end
+
+    def lookup(type, plugin_name, &block)
+      plugin = get(type, plugin_name)
+      # Assume that we have a legacy plugin
+      if plugin.nil?
+        plugin = legacy_lookup(type, plugin_name)
+      end
+
+      if block_given? # if provided pass a block to do validation
+        raise LoadError, "Block validation fails for plugin named #{plugin_name} of type #{type}," unless block.call(plugin.klass, plugin_name)
+      end
+
+      return plugin.klass
+    end
+
+    # The legacy_lookup method uses the 1.5->5.0 file structure to find and match
+    # a plugin and will do a lookup on the namespace of the required class to find a matching
+    # plugin with the appropriate type.
+    def legacy_lookup(type, plugin_name)
+      begin
+        path = "logstash/#{type}s/#{plugin_name}"
+
+        begin
+          require path
+        rescue LoadError
+          # Plugin might be already defined in the current scope
+          # This scenario often happen in test when we write an adhoc class
+        end
+
+        klass = namespace_lookup(type, plugin_name)
+        plugin = lazy_add(type, plugin_name, klass)
+      rescue => e
+        logger.error("Problems loading a plugin with",
+                    :type => type,
+                    :name => plugin_name,
+                    :path => path,
+                    :error_message => e.message,
+                    :error_class => e.class,
+                    :error_backtrace => e.backtrace)
+
+        raise LoadError, "Problems loading the requested plugin named #{plugin_name} of type #{type}. Error: #{e.class} #{e.message}"
+      end
+
+      plugin
+    end
+
+    def lookup_pipeline_plugin(type, name)
+      LogStash::PLUGIN_REGISTRY.lookup(type, name) do |plugin_klass, plugin_name|
+        is_a_plugin?(plugin_klass, plugin_name)
+      end
+    rescue LoadError, NameError => e
+      logger.debug("Problems loading the plugin with", :type => type, :name => name)
+      raise(LogStash::PluginLoadingError, I18n.t("logstash.pipeline.plugin-loading-error", :type => type, :name => name, :error => e.to_s))
+    end
+
+    def lazy_add(type, name, klass)
+      logger.debug("On demand adding plugin to the registry", :name => name, :type => type, :class => klass)
+      add_plugin(type, name, klass)
+    end
+
+    def add(type, name, klass)
+      logger.debug("Adding plugin to the registry", :name => name, :type => type, :class => klass)
+      add_plugin(type, name, klass)
+    end
+
+    def get(type, plugin_name)
+      @registry[key_for(type, plugin_name)]
+    end
+
+    def exists?(type, name)
+      @registry.include?(key_for(type, name))
+    end
+
+    def size
+      @registry.size
+    end
+
+    private
+    # lookup a plugin by type and name in the existing LogStash module namespace
+    # ex.: namespace_lookup("filter", "grok") looks for LogStash::Filters::Grok
+    # @param type [String] plugin type, "input", "output", "filter"
+    # @param name [String] plugin name, ex.: "grok"
+    # @return [Class] the plugin class or raises NameError
+    # @raise NameError if plugin class does not exist or is invalid
+    def namespace_lookup(type, name)
+      type_const = "#{type.capitalize}s"
+      namespace = LogStash.const_get(type_const)
+      # the namespace can contain constants which are not for plugins classes (do not respond to :config_name)
+      # namespace.constants is the shallow collection of all constants symbols in namespace
+      # note that below namespace.const_get(c) should never result in a NameError since c is from the constants collection
+      klass_sym = namespace.constants.find { |c| is_a_plugin?(namespace.const_get(c), name) }
+      klass = klass_sym && namespace.const_get(klass_sym)
+
+      raise(NameError) unless klass
+      klass
+    end
+
+    # check if klass is a valid plugin for name
+    # @param klass [Class] plugin class
+    # @param name [String] plugin name
+    # @return [Boolean] true if klass is a valid plugin for name
+    def is_a_plugin?(klass, name)
+      klass.ancestors.include?(LogStash::Plugin) && klass.respond_to?(:config_name) && klass.config_name == name
+    end
+
+    def add_plugin(type, name, klass)
+      if !exists?(type, name)
+        specification_klass = type == :universal ? UniversalPluginSpecification : PluginSpecification
+        @registry[key_for(type, name)] = specification_klass.new(type, name, klass)
+      else
+        logger.debug("Ignoring, plugin already added to the registry", :name => name, :type => type, :klass => klass)
+      end
+    end
+
+    def key_for(type, plugin_name)
+      "#{type}-#{plugin_name}"
+    end
+  end end
+
+  PLUGIN_REGISTRY = Plugins::Registry.new
+end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/runner.rb

@@ -0,0 +1,484 @@
+# encoding: utf-8
+Thread.abort_on_exception = true
+Encoding.default_external = Encoding::UTF_8
+$DEBUGLIST = (ENV["DEBUG"] || "").split(",")
+
+require "clamp"
+require "net/http"
+
+require "logstash/namespace"
+require "logstash-core/logstash-core"
+require "logstash/environment"
+require "logstash/modules/cli_parser"
+
+LogStash::Environment.load_locale!
+
+require "logstash/agent"
+require "logstash/config/defaults"
+require "logstash/config/modules_common"
+require "logstash/shutdown_watcher"
+require "logstash/patches/clamp"
+require "logstash/settings"
+require "logstash/version"
+require "logstash/plugins/registry"
+
+java_import 'org.logstash.FileLockFactory'
+
+def register_local_modules(path)
+  modules_path = File.join(path, File::Separator, "modules")
+  Dir.foreach(modules_path) do |item|
+    # Ignore unix relative path ids
+    next if item == '.' or item == '..'
+    # Ignore non-directories
+    next if !File.directory?(File.join(modules_path, File::Separator, item))
+    LogStash::PLUGIN_REGISTRY.add(:modules, item, LogStash::Modules::Scaffold.new(item, File.join(modules_path, File::Separator, item, File::Separator, "configuration")))
+  end
+end
+
+class LogStash::Runner < Clamp::StrictCommand
+  include LogStash::Util::Loggable
+  # The `path.settings` and `path.logs` need to be defined in the runner instead of the `logstash-core/lib/logstash/environment.rb`
+  # because the `Environment::LOGSTASH_HOME` doesn't exist in the context of the `logstash-core` gem.
+  #
+  # See issue https://github.com/elastic/logstash/issues/5361
+  LogStash::SETTINGS.register(LogStash::Setting::String.new("path.settings", ::File.join(LogStash::Environment::LOGSTASH_HOME, "config")))
+  LogStash::SETTINGS.register(LogStash::Setting::String.new("path.logs", ::File.join(LogStash::Environment::LOGSTASH_HOME, "logs")))
+
+  # Node Settings
+  option ["-n", "--node.name"], "NAME",
+    I18n.t("logstash.runner.flag.name"),
+    :attribute_name => "node.name",
+    :default => LogStash::SETTINGS.get_default("node.name")
+
+  # Config Settings
+  option ["-f", "--path.config"], "CONFIG_PATH",
+    I18n.t("logstash.runner.flag.config"),
+    :attribute_name => "path.config"
+
+  option ["-e", "--config.string"], "CONFIG_STRING",
+    I18n.t("logstash.runner.flag.config-string",
+      :default_input => LogStash::Config::Defaults.input,
+      :default_output => LogStash::Config::Defaults.output),
+    :default => LogStash::SETTINGS.get_default("config.string"),
+    :attribute_name => "config.string"
+
+  # Module settings
+  option ["--modules"], "MODULES",
+    I18n.t("logstash.runner.flag.modules"),
+    :multivalued => true,
+    :attribute_name => "modules_list"
+
+  option ["-M", "--modules.variable"], "MODULES_VARIABLE",
+    I18n.t("logstash.runner.flag.modules_variable"),
+    :multivalued => true,
+    :attribute_name => "modules_variable_list"
+
+  # Pipeline settings
+  option ["-w", "--pipeline.workers"], "COUNT",
+    I18n.t("logstash.runner.flag.pipeline-workers"),
+    :attribute_name => "pipeline.workers",
+    :default => LogStash::SETTINGS.get_default("pipeline.workers")
+
+  option ["-b", "--pipeline.batch.size"], "SIZE",
+    I18n.t("logstash.runner.flag.pipeline-batch-size"),
+    :attribute_name => "pipeline.batch.size",
+    :default => LogStash::SETTINGS.get_default("pipeline.batch.size")
+
+  option ["-u", "--pipeline.batch.delay"], "DELAY_IN_MS",
+    I18n.t("logstash.runner.flag.pipeline-batch-delay"),
+    :attribute_name => "pipeline.batch.delay",
+    :default => LogStash::SETTINGS.get_default("pipeline.batch.delay")
+
+  option ["--pipeline.unsafe_shutdown"], :flag,
+    I18n.t("logstash.runner.flag.unsafe_shutdown"),
+    :attribute_name => "pipeline.unsafe_shutdown",
+    :default => LogStash::SETTINGS.get_default("pipeline.unsafe_shutdown")
+
+  # Data Path Setting
+  option ["--path.data"] , "PATH",
+    I18n.t("logstash.runner.flag.datapath"),
+    :attribute_name => "path.data",
+    :default => LogStash::SETTINGS.get_default("path.data")
+
+  # Plugins Settings
+  option ["-p", "--path.plugins"] , "PATH",
+    I18n.t("logstash.runner.flag.pluginpath"),
+    :multivalued => true, :attribute_name => "path.plugins",
+    :default => LogStash::SETTINGS.get_default("path.plugins")
+
+  # Logging Settings
+  option ["-l", "--path.logs"], "PATH",
+    I18n.t("logstash.runner.flag.log"),
+    :attribute_name => "path.logs",
+    :default => LogStash::SETTINGS.get_default("path.logs")
+
+  option "--log.level", "LEVEL", I18n.t("logstash.runner.flag.log_level"),
+    :default => LogStash::SETTINGS.get_default("log.level"),
+    :attribute_name => "log.level"
+
+  option "--config.debug", :flag,
+    I18n.t("logstash.runner.flag.config_debug"),
+    :default => LogStash::SETTINGS.get_default("config.debug"),
+    :attribute_name => "config.debug"
+
+  # Other settings
+  option ["-i", "--interactive"], "SHELL",
+    I18n.t("logstash.runner.flag.rubyshell"),
+    :attribute_name => "interactive"
+
+  option ["-V", "--version"], :flag,
+    I18n.t("logstash.runner.flag.version")
+
+  option ["-t", "--config.test_and_exit"], :flag,
+    I18n.t("logstash.runner.flag.configtest"),
+    :attribute_name => "config.test_and_exit",
+    :default => LogStash::SETTINGS.get_default("config.test_and_exit")
+
+  option ["-r", "--config.reload.automatic"], :flag,
+    I18n.t("logstash.runner.flag.auto_reload"),
+    :attribute_name => "config.reload.automatic",
+    :default => LogStash::SETTINGS.get_default("config.reload.automatic")
+
+  option ["--config.reload.interval"], "RELOAD_INTERVAL",
+    I18n.t("logstash.runner.flag.reload_interval"),
+    :attribute_name => "config.reload.interval",
+    :default => LogStash::SETTINGS.get_default("config.reload.interval")
+
+  option ["--http.host"], "HTTP_HOST",
+    I18n.t("logstash.runner.flag.http_host"),
+    :attribute_name => "http.host",
+    :default => LogStash::SETTINGS.get_default("http.host")
+
+  option ["--http.port"], "HTTP_PORT",
+    I18n.t("logstash.runner.flag.http_port"),
+    :attribute_name => "http.port",
+    :default => LogStash::SETTINGS.get_default("http.port")
+
+  option ["--log.format"], "FORMAT",
+    I18n.t("logstash.runner.flag.log_format"),
+    :attribute_name => "log.format",
+    :default => LogStash::SETTINGS.get_default("log.format")
+
+  option ["--path.settings"], "SETTINGS_DIR",
+    I18n.t("logstash.runner.flag.path_settings"),
+    :attribute_name => "path.settings",
+    :default => LogStash::SETTINGS.get_default("path.settings")
+
+  ### DEPRECATED FLAGS ###
+  deprecated_option ["--verbose"], :flag,
+    I18n.t("logstash.runner.flag.verbose"),
+    :new_flag => "log.level", :new_value => "info"
+
+  deprecated_option ["--debug"], :flag,
+    I18n.t("logstash.runner.flag.debug"),
+    :new_flag => "log.level", :new_value => "debug"
+
+  deprecated_option ["--quiet"], :flag,
+    I18n.t("logstash.runner.flag.quiet"),
+    :new_flag => "log.level", :new_value => "error"
+
+  attr_reader :agent
+
+  def initialize(*args)
+    @settings = LogStash::SETTINGS
+    super(*args)
+  end
+
+  def run(args)
+    settings_path = fetch_settings_path(args)
+
+    @settings.set("path.settings", settings_path) if settings_path
+
+    begin
+      LogStash::SETTINGS.from_yaml(LogStash::SETTINGS.get("path.settings"))
+    rescue Errno::ENOENT
+      $stderr.puts "WARNING: Could not find logstash.yml which is typically located in $LS_HOME/config or /etc/logstash. You can specify the path using --path.settings. Continuing using the defaults"
+    rescue => e
+      # abort unless we're just looking for the help
+      unless cli_help?(args)
+        if e.kind_of?(Psych::Exception)
+          yaml_file_path = ::File.join(LogStash::SETTINGS.get("path.settings"), "logstash.yml")
+          $stderr.puts "ERROR: Failed to parse YAML file \"#{yaml_file_path}\". Please confirm if the YAML structure is valid (e.g. look for incorrect usage of whitespace or indentation). Aborting... parser_error=>#{e.message}"
+        else
+          $stderr.puts "ERROR: Failed to load settings file from \"path.settings\". Aborting... path.setting=#{LogStash::SETTINGS.get("path.settings")}, exception=#{e.class}, message=>#{e.message}"
+        end
+        return 1
+      end
+    end
+
+    super(*[args])
+  end
+
+  def execute
+    # Only when execute is have the CLI options been added to the @settings
+    # We invoke post_process to apply extra logic to them.
+    # The post_process callbacks have been added in environment.rb
+    @settings.post_process
+
+    require "logstash/util"
+    require "logstash/util/java_version"
+    require "stud/task"
+
+    # Configure Logstash logging facility, this need to be done before everything else to
+    # make sure the logger has the correct settings and the log level is correctly defined.
+    java.lang.System.setProperty("ls.logs", setting("path.logs"))
+    java.lang.System.setProperty("ls.log.format", setting("log.format"))
+    java.lang.System.setProperty("ls.log.level", setting("log.level"))
+    unless java.lang.System.getProperty("log4j.configurationFile")
+      log4j_config_location = ::File.join(setting("path.settings"), "log4j2.properties")
+      LogStash::Logging::Logger::initialize("file:///" + log4j_config_location)
+    end
+    # override log level that may have been introduced from a custom log4j config file
+    LogStash::Logging::Logger::configure_logging(setting("log.level"))
+
+    if setting("config.debug") && !logger.debug?
+      logger.warn("--config.debug was specified, but log.level was not set to \'debug\'! No config info will be logged.")
+    end
+
+    # Add local modules to the registry before everything else
+    register_local_modules(LogStash::Environment::LOGSTASH_HOME)
+
+    # We configure the registry and load any plugin that can register hooks
+    # with logstash, this need to be done before any operation.
+    LogStash::PLUGIN_REGISTRY.setup!
+    @settings.validate_all
+
+    LogStash::Util::set_thread_name(self.class.name)
+
+    if RUBY_VERSION < "1.9.2"
+      logger.fatal "Ruby 1.9.2 or later is required. (You are running: " + RUBY_VERSION + ")"
+      return 1
+    end
+
+    # Exit on bad java versions
+    java_version = LogStash::Util::JavaVersion.version
+    if LogStash::Util::JavaVersion.bad_java_version?(java_version)
+      logger.fatal "Java version 1.8.0 or later is required. (You are running: #{java_version})"
+      return 1
+    end
+
+    module_parser = LogStash::Modules::CLIParser.new(@modules_list, @modules_variable_list)
+    # Now populate Setting for modules.list with our parsed array.
+    @settings.set("modules.cli", module_parser.output)
+
+    LogStash::ShutdownWatcher.unsafe_shutdown = setting("pipeline.unsafe_shutdown")
+
+    configure_plugin_paths(setting("path.plugins"))
+
+    if version?
+      show_version
+      return 0
+    end
+
+    return start_shell(setting("interactive"), binding) if setting("interactive")
+
+    @settings.format_settings.each {|line| logger.debug(line) }
+
+    module_configs = LogStash::Config::ModulesCommon.pipeline_configs(@settings)
+    module_config_hash = module_configs.first
+    if !module_config_hash.nil?
+      @settings.set_value("config.string", module_config_hash["config_string"])
+    end
+    if module_configs.size > 1
+      logger.warn "Multiple modules defined in logstash.yml - using the first one: #{module_config_hash["pipeline_id"]}"
+    end
+
+    if setting("config.string").nil? && setting("path.config").nil?
+      fail(I18n.t("logstash.runner.missing-configuration"))
+    end
+
+    if setting("config.reload.automatic") && setting("path.config").nil?
+      # there's nothing to reload
+      signal_usage_error(I18n.t("logstash.runner.reload-without-config-path"))
+    end
+
+    if setting("config.test_and_exit")
+      config_loader = LogStash::Config::Loader.new(logger)
+      config_str = config_loader.format_config(setting("path.config"), setting("config.string"))
+      begin
+        LogStash::BasePipeline.new(config_str)
+        puts "Configuration OK"
+        logger.info "Using config.test_and_exit mode. Config Validation Result: OK. Exiting Logstash"
+        return 0
+      rescue => e
+        logger.fatal I18n.t("logstash.runner.invalid-configuration", :error => e.message)
+        return 1
+      end
+    end
+
+    # lock path.data before starting the agent
+    @data_path_lock = FileLockFactory.getDefault().obtainLock(setting("path.data"), ".lock");
+
+    @agent = create_agent(@settings)
+
+    @agent.register_pipeline(@settings)
+
+    # enable sigint/sigterm before starting the agent
+    # to properly handle a stalled agent
+    sigint_id = trap_sigint()
+    sigterm_id = trap_sigterm()
+
+    @agent_task = Stud::Task.new { @agent.execute }
+
+    # no point in enabling config reloading before the agent starts
+    # also windows doesn't have SIGHUP. we can skip it
+    sighup_id = LogStash::Environment.windows? ? nil : trap_sighup()
+
+    agent_return = @agent_task.wait
+
+    @agent.shutdown
+
+    # flush any outstanding log messages during shutdown
+    org.apache.logging.log4j.LogManager.shutdown
+
+    agent_return
+
+  rescue org.logstash.LockException => e
+    logger.fatal(I18n.t("logstash.runner.locked-data-path", :path => setting("path.data")))
+    return 1
+  rescue Clamp::UsageError => e
+    $stderr.puts "ERROR: #{e.message}"
+    show_short_help
+    return 1
+  rescue => e
+    # if logger itself is not initialized
+    if LogStash::Logging::Logger.get_logging_context.nil?
+      $stderr.puts "#{I18n.t("oops")} :error => #{e}, :backtrace => #{e.backtrace}"
+    else
+      logger.fatal(I18n.t("oops"), :error => e, :backtrace => e.backtrace)
+    end
+    return 1
+  ensure
+    Stud::untrap("INT", sigint_id) unless sigint_id.nil?
+    Stud::untrap("TERM", sigterm_id) unless sigterm_id.nil?
+    Stud::untrap("HUP", sighup_id) unless sighup_id.nil?
+    FileLockFactory.getDefault().releaseLock(@data_path_lock) if @data_path_lock
+    @log_fd.close if @log_fd
+  end # def self.main
+
+  def show_version
+    show_version_logstash
+
+    if logger.info?
+      show_version_ruby
+      show_version_java if LogStash::Environment.jruby?
+      show_gems if logger.debug?
+    end
+  end # def show_version
+
+  def show_version_logstash
+    puts "logstash #{LOGSTASH_VERSION}"
+  end # def show_version_logstash
+
+  def show_version_ruby
+    puts RUBY_DESCRIPTION
+  end # def show_version_ruby
+
+  def show_version_java
+    properties = java.lang.System.getProperties
+    puts "java #{properties["java.version"]} (#{properties["java.vendor"]})"
+    puts "jvm #{properties["java.vm.name"]} / #{properties["java.vm.version"]}"
+  end # def show_version_java
+
+  def show_gems
+    require "rubygems"
+    Gem::Specification.each do |spec|
+      puts "gem #{spec.name} #{spec.version}"
+    end
+  end # def show_gems
+
+  # add the given paths for ungemified/bare plugins lookups
+  # @param paths [String, Array<String>] plugins path string or list of path strings to add
+  def configure_plugin_paths(paths)
+    Array(paths).each do |path|
+      fail(I18n.t("logstash.runner.configuration.plugin_path_missing", :path => path)) unless File.directory?(path)
+      LogStash::Environment.add_plugin_path(path)
+    end
+  end
+
+  def create_agent(*args)
+    LogStash::Agent.new(*args)
+  end
+
+  # Emit a failure message and abort.
+  def fail(message)
+    signal_usage_error(message)
+  end # def fail
+
+  def show_short_help
+    puts I18n.t("logstash.runner.short-help")
+  end
+
+  def start_shell(shell, start_binding)
+    case shell
+    when "pry"
+      require 'pry'
+      start_binding.pry
+    when "irb"
+      require 'irb'
+      ARGV.clear
+      # TODO: set binding to this instance of Runner
+      # currently bugged as per https://github.com/jruby/jruby/issues/384
+      IRB.start(__FILE__)
+    else
+      fail(I18n.t("logstash.runner.invalid-shell"))
+    end
+  end
+
+  def trap_sighup
+    Stud::trap("HUP") do
+      logger.warn(I18n.t("logstash.agent.sighup"))
+      @agent.reload_state!
+    end
+  end
+
+  def trap_sigterm
+    Stud::trap("TERM") do
+      logger.warn(I18n.t("logstash.agent.sigterm"))
+      @agent_task.stop!
+    end
+  end
+
+  def trap_sigint
+    Stud::trap("INT") do
+      if @interrupted_once
+        logger.fatal(I18n.t("logstash.agent.forced_sigint"))
+        exit
+      else
+        logger.warn(I18n.t("logstash.agent.sigint"))
+        Thread.new(logger) {|lg| sleep 5; lg.warn(I18n.t("logstash.agent.slow_shutdown")) }
+        @interrupted_once = true
+        @agent_task.stop!
+      end
+    end
+  end
+
+  def setting(key)
+    @settings.get_value(key)
+  end
+
+  # where can I find the logstash.yml file?
+  # 1. look for a "--path.settings path"
+  # 2. look for a "--path.settings=path"
+  # 3. check if the LS_SETTINGS_DIR environment variable is set
+  # 4. return nil if not found
+  def fetch_settings_path(cli_args)
+    if i=cli_args.find_index("--path.settings")
+      cli_args[i+1]
+    elsif settings_arg = cli_args.find {|v| v.match(/--path.settings=/) }
+      match = settings_arg.match(/--path.settings=(.*)/)
+      match[1]
+    elsif ENV['LS_SETTINGS_DIR']
+      ENV['LS_SETTINGS_DIR']
+    else
+      nil
+    end
+  end
+
+  # is the user asking for CLI help subcommand?
+  def cli_help?(args)
+    # I know, double negative
+    !(["--help", "-h"] & args).empty?
+  end
+
+end