logstash-filter-cache-redis 0.1.0 → 0.2.0

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/environment.rb

@@ -1,172 +0,0 @@
-# encoding: utf-8
-require "logstash/errors"
-require "logstash/java_integration"
-require "logstash/config/cpu_core_strategy"
-require "logstash/settings"
-require "socket"
-require "stud/temporary"
-
-module LogStash
-  # In the event that we're requiring this file without bootstrap/environment.rb
-  if !defined?(LogStash::Environment::LOGSTASH_HOME)
-    module Environment
-      LOGSTASH_HOME = Stud::Temporary.directory("logstash-home")
-      Dir.mkdir(::File.join(LOGSTASH_HOME, "data"))
-    end
-  end
-
-  [
-            Setting::String.new("node.name", Socket.gethostname),
-    Setting::NullableString.new("path.config", nil, false),
- Setting::WritableDirectory.new("path.data", ::File.join(LogStash::Environment::LOGSTASH_HOME, "data")),
-    Setting::NullableString.new("config.string", nil, false),
-           Setting::Boolean.new("config.test_and_exit", false),
-           Setting::Boolean.new("config.reload.automatic", false),
-           Setting::Numeric.new("config.reload.interval", 3), # in seconds
-           Setting::Boolean.new("metric.collect", true),
-            Setting::String.new("pipeline.id", "main"),
-            Setting::Boolean.new("pipeline.system", false),
-   Setting::PositiveInteger.new("pipeline.workers", LogStash::Config::CpuCoreStrategy.maximum),
-   Setting::PositiveInteger.new("pipeline.output.workers", 1),
-   Setting::PositiveInteger.new("pipeline.batch.size", 125),
-           Setting::Numeric.new("pipeline.batch.delay", 5), # in milliseconds
-           Setting::Boolean.new("pipeline.unsafe_shutdown", false),
-                    Setting.new("path.plugins", Array, []),
-    Setting::NullableString.new("interactive", nil, false),
-           Setting::Boolean.new("config.debug", false),
-            Setting::String.new("log.level", "info", true, ["fatal", "error", "warn", "debug", "info", "trace"]),
-           Setting::Boolean.new("version", false),
-           Setting::Boolean.new("help", false),
-            Setting::String.new("log.format", "plain", true, ["json", "plain"]),
-            Setting::String.new("http.host", "127.0.0.1"),
-            Setting::PortRange.new("http.port", 9600..9700),
-            Setting::String.new("http.environment", "production"),
-            Setting::String.new("queue.type", "memory", true, ["persisted", "memory", "memory_acked"]),
-            Setting::Boolean.new("queue.drain", false),
-            Setting::Bytes.new("queue.page_capacity", "250mb"),
-            Setting::Bytes.new("queue.max_bytes", "1024mb"),
-            Setting::Numeric.new("queue.max_events", 0), # 0 is unlimited
-            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::TimeValue.new("slowlog.threshold.warn", "-1"),
-            Setting::TimeValue.new("slowlog.threshold.info", "-1"),
-            Setting::TimeValue.new("slowlog.threshold.debug", "-1"),
-            Setting::TimeValue.new("slowlog.threshold.trace", "-1")
-  ].each {|setting| SETTINGS.register(setting) }
-
-  # Compute the default queue path based on `path.data`
-  default_queue_file_path = ::File.join(SETTINGS.get("path.data"), "queue")
-  SETTINGS.register Setting::WritableDirectory.new("path.queue", default_queue_file_path)
-  
-  SETTINGS.on_post_process do |settings|
-    # If the data path is overridden but the queue path isn't recompute the queue path
-    # We need to do this at this stage because of the weird execution order
-    # our monkey-patched Clamp follows
-    if settings.set?("path.data") && !settings.set?("path.queue")
-      settings.set_value("path.queue", ::File.join(settings.get("path.data"), "queue"))
-    end
-  end
-
-  module Environment
-    extend self
-
-    LOGSTASH_CORE = ::File.expand_path(::File.join(::File.dirname(__FILE__), "..", ".."))
-    LOGSTASH_ENV = (ENV["LS_ENV"] || 'production').to_s.freeze
-
-    LINUX_OS_RE = /linux/
-    WINDOW_OS_RE = /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-    MACOS_OS_RE = /darwin/
-
-    def env
-      LOGSTASH_ENV
-    end
-
-    def production?
-      env.downcase == "production"
-    end
-
-    def development?
-      env.downcase == "development"
-    end
-
-    def test?
-      env.downcase == "test"
-    end
-
-    def runtime_jars_root(dir_name, package)
-      ::File.join(dir_name, package, "runtime-jars")
-    end
-
-    def test_jars_root(dir_name, package)
-      ::File.join(dir_name, package, "test-jars")
-    end
-
-    def load_runtime_jars!(dir_name="vendor", package="jar-dependencies")
-      load_jars!(::File.join(runtime_jars_root(dir_name, package), "*.jar"))
-    end
-
-    def load_test_jars!(dir_name="vendor", package="jar-dependencies")
-      load_jars!(::File.join(test_jars_root(dir_name, package), "*.jar"))
-    end
-
-    def load_jars!(pattern)
-      raise(LogStash::EnvironmentError, I18n.t("logstash.environment.jruby-required")) unless LogStash::Environment.jruby?
-
-      jar_files = find_jars(pattern)
-      require_jars! jar_files
-    end
-
-    def find_jars(pattern)
-      require 'java'
-      jar_files = Dir.glob(pattern)
-      raise(LogStash::EnvironmentError, I18n.t("logstash.environment.missing-jars", :pattern => pattern)) if jar_files.empty?
-      jar_files
-    end
-
-    def require_jars!(files)
-      files.each do |jar_file|
-        loaded = require jar_file
-        puts("Loaded #{jar_file}") if $DEBUG && loaded
-      end
-    end
-
-    def ruby_bin
-      ENV["USE_RUBY"] == "1" ? "ruby" : File.join("vendor", "jruby", "bin", "jruby")
-    end
-
-    def jruby?
-      @jruby ||= !!(RUBY_PLATFORM == "java")
-    end
-
-    def windows?
-      RbConfig::CONFIG['host_os'] =~ WINDOW_OS_RE
-    end
-
-    def linux?
-      RbConfig::CONFIG['host_os'] =~ LINUX_OS_RE
-    end
-
-    def locales_path(path)
-      return ::File.join(LOGSTASH_CORE, "locales", path)
-    end
-
-    def load_locale!
-      require "i18n"
-      I18n.enforce_available_locales = true
-      I18n.load_path << LogStash::Environment.locales_path("en.yml")
-      I18n.reload!
-      fail "No locale? This is a bug." if I18n.available_locales.empty?
-    end
-
-    # add path for bare/ungemified plugins lookups. the path must be the base path that will include
-    # the dir structure 'logstash/TYPE/NAME.rb' where TYPE is 'inputs' 'filters', 'outputs' or 'codecs'
-    # and NAME is the name of the plugin
-    # @param path [String] plugins path to add
-    def add_plugin_path(path)
-      $LOAD_PATH << path
-    end
-  end
-end
-
-require "logstash/patches"

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/errors.rb

