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-core/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# The version of logstash core gem.
+#
+# Note to authors: this should not include dashes because 'gem' barfs if
+# you include a dash in the version string.
+
+LOGSTASH_CORE_VERSION = "5.5.0"

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/api/commands/hot_threads_reporter.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+java_import 'org.logstash.instrument.reports.ThreadsReport'
+
+class HotThreadsReport
+  STRING_SEPARATOR_LENGTH = 80.freeze
+  HOT_THREADS_STACK_TRACES_SIZE_DEFAULT = 10.freeze
+
+  def initialize(cmd, options)
+    @cmd = cmd
+    filter = { :stacktrace_size => options.fetch(:stacktrace_size, HOT_THREADS_STACK_TRACES_SIZE_DEFAULT) }
+    @thread_dump = ::LogStash::Util::ThreadDump.new(options.merge(:dump => ThreadsReport.generate(filter)))
+  end
+
+  def to_s
+    hash = to_hash[:hot_threads]
+    report =  "#{I18n.t("logstash.web_api.hot_threads.title", :hostname => hash[:hostname], :time => hash[:time], :top_count => @thread_dump.top_count )} \n"
+    report << '=' * STRING_SEPARATOR_LENGTH
+    report << "\n"
+    hash[:threads].each do |thread|
+      thread_report = "#{I18n.t("logstash.web_api.hot_threads.thread_title", :percent_of_cpu_time => thread[:percent_of_cpu_time], :thread_state => thread[:state], :thread_name => thread[:name])} \n"
+      thread_report << "#{thread[:path]}\n" if thread[:path]
+      thread[:traces].each do |trace|
+        thread_report << "\t#{trace}\n"
+      end
+      report << thread_report
+      report << '-' * STRING_SEPARATOR_LENGTH
+      report << "\n"
+    end
+    report
+  end
+
+  def to_hash
+    hash = { :time => Time.now.iso8601, :busiest_threads => @thread_dump.top_count, :threads => [] }
+    @thread_dump.each do |thread_name, _hash|
+      thread_name, thread_path = _hash["thread.name"].split(": ")
+      thread = { :name => thread_name,
+                 :percent_of_cpu_time => cpu_time_as_percent(_hash),
+                 :state => _hash["thread.state"]
+      }
+      thread[:path] = thread_path if thread_path
+      traces = []
+      _hash["thread.stacktrace"].each do |trace|
+        traces << trace
+      end
+      thread[:traces] = traces
+      hash[:threads] << thread
+    end
+    { :hot_threads => hash }
+  end
+
+  def cpu_time_as_percent(hash)
+    (((cpu_time(hash) / @cmd.uptime * 1.0)*10000).to_i)/100.0
+  end
+
+  def cpu_time(hash)
+    hash["cpu.time"] / 1000000.0
+  end
+end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/api/commands/node.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require "logstash/api/commands/base"
+require_relative "hot_threads_reporter"
+
+module LogStash
+  module Api
+    module Commands
+      class Node < Commands::Base
+
+        def all(selected_fields=[])
+          payload = {
+            :pipeline => pipeline,
+            :os => os,
+            :jvm => jvm
+          }
+          payload.select! { |k,v| selected_fields.include?(k) } unless selected_fields.empty?
+          payload
+        end
+
+        def pipeline(pipeline_id = LogStash::SETTINGS.get("pipeline.id").to_sym)
+          stats = extract_metrics(
+            [:stats, :pipelines, pipeline_id, :config],
+            :workers, :batch_size, :batch_delay, :config_reload_automatic, :config_reload_interval
+          )
+          stats.merge(:id => pipeline_id)
+        end
+
+        def os
+          {
+            :name => java.lang.System.getProperty("os.name"),
+            :arch => java.lang.System.getProperty("os.arch"),
+            :version => java.lang.System.getProperty("os.version"),
+            :available_processors => java.lang.Runtime.getRuntime().availableProcessors()
+          }
+        end
+
+        def jvm
+          memory_bean = ManagementFactory.getMemoryMXBean()
+
+          {
+            :pid =>  ManagementFactory.getRuntimeMXBean().getName().split("@").first.to_i,
+            :version => java.lang.System.getProperty("java.version"),
+            :vm_version => java.lang.System.getProperty("java.version"),
+            :vm_vendor => java.lang.System.getProperty("java.vendor"),
+            :vm_name => java.lang.System.getProperty("java.vm.name"),
+            :start_time_in_millis => started_at,
+            :mem => {
+              :heap_init_in_bytes => (memory_bean.getHeapMemoryUsage().getInit() < 0 ? 0 : memory_bean.getHeapMemoryUsage().getInit()),
+              :heap_max_in_bytes => (memory_bean.getHeapMemoryUsage().getMax() < 0 ? 0 : memory_bean.getHeapMemoryUsage().getMax()),
+              :non_heap_init_in_bytes => (memory_bean.getNonHeapMemoryUsage().getInit() < 0 ? 0 : memory_bean.getNonHeapMemoryUsage().getInit()),
+              :non_heap_max_in_bytes => (memory_bean.getNonHeapMemoryUsage().getMax() < 0 ? 0 : memory_bean.getNonHeapMemoryUsage().getMax())
+            },
+            :gc_collectors => ManagementFactory.getGarbageCollectorMXBeans().collect(&:getName)
+          }
+        end
+
+        def hot_threads(options={})
+          HotThreadsReport.new(self, options)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.5.0-java/lib/logstash/api/commands/stats.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+require "logstash/api/commands/base"
+require 'logstash/util/thread_dump'
+require_relative "hot_threads_reporter"
+
+java_import java.nio.file.Files
+java_import java.nio.file.Paths
+
+module LogStash
+  module Api
+    module Commands
+      class Stats < Commands::Base
+        def jvm
+          {
+            :threads => extract_metrics(
+              [:jvm, :threads],
+              :count,
+              :peak_count
+            ),
+            :mem => memory,
+            :gc => gc,
+            :uptime_in_millis => service.get_shallow(:jvm, :uptime_in_millis),
+          }
+        end
+
+        def reloads
+          service.get_shallow(:stats, :reloads)
+        end
+
+        def process
+          extract_metrics(
+            [:jvm, :process],
+            :open_file_descriptors,
+            :peak_open_file_descriptors,
+            :max_file_descriptors,
+            [:mem, [:total_virtual_in_bytes]],
+            [:cpu, [:total_in_millis, :percent, :load_average]]
+          )
+        end
+
+        def events
+          extract_metrics(
+            [:stats, :events],
+            :in, :filtered, :out, :duration_in_millis
+          )
+        end
+
+        def pipeline(pipeline_id = LogStash::SETTINGS.get("pipeline.id").to_sym)
+          stats = service.get_shallow(:stats, :pipelines, pipeline_id)
+          stats = PluginsStats.report(stats)
+          stats.merge(:id => pipeline_id)
+        end
+
+        def memory
+          memory = service.get_shallow(:jvm, :memory)
+          {
+            :heap_used_percent => memory[:heap][:used_percent],
+            :heap_committed_in_bytes => memory[:heap][:committed_in_bytes],
+            :heap_max_in_bytes => memory[:heap][:max_in_bytes],
+            :heap_used_in_bytes => memory[:heap][:used_in_bytes],
+            :non_heap_used_in_bytes => memory[:non_heap][:used_in_bytes],
+            :non_heap_committed_in_bytes => memory[:non_heap][:committed_in_bytes],
+            :pools => memory[:pools].inject({}) do |acc, (type, hash)|
+              hash.delete("committed_in_bytes")
+              acc[type] = hash
+              acc
+            end
+          }
+        end
+
+        def os
+          service.get_shallow(:os)
+        rescue
+          # The only currently fetch OS information is about the linux
+          # containers.
+          {}
+        end
+
+        def gc
+          service.get_shallow(:jvm, :gc)
+        end
+
+        def hot_threads(options={})
+          HotThreadsReport.new(self, options)
+        end
+
+        module PluginsStats
+          module_function
+
+          def plugin_stats(stats, plugin_type)
+            # Turn the `plugins` stats hash into an array of [ {}, {}, ... ]
+            # This is to produce an array of data points, one point for each
+            # plugin instance.
+            return [] unless stats[:plugins] && stats[:plugins].include?(plugin_type)
+            stats[:plugins][plugin_type].collect do |id, data|
+              { :id => id }.merge(data)
+            end
+          end
+
+          def report(stats)
+            {
+              :events => stats[:events],
+              :plugins => {
+                :inputs => plugin_stats(stats, :inputs),
+                :filters => plugin_stats(stats, :filters),
+                :outputs => plugin_stats(stats, :outputs)
+              },
+              :reloads => stats[:reloads],
+              :queue => stats[:queue]
+            }
+          end
+        end # module PluginsStats
+      end
+    end
+  end
+end

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