@@ -1,12 +0,0 @@
-# encoding: utf-8
-module LogStash
-  class Error < ::StandardError; end
-  class EnvironmentError < Error; end
-  class ConfigurationError < Error; end
-  class PluginLoadingError < Error; end
-  class ShutdownSignal < StandardError; end
-  class PluginNoVersionError < Error; end
-
-  class Bug < Error; end
-  class ThisMethodWasRemoved < Bug; end
-end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/execution_context.rb

@@ -1,10 +0,0 @@
-# encoding: utf-8
-module LogStash
-  class ExecutionContext
-    attr_reader :pipeline_id
-
-    def initialize(pipeline_id)
-      @pipeline_id = pipeline_id
-    end
-  end
-end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/inputs/base.rb

@@ -1,136 +0,0 @@
-# encoding: utf-8
-require "logstash/namespace"
-require "logstash/event"
-require "logstash/plugin"
-require "logstash/logging"
-require "logstash/config/mixin"
-require "logstash/codecs/base"
-require "logstash/util/decorators"
-
-# This is the base class for Logstash inputs.
-class LogStash::Inputs::Base < LogStash::Plugin
-  include LogStash::Util::Loggable
-  include LogStash::Config::Mixin
-
-  config_name "input"
-
-  # Add a `type` field to all events handled by this input.
-  #
-  # Types are used mainly for filter activation.
-  #
-  # The type is stored as part of the event itself, so you can
-  # also use the type to search for it in Kibana.
-  #
-  # If you try to set a type on an event that already has one (for
-  # example when you send an event from a shipper to an indexer) then
-  # a new input will not override the existing type. A type set at
-  # the shipper stays with that event for its life even
-  # when sent to another Logstash server.
-  config :type, :validate => :string
-
-  config :debug, :validate => :boolean, :default => false, :obsolete => "This setting no longer has any effect. In past releases, it existed, but almost no plugin made use of it."
-
-  config :format, :validate => ["plain", "json", "json_event", "msgpack_event"], :obsolete => "You should use the newer 'codec' setting instead."
-
-  config :charset, :obsolete => "Use the codec setting instead. For example: input { %PLUGIN% { codec => plain { charset => \"UTF-8\" } }"
-
-  config :message_format, :validate => :string, :obsolete => "Setting is no longer valid."
-
-  # The codec used for input data. Input codecs are a convenient method for decoding your data before it enters the input, without needing a separate filter in your Logstash pipeline.
-  config :codec, :validate => :codec, :default => "plain"
-
-  # Add any number of arbitrary tags to your event.
-  #
-  # This can help with processing later.
-  config :tags, :validate => :array
-
-  # Add a field to an event
-  config :add_field, :validate => :hash, :default => {}
-
-  attr_accessor :params
-  attr_accessor :threadable
-
-  def self.plugin_type
-    "input"
-  end
-
-  public
-  def initialize(params={})
-    super
-    @threadable = false
-    @stop_called = Concurrent::AtomicBoolean.new(false)
-    config_init(@params)
-    @tags ||= []
-  end # def initialize
-
-  public
-  def register
-    raise "#{self.class}#register must be overidden"
-  end # def register
-
-  public
-  def tag(newtag)
-    @tags << newtag
-  end # def tag
-
-  public
-  # override stop if you need to do more than do_stop to
-  # enforce the input plugin to return from `run`.
-  # e.g. a tcp plugin might need to close the tcp socket
-  # so blocking read operation aborts
-  def stop
-    # override if necessary
-  end
-
-  public
-  def do_stop
-    @logger.debug("stopping", :plugin => self.class.name)
-    @stop_called.make_true
-    stop
-  end
-
-  # stop? should never be overridden
-  public
-  def stop?
-    @stop_called.value
-  end
-  
-  def clone
-    cloned = super
-    cloned.codec = @codec.clone if @codec
-    cloned
-  end
-
-  def execution_context=(context)
-    super
-    # There is no easy way to propage an instance variable into the codec, because the codec
-    # are created at the class level
-    @codec.execution_context = context
-    context
-  end
-
-  protected
-  def decorate(event)
-    # Only set 'type' if not already set. This is backwards-compatible behavior
-    event.set("type", @type) if @type && !event.include?("type")
-
-    LogStash::Util::Decorators.add_fields(@add_field,event,"inputs/#{self.class.name}")
-    LogStash::Util::Decorators.add_tags(@tags,event,"inputs/#{self.class.name}")
-  end
-
-  protected
-  def fix_streaming_codecs
-    require "logstash/codecs/plain"
-    require "logstash/codecs/line"
-    require "logstash/codecs/json"
-    require "logstash/codecs/json_lines"
-    case @codec
-      when LogStash::Codecs::Plain
-        @logger.info("Automatically switching from #{@codec.class.config_name} to line codec", :plugin => self.class.config_name)
-        @codec = LogStash::Codecs::Line.new("charset" => @codec.charset)
-      when LogStash::Codecs::JSON
-        @logger.info("Automatically switching from #{@codec.class.config_name} to json_lines codec", :plugin => self.class.config_name)
-        @codec = LogStash::Codecs::JSONLines.new("charset" => @codec.charset)
-    end
-  end
-end # class LogStash::Inputs::Base

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/instrument/metric_type/mean.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-require "logstash/instrument/metric_type/base"
-require "concurrent"
-
-module LogStash module Instrument module MetricType
-  class Mean < Base
-    def initialize(namespaces, key)
-      super(namespaces, key)
-
-      @counter = Concurrent::AtomicFixnum.new
-      @sum = Concurrent::AtomicFixnum.new
-    end
-
-    def increment(value = 1)
-      @counter.increment
-      @sum.increment(value)
-    end
-
-    def decrement(value = 1)
-      @counter.decrement
-      @sum.decrement(value)
-    end
-
-    def mean
-      if @counter > 0
-        @sum.value / @counter.value
-      else
-        0
-      end
-    end
-    alias_method :value, :mean
-  end
-end; end; end

data/vendor/bundle/jruby/1.9/gems/logstash-core-5.4.0-java/lib/logstash/instrument/periodic_poller/jvm.rb

@@ -1,190 +0,0 @@
-# encoding: utf-8
-require "logstash/instrument/periodic_poller/base"
-require "logstash/instrument/periodic_poller/load_average"
-require "logstash/environment"
-require "jrmonitor"
-require "set"
-
-java_import 'java.lang.management.ManagementFactory'
-java_import 'java.lang.management.OperatingSystemMXBean'
-java_import 'java.lang.management.GarbageCollectorMXBean'
-java_import 'java.lang.management.RuntimeMXBean'
-java_import 'com.sun.management.UnixOperatingSystemMXBean'
-java_import 'javax.management.MBeanServer'
-java_import 'javax.management.ObjectName'
-java_import 'javax.management.AttributeList'
-java_import 'javax.naming.directory.Attribute'
-
-
-module LogStash module Instrument module PeriodicPoller
-  class JVM < Base
-    class GarbageCollectorName
-      YOUNG_GC_NAMES = Set.new(["Copy", "PS Scavenge", "ParNew", "G1 Young Generation"])
-      OLD_GC_NAMES = Set.new(["MarkSweepCompact", "PS MarkSweep", "ConcurrentMarkSweep", "G1 Old Generation"])
-
-      YOUNG = :young
-      OLD = :old
-
-      def self.get(gc_name)
-        if YOUNG_GC_NAMES.include?(gc_name)
-          YOUNG
-        elsif(OLD_GC_NAMES.include?(gc_name))
-          OLD
-        end
-      end
-    end
-
-    MEMORY_TRANSPOSE_MAP = {
-      "usage.used" => :used_in_bytes,
-      "usage.committed" => :committed_in_bytes,
-      "usage.max" => :max_in_bytes,
-      "peak.max" => :peak_max_in_bytes,
-      "peak.used" => :peak_used_in_bytes
-    }
-
-    attr_reader :metric
-
-    def initialize(metric, options = {})
-      super(metric, options)
-      @load_average = LoadAverage.create
-    end
-
-    def collect
-      raw = JRMonitor.memory.generate
-      collect_jvm_metrics(raw)
-      collect_pools_metrics(raw)
-      collect_threads_metrics
-      collect_process_metrics
-      collect_gc_stats
-      collect_load_average
-    end
-
-    def collect_gc_stats
-      garbage_collectors = ManagementFactory.getGarbageCollectorMXBeans()
-
-      garbage_collectors.each do |collector|
-        name = GarbageCollectorName.get(collector.getName())
-        if name.nil?
-          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())
-        end
-      end
-    end
-
-    def collect_threads_metrics
-      threads_mx = ManagementFactory.getThreadMXBean()
-
-      metric.gauge([:jvm, :threads], :count, threads_mx.getThreadCount())
-      metric.gauge([:jvm, :threads], :peak_count, threads_mx.getPeakThreadCount())
-    end
-
-    def collect_process_metrics
-      process_metrics = JRMonitor.process.generate
-
-      path = [:jvm, :process]
-
-
-      open_fds = process_metrics["open_file_descriptors"]
-      if @peak_open_fds.nil? || open_fds > @peak_open_fds
-        @peak_open_fds = open_fds
-      end
-      metric.gauge(path, :open_file_descriptors, open_fds)
-      metric.gauge(path, :peak_open_file_descriptors, @peak_open_fds)
-      metric.gauge(path, :max_file_descriptors, process_metrics["max_file_descriptors"])
-
-      cpu_path = path + [:cpu]
-      cpu_metrics = process_metrics["cpu"]
-      metric.gauge(cpu_path, :percent, cpu_metrics["process_percent"])
-      metric.gauge(cpu_path, :total_in_millis, cpu_metrics["total_in_millis"])
-
-      metric.gauge(path + [:mem], :total_virtual_in_bytes, process_metrics["mem"]["total_virtual_in_bytes"])
-
-    end
-
-    def collect_load_average
-      begin
-        load_average = @load_average.get
-      rescue => e
-        logger.debug("Can't retrieve load average", :exception => e.class.name, :message => e.message)
-        load_average = nil
-      end
-
-      metric.gauge([:jvm, :process, :cpu], :load_average, load_average) unless load_average.nil?
-    end
-
-    def collect_jvm_metrics(data)
-      runtime_mx_bean = ManagementFactory.getRuntimeMXBean()
-      metric.gauge([:jvm], :uptime_in_millis, runtime_mx_bean.getUptime())
-      collect_heap_metrics(data)
-      collect_non_heap_metrics(data)
-    end
-
-    def collect_heap_metrics(data)
-      heap = aggregate_information_for(data["heap"].values)
-      heap[:used_percent] = (heap[:used_in_bytes] / heap[:max_in_bytes].to_f)*100.0
-
-      heap.each_pair do |key, value|
-        metric.gauge([:jvm, :memory, :heap], key, value.to_i)
-      end
-    end
-
-    def collect_non_heap_metrics(data)
-      non_heap = aggregate_information_for(data["non_heap"].values)
-      non_heap.each_pair do |key, value|
-        metric.gauge([:jvm, :memory, :non_heap],key, value.to_i)
-      end
-    end
-
-    def collect_pools_metrics(data)
-      metrics = build_pools_metrics(data)
-      metrics.each_pair do |key, hash|
-        hash.each_pair do |p,v|
-          metric.gauge([:jvm, :memory, :pools, key.to_sym], p, v)
-        end
-      end
-    end
-
-    def build_pools_metrics(data)
-      heap = data["heap"]
-      old  = {}
-      old = old.merge!(heap["CMS Old Gen"]) if heap.has_key?("CMS Old Gen")
-      old = old.merge!(heap["PS Old Gen"])  if heap.has_key?("PS Old Gen")
-      young = {}
-      young = young.merge!(heap["Par Eden Space"]) if heap.has_key?("Par Eden Space")
-      young = young.merge!(heap["PS Eden Space"])  if heap.has_key?("PS Eden Space")
-      survivor = {}
-      survivor = survivor.merge!(heap["Par Survivor Space"]) if heap.has_key?("Par Survivor Space")
-      survivor = survivor.merge!(heap["PS Survivor Space"])  if heap.has_key?("PS Survivor Space")
-      {
-        "young"    => aggregate_information_for(young),
-        "old"      => aggregate_information_for(old),
-        "survivor" => aggregate_information_for(survivor)
-      }
-    end
-
-    def aggregate_information_for(collection)
-      collection.reduce(default_information_accumulator) do |m,e|
-        e = { e[0] => e[1] } if e.is_a?(Array)
-        e.each_pair do |k,v|
-          if MEMORY_TRANSPOSE_MAP.include?(k)
-            transpose_key = MEMORY_TRANSPOSE_MAP[k]
-            m[transpose_key] += v
-          end
-        end
-        m
-      end
-    end
-
-    def default_information_accumulator
-      {
-        :used_in_bytes => 0,
-        :committed_in_bytes => 0,
-        :max_in_bytes => 0,
-        :peak_used_in_bytes => 0,
-        :peak_max_in_bytes => 0
-      }
-    end
-  end
-end; end; end