@@ -0,0 +1,566 @@
+# encoding: utf-8
+require "logstash/namespace"
+require "logstash/plugins/registry"
+require "logstash/logging"
+require "logstash/util/password"
+require "logstash/util/safe_uri"
+require "logstash/version"
+require "logstash/environment"
+require "logstash/util/plugin_version"
+require "filesize"
+
+LogStash::Environment.load_locale!
+
+# This module is meant as a mixin to classes wishing to be configurable from
+# config files
+#
+# The idea is that you can do this:
+#
+# class Foo < LogStash::Config
+#   # Add config file settings
+#   config "path" => ...
+#   config "tag" => ...
+#
+#   # Add global flags (becomes --foo-bar)
+#   flag "bar" => ...
+# end
+#
+# And the config file should let you do:
+#
+# foo {
+#   "path" => ...
+#   "tag" => ...
+# }
+#
+module LogStash::Config::Mixin
+  
+  include LogStash::Util::EnvironmentVariables
+  
+  attr_accessor :config
+  attr_accessor :original_params
+
+  PLUGIN_VERSION_1_0_0 = LogStash::Util::PluginVersion.new(1, 0, 0)
+  PLUGIN_VERSION_0_9_0 = LogStash::Util::PluginVersion.new(0, 9, 0)
+  
+  # This method is called when someone does 'include LogStash::Config'
+  def self.included(base)
+    # Add the DSL methods to the 'base' given.
+    base.extend(LogStash::Config::Mixin::DSL)
+  end
+  
+  def config_init(params)
+    # Validation will modify the values inside params if necessary.
+    # For example: converting a string to a number, etc.
+
+    # Keep a copy of the original config params so that we can later
+    # differentiate between explicit configuration and implicit (default)
+    # configuration.
+    original_params = params.clone
+
+    # store the plugin type, turns LogStash::Inputs::Base into 'input'
+    @plugin_type = self.class.ancestors.find { |a| a.name =~ /::Base$/ }.config_name
+
+    # warn about deprecated variable use
+    params.each do |name, value|
+      opts = self.class.get_config[name]
+      if opts && opts[:deprecated]
+        extra = opts[:deprecated].is_a?(String) ? opts[:deprecated] : ""
+        extra.gsub!("%PLUGIN%", self.class.config_name)
+        self.logger.warn("You are using a deprecated config setting " +
+                     "#{name.inspect} set in #{self.class.config_name}. " +
+                     "Deprecated settings will continue to work, " +
+                     "but are scheduled for removal from logstash " +
+                     "in the future. #{extra} If you have any questions " +
+                     "about this, please visit the #logstash channel " +
+                     "on freenode irc.", :name => name, :plugin => self)
+
+      end
+      if opts && opts[:obsolete]
+        extra = opts[:obsolete].is_a?(String) ? opts[:obsolete] : ""
+        extra.gsub!("%PLUGIN%", self.class.config_name)
+        raise LogStash::ConfigurationError,
+          I18n.t("logstash.runner.configuration.obsolete", :name => name,
+                 :plugin => self.class.config_name, :extra => extra)
+      end
+    end
+
+    # Set defaults from 'config :foo, :default => somevalue'
+    self.class.get_config.each do |name, opts|
+      next if params.include?(name.to_s)
+      if opts.include?(:default) and (name.is_a?(Symbol) or name.is_a?(String))
+        # default values should be cloned if possible
+        # cloning prevents
+        case opts[:default]
+          when FalseClass, TrueClass, NilClass, Numeric
+            params[name.to_s] = opts[:default]
+          else
+            params[name.to_s] = opts[:default].clone
+        end
+      end
+
+      # Allow plugins to override default values of config settings
+      if self.class.default?(name)
+        params[name.to_s] = self.class.get_default(name)
+      end
+    end
+
+    # Resolve environment variables references
+    params.each do |name, value|
+      params[name.to_s] = deep_replace(value)
+    end
+
+
+    if !self.class.validate(params)
+      raise LogStash::ConfigurationError,
+        I18n.t("logstash.runner.configuration.invalid_plugin_settings")
+    end
+
+    # We remove any config options marked as obsolete,
+    # no code should be associated to them and their values should not bleed
+    # to the plugin context.
+    #
+    # This need to be done after fetching the options from the parents classed
+    params.reject! do |name, value|
+      opts = self.class.get_config[name]
+      opts.include?(:obsolete)
+    end
+
+    # set instance variables like '@foo'  for each config value given.
+    params.each do |key, value|
+      next if key[0, 1] == "@"
+
+      # Set this key as an instance variable only if it doesn't start with an '@'
+      self.logger.debug("config #{self.class.name}/@#{key} = #{value.inspect}")
+      instance_variable_set("@#{key}", value)
+    end
+
+    # now that we know the parameters are valid, we can obfuscate the original copy
+    # of the parameters before storing them as an instance variable
+    self.class.secure_params!(original_params)
+    @original_params = original_params
+
+    @config = params
+  end # def config_init
+
+  module DSL
+
+    include LogStash::Util::EnvironmentVariables
+
+    attr_accessor :flags
+
+    # If name is given, set the name and return it.
+    # If no name given (nil), return the current name.
+    def config_name(name = nil)
+      @config_name = name if !name.nil?
+      @config_name
+    end
+    alias_method :config_plugin, :config_name
+
+    # Deprecated: Declare the version of the plugin
+    # inside the gemspec.
+    def plugin_status(status = nil)
+      milestone(status)
+    end
+
+    # Deprecated: Declare the version of the plugin
+    # inside the gemspec.
+    def milestone(m = nil)
+      self.logger.debug(I18n.t('logstash.plugin.deprecated_milestone', :plugin => config_name))
+    end
+
+    # Define a new configuration setting
+    def config(name, opts={})
+      @config ||= Hash.new
+      # TODO(sissel): verify 'name' is of type String, Symbol, or Regexp
+
+      name = name.to_s if name.is_a?(Symbol)
+      @config[name] = opts  # ok if this is empty
+
+      if name.is_a?(String)
+        define_method(name) { instance_variable_get("@#{name}") }
+        define_method("#{name}=") { |v| instance_variable_set("@#{name}", v) }
+      end
+    end # def config
+
+    def default(name, value)
+      @defaults ||= {}
+      @defaults[name.to_s] = value
+    end
+
+    def get_config
+      return @config
+    end # def get_config
+
+    def get_default(name)
+      return @defaults && @defaults[name]
+    end
+
+    def default?(name)
+      return @defaults && @defaults.include?(name)
+    end
+
+    def options(opts)
+      # add any options from this class
+      prefix = self.name.split("::").last.downcase
+      @flags.each do |flag|
+        flagpart = flag[:args].first.gsub(/^--/,"")
+        # TODO(sissel): logger things here could help debugging.
+
+        opts.on("--#{prefix}-#{flagpart}", *flag[:args][1..-1], &flag[:block])
+      end
+    end # def options
+
+    # This is called whenever someone subclasses a class that has this mixin.
+    def inherited(subclass)
+      # Copy our parent's config to a subclass.
+      # This method is invoked whenever someone subclasses us, like:
+      # class Foo < Bar ...
+      subconfig = Hash.new
+      if !@config.nil?
+        @config.each do |key, val|
+          subconfig[key] = val
+        end
+      end
+      subclass.instance_variable_set("@config", subconfig)
+      @@version_notice_given = false
+    end # def inherited
+
+    def validate(params)
+      @plugin_name = config_name
+      @plugin_type = ancestors.find { |a| a.name =~ /::Base$/ }.config_name
+      is_valid = true
+
+      print_version_notice
+
+      is_valid &&= validate_check_invalid_parameter_names(params)
+      is_valid &&= validate_check_required_parameter_names(params)
+      is_valid &&= validate_check_parameter_values(params)
+
+      return is_valid
+    end # def validate
+
+    # TODO: Remove in 6.0
+    def print_version_notice
+      return if @@version_notice_given
+
+      begin
+        plugin_version = LogStash::Util::PluginVersion.find_plugin_version!(@plugin_type, @config_name)
+
+        if plugin_version < PLUGIN_VERSION_1_0_0
+          if plugin_version < PLUGIN_VERSION_0_9_0
+            self.logger.info(I18n.t("logstash.plugin.version.0-1-x",
+                                :type => @plugin_type,
+                                :name => @config_name,
+                                :LOGSTASH_VERSION => LOGSTASH_VERSION))
+          else
+            self.logger.info(I18n.t("logstash.plugin.version.0-9-x",
+                                :type => @plugin_type,
+                                :name => @config_name,
+                                :LOGSTASH_VERSION => LOGSTASH_VERSION))
+          end
+        end
+      rescue LogStash::PluginNoVersionError
+        # This can happen because of one of the following:
+        # - The plugin is loaded from the plugins.path and contains no gemspec.
+        # - The plugin is defined in a universal plugin, so the loaded plugin doesn't correspond to an actual gemspec.
+      ensure
+        @@version_notice_given = true
+      end
+    end
+
+    def validate_check_invalid_parameter_names(params)
+      invalid_params = params.keys
+      # Filter out parameters that match regexp keys.
+      # These are defined in plugins like this:
+      #   config /foo.*/ => ...
+      @config.each_key do |config_key|
+        if config_key.is_a?(Regexp)
+          invalid_params.reject! { |k| k =~ config_key }
+        elsif config_key.is_a?(String)
+          invalid_params.reject! { |k| k == config_key }
+        end
+      end
+
+      if invalid_params.size > 0
+        invalid_params.each do |name|
+          self.logger.error("Unknown setting '#{name}' for #{@plugin_name}")
+        end
+        return false
+      end # if invalid_params.size > 0
+      return true
+    end # def validate_check_invalid_parameter_names
+
+    def validate_check_required_parameter(config_key, config_opts, k, v)
+      if config_key.is_a?(Regexp)
+        (k =~ config_key && v)
+      elsif config_key.is_a?(String)
+        k && v
+      end
+    end
+
+    def validate_check_required_parameter_names(params)
+      is_valid = true
+
+      @config.each do |config_key, config|
+        next unless config[:required]
+
+        if config_key.is_a?(Regexp) && !params.keys.any? { |k| k =~ config_key }
+          is_valid = false
+        end
+
+        value = params[config_key]
+        if value.nil? || (config[:list] && Array(value).empty?)
+          self.logger.error(I18n.t("logstash.runner.configuration.setting_missing",
+                               :setting => config_key, :plugin => @plugin_name,
+                               :type => @plugin_type))
+          is_valid = false
+        end
+      end
+
+      return is_valid
+    end
+
+    def process_parameter_value(value, config_settings)
+      config_val = config_settings[:validate]
+
+      if config_settings[:list]
+        value = Array(value) # coerce scalars to lists
+        # Empty lists are converted to nils
+        return true, nil if value.empty?
+
+        validated_items = value.map {|v| validate_value(v, config_val)}
+        is_valid = validated_items.all? {|sr| sr[0] }
+        processed_value = validated_items.map {|sr| sr[1]}
+      else
+        is_valid, processed_value = validate_value(value, config_val)
+      end
+
+      return [is_valid, processed_value]
+    end
+
+    def validate_check_parameter_values(params)
+      # Filter out parameters that match regexp keys.
+      # These are defined in plugins like this:
+      #   config /foo.*/ => ...
+      all_params_valid = true
+
+      params.each do |key, value|
+        @config.keys.each do |config_key|
+          next unless (config_key.is_a?(Regexp) && key =~ config_key) \
+                      || (config_key.is_a?(String) && key == config_key)
+
+          config_settings = @config[config_key]
+
+          is_valid, processed_value = process_parameter_value(value, config_settings)
+
+          if is_valid
+            # Accept coerced value if valid
+            # Used for converting values in the config to proper objects.
+            params[key] = processed_value
+          else
+            self.logger.error(I18n.t("logstash.runner.configuration.setting_invalid",
+                                 :plugin => @plugin_name, :type => @plugin_type,
+                                 :setting => key, :value => value.inspect,
+                                 :value_type => config_settings[:validate],
+                                 :note => processed_value))
+          end
+
+          all_params_valid &&= is_valid
+
+          break # done with this param key
+        end # config.each
+      end # params.each
+
+      return all_params_valid
+    end # def validate_check_parameter_values
+
+    def validator_find(key)
+      @config.each do |config_key, config_val|
+        if (config_key.is_a?(Regexp) && key =~ config_key) \
+           || (config_key.is_a?(String) && key == config_key)
+          return config_val
+        end
+      end # @config.each
+      return nil
+    end
+
+    def validate_value(value, validator)
+      # Validator comes from the 'config' pieces of plugins.
+      # They look like this
+      #   config :mykey => lambda do |value| ... end
+      # (see LogStash::Inputs::File for example)
+      result = nil
+
+      value = deep_replace(value)
+
+      if validator.nil?
+        return true, value
+      elsif validator.is_a?(Array)
+        value = [*value]
+        if value.size > 1
+          return false, "Expected one of #{validator.inspect}, got #{value.inspect}"
+        end
+
+        if !validator.include?(value.first)
+          return false, "Expected one of #{validator.inspect}, got #{value.inspect}"
+        end
+        result = value.first
+      elsif validator.is_a?(Symbol)
+        # TODO(sissel): Factor this out into a coercion method?
+        # TODO(sissel): Document this stuff.
+        value = hash_or_array(value)
+
+        case validator
+          when :codec
+            if value.first.is_a?(String)
+              value = LogStash::Plugin.lookup("codec", value.first).new
+              return true, value
+            else
+              value = value.first
+              return true, value
+            end
+          when :hash
+            if value.is_a?(Hash)
+              return true, value
+            end
+
+            if value.size % 2 == 1
+              return false, "This field must contain an even number of items, got #{value.size}"
+            end
+
+            # Convert the array the config parser produces into a hash.
+            result = {}
+            value.each_slice(2) do |key, value|
+              entry = result[key]
+              if entry.nil?
+                result[key] = value
+              else
+                if entry.is_a?(Array)
+                  entry << value
+                else
+                  result[key] = [entry, value]
+                end
+              end
+            end
+          when :array
+            result = value
+          when :string
+            if value.size > 1 # only one value wanted
+              return false, "Expected string, got #{value.inspect}"
+            end
+            result = value.first
+          when :number
+            if value.size > 1 # only one value wanted
+              return false, "Expected number, got #{value.inspect} (type #{value.class})"
+            end
+
+            v = value.first
+            case v
+              when Numeric
+                result = v
+              when String
+                if v.to_s.to_f.to_s != v.to_s \
+                   && v.to_s.to_i.to_s != v.to_s
+                  return false, "Expected number, got #{v.inspect} (type #{v})"
+                end
+                if v.include?(".")
+                  # decimal value, use float.
+                  result = v.to_f
+                else
+                  result = v.to_i
+                end
+            end # case v
+          when :boolean
+            if value.size > 1 # only one value wanted
+              return false, "Expected boolean, got #{value.inspect}"
+            end
+
+            bool_value = value.first
+            if !!bool_value == bool_value
+              # is_a does not work for booleans
+              # we have Boolean and not a string
+              result = bool_value
+            else
+              if bool_value !~ /^(true|false)$/
+                return false, "Expected boolean 'true' or 'false', got #{bool_value.inspect}"
+              end
+
+              result = (bool_value == "true")
+            end
+          when :ipaddr
+            if value.size > 1 # only one value wanted
+              return false, "Expected IPaddr, got #{value.inspect}"
+            end
+
+            octets = value.split(".")
+            if octets.length != 4
+              return false, "Expected IPaddr, got #{value.inspect}"
+            end
+            octets.each do |o|
+              if o.to_i < 0 or o.to_i > 255
+                return false, "Expected IPaddr, got #{value.inspect}"
+              end
+            end
+            result = value.first
+          when :password
+            if value.size > 1
+              return false, "Expected password (one value), got #{value.size} values?"
+            end
+
+            result = value.first.is_a?(::LogStash::Util::Password) ? value.first : ::LogStash::Util::Password.new(value.first)
+          when :uri
+            if value.size > 1
+              return false, "Expected uri (one value), got #{value.size} values?"
+            end
+
+            result = value.first.is_a?(::LogStash::Util::SafeURI) ? value.first : ::LogStash::Util::SafeURI.new(value.first)
+          when :path
+            if value.size > 1 # Only 1 value wanted
+              return false, "Expected path (one value), got #{value.size} values?"
+            end
+
+            # Paths must be absolute
+            #if !Pathname.new(value.first).absolute?
+              #return false, "Require absolute path, got relative path #{value.first}?"
+            #end
+
+            if !File.exists?(value.first) # Check if the file exists
+              return false, "File does not exist or cannot be opened #{value.first}"
+            end
+
+            result = value.first
+          when :bytes
+            begin
+              bytes = Integer(value.first) rescue nil
+              result = bytes || Filesize.from(value.first).to_i
+            rescue ArgumentError
+              return false, "Unparseable filesize: #{value.first}. possible units (KiB, MiB, ...) e.g. '10 KiB'. doc reference: http://www.elastic.co/guide/en/logstash/current/configuration.html#bytes"
+            end
+          else
+            return false, "Unknown validator symbol #{validator}"
+        end # case validator
+      else
+        return false, "Unknown validator #{validator.class}"
+      end
+
+      # Return the validator for later use, like with type coercion.
+      return true, result
+    end # def validate_value
+
+    def secure_params!(params)
+      params.each do |key, value|
+        if [:uri, :password].include? @config[key][:validate]
+          is_valid, processed_value = process_parameter_value(value, @config[key])
+          params[key] = processed_value
+        end
+      end
+    end
+
+    def hash_or_array(value)
+      if !value.is_a?(Hash)
+        value = [*value] # coerce scalar to array if necessary
+      end
+      return value
+    end
+  end # module LogStash::Config::DSL
+end # module LogStash::Config