logstash-output-scalyr 0.1.4 → 0.1.9

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb

@@ -1,79 +0,0 @@
-require 'concurrent/utility/engine'
-
-module Concurrent
-
-  module Utility
-
-    # @!visibility private
-    module NativeExtensionLoader
-
-      def allow_c_extensions?
-        Concurrent.on_cruby?
-      end
-
-      def c_extensions_loaded?
-        defined?(@c_extensions_loaded) && @c_extensions_loaded
-      end
-
-      def java_extensions_loaded?
-        defined?(@java_extensions_loaded) && @java_extensions_loaded
-      end
-
-      def load_native_extensions
-        unless defined? Synchronization::AbstractObject
-          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
-        end
-
-        if Concurrent.on_cruby? && !c_extensions_loaded?
-          ['concurrent/concurrent_ruby_ext',
-           "concurrent/#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
-          ].each { |p| try_load_c_extension p }
-        end
-
-        if Concurrent.on_jruby? && !java_extensions_loaded?
-          begin
-            require 'concurrent/concurrent_ruby.jar'
-            set_java_extensions_loaded
-          rescue LoadError => e
-            raise e, "Java extensions are required for JRuby.\n" + e.message, e.backtrace
-          end
-        end
-      end
-
-      private
-
-      def load_error_path(error)
-        if error.respond_to? :path
-          error.path
-        else
-          error.message.split(' -- ').last
-        end
-      end
-
-      def set_c_extensions_loaded
-        @c_extensions_loaded = true
-      end
-
-      def set_java_extensions_loaded
-        @java_extensions_loaded = true
-      end
-
-      def try_load_c_extension(path)
-        require path
-        set_c_extensions_loaded
-      rescue LoadError => e
-        if load_error_path(e) == path
-          # move on with pure-Ruby implementations
-          # TODO (pitr-ch 12-Jul-2018): warning on verbose?
-        else
-          raise e
-        end
-      end
-
-    end
-  end
-
-  # @!visibility private
-  extend Utility::NativeExtensionLoader
-end
-

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/utility/native_integer.rb

@@ -1,53 +0,0 @@
-module Concurrent
-  module Utility
-    # @private
-    module NativeInteger
-      # http://stackoverflow.com/questions/535721/ruby-max-integer
-      MIN_VALUE = -(2**(0.size * 8 - 2))
-      MAX_VALUE = (2**(0.size * 8 - 2) - 1)
-
-      def ensure_upper_bound(value)
-        if value > MAX_VALUE
-          raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
-        end
-        value
-      end
-
-      def ensure_lower_bound(value)
-        if value < MIN_VALUE
-          raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
-        end
-        value
-      end
-
-      def ensure_integer(value)
-        unless value.is_a?(Integer)
-          raise ArgumentError.new("#{value} is not an Integer")
-        end
-        value
-      end
-
-      def ensure_integer_and_bounds(value)
-        ensure_integer value
-        ensure_upper_bound value
-        ensure_lower_bound value
-      end
-
-      def ensure_positive(value)
-        if value < 0
-          raise ArgumentError.new("#{value} cannot be negative")
-        end
-        value
-      end
-
-      def ensure_positive_and_no_zero(value)
-        if value < 1
-          raise ArgumentError.new("#{value} cannot be negative or zero")
-        end
-        value
-      end
-
-      extend self
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/utility/processor_counter.rb

@@ -1,163 +0,0 @@
-require 'etc'
-require 'rbconfig'
-require 'concurrent/delay'
-
-module Concurrent
-  module Utility
-
-    # @!visibility private
-    class ProcessorCounter
-      def initialize
-        @processor_count          = Delay.new { compute_processor_count }
-        @physical_processor_count = Delay.new { compute_physical_processor_count }
-      end
-
-      # Number of processors seen by the OS and used for process scheduling. For
-      # performance reasons the calculated value will be memoized on the first
-      # call.
-      #
-      # When running under JRuby the Java runtime call
-      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
-      # to the Java documentation this "value may change during a particular
-      # invocation of the virtual machine... [applications] should therefore
-      # occasionally poll this property." Subsequently the result will NOT be
-      # memoized under JRuby.
-      #
-      # Ruby's Etc.nprocessors will be used if available (MRI 2.2+).
-      #
-      # On Windows the Win32 API will be queried for the
-      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
-      # total number "logical processors for the current instance of the
-      # processor", which taked into account hyperthreading.
-      #
-      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
-      # * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
-      # * BSD: /sbin/sysctl
-      # * Cygwin: /proc/cpuinfo
-      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
-      # * HP-UX: /usr/sbin/ioscan
-      # * IRIX: /usr/sbin/sysconf
-      # * Linux: /proc/cpuinfo
-      # * Minix 3+: /proc/cpuinfo
-      # * Solaris: /usr/sbin/psrinfo
-      # * Tru64 UNIX: /usr/sbin/psrinfo
-      # * UnixWare: /usr/sbin/psrinfo
-      #
-      # @return [Integer] number of processors seen by the OS or Java runtime
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      def processor_count
-        @processor_count.value
-      end
-
-      # Number of physical processor cores on the current system. For performance
-      # reasons the calculated value will be memoized on the first call.
-      #
-      # On Windows the Win32 API will be queried for the `NumberOfCores from
-      # Win32_Processor`. This will return the total number "of cores for the
-      # current instance of the processor." On Unix-like operating systems either
-      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
-      # returned value will be used. In the rare case where none of these methods
-      # work or an exception is raised the function will simply return 1.
-      #
-      # @return [Integer] number physical processor cores on the current system
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
-      # @see http://linux.die.net/man/8/sysctl
-      def physical_processor_count
-        @physical_processor_count.value
-      end
-
-      private
-
-      def compute_processor_count
-        if Concurrent.on_jruby?
-          java.lang.Runtime.getRuntime.availableProcessors
-        elsif Etc.respond_to?(:nprocessors) && (nprocessor = Etc.nprocessors rescue nil)
-          nprocessor
-        else
-          os_name = RbConfig::CONFIG["target_os"]
-          if os_name =~ /mingw|mswin/
-            require 'win32ole'
-            result = WIN32OLE.connect("winmgmts://").ExecQuery(
-              "select NumberOfLogicalProcessors from Win32_Processor")
-            result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
-          elsif File.readable?("/proc/cpuinfo") && (cpuinfo_count = IO.read("/proc/cpuinfo").scan(/^processor/).size) > 0
-            cpuinfo_count
-          elsif File.executable?("/usr/bin/nproc")
-            IO.popen("/usr/bin/nproc --all", &:read).to_i
-          elsif File.executable?("/usr/bin/hwprefs")
-            IO.popen("/usr/bin/hwprefs thread_count", &:read).to_i
-          elsif File.executable?("/usr/sbin/psrinfo")
-            IO.popen("/usr/sbin/psrinfo", &:read).scan(/^.*on-*line/).size
-          elsif File.executable?("/usr/sbin/ioscan")
-            IO.popen("/usr/sbin/ioscan -kC processor", &:read).scan(/^.*processor/).size
-          elsif File.executable?("/usr/sbin/pmcycles")
-            IO.popen("/usr/sbin/pmcycles -m", &:read).count("\n")
-          elsif File.executable?("/usr/sbin/lsdev")
-            IO.popen("/usr/sbin/lsdev -Cc processor -S 1", &:read).count("\n")
-          elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
-            IO.popen("/usr/sbin/sysconf NPROC_ONLN", &:read).to_i
-          elsif File.executable?("/usr/sbin/sysctl")
-            IO.popen("/usr/sbin/sysctl -n hw.ncpu", &:read).to_i
-          elsif File.executable?("/sbin/sysctl")
-            IO.popen("/sbin/sysctl -n hw.ncpu", &:read).to_i
-          else
-            # TODO (pitr-ch 05-Nov-2016): warn about failures
-            1
-          end
-        end
-      rescue
-        return 1
-      end
-
-      def compute_physical_processor_count
-        ppc = case RbConfig::CONFIG["target_os"]
-              when /darwin1/
-                IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
-              when /linux/
-                cores = {} # unique physical ID / core ID combinations
-                phy   = 0
-                IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
-                  if ln.start_with?("physical")
-                    phy = ln[/\d+/]
-                  elsif ln.start_with?("core")
-                    cid        = phy + ":" + ln[/\d+/]
-                    cores[cid] = true if not cores[cid]
-                  end
-                end
-                cores.count
-              when /mswin|mingw/
-                require 'win32ole'
-                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-                  "select NumberOfCores from Win32_Processor")
-                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
-              else
-                processor_count
-              end
-        # fall back to logical count if physical info is invalid
-        ppc > 0 ? ppc : processor_count
-      rescue
-        return 1
-      end
-    end
-  end
-
-  # create the default ProcessorCounter on load
-  @processor_counter = Utility::ProcessorCounter.new
-  singleton_class.send :attr_reader, :processor_counter
-
-  def self.processor_count
-    processor_counter.processor_count
-  end
-
-  def self.physical_processor_count
-    processor_counter.physical_processor_count
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/concurrent-ruby-1.1.6/lib/concurrent-ruby/concurrent/version.rb

@@ -1,3 +0,0 @@
-module Concurrent
-  VERSION      = '1.1.6'
-end

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/Changes.md

@@ -1,123 +0,0 @@
-connection\_pool changelog
----------------------------
-
-2.2.2
-------
-
-- Add pool `size` and `available` accessors for metrics and monitoring
-  purposes [#97, robholland]
-
-2.2.1
-------
-
-- Allow CP::Wrapper to use an existing pool [#87, etiennebarrie]
-- Use monotonic time for more accurate timeouts [#84, jdantonio]
-
-2.2.0
-------
-
-- Rollback `Timeout` handling introduced in 2.1.1 and 2.1.2.  It seems
-  impossible to safely work around the issue. Please never, ever use
-  `Timeout.timeout` in your code or you will see rare but mysterious bugs. [#75]
-
-2.1.3
-------
-
-- Don't increment created count until connection is successfully
-  created. [mylesmegyesi, #73]
-
-2.1.2
-------
-
-- The connection\_pool will now close any connections which respond to
-  `close` (Dalli) or `disconnect!` (Redis).  This ensures discarded connections
-  from the fix in 2.1.1 are torn down ASAP and don't linger open.
-
-
-2.1.1
-------
-
-- Work around a subtle race condition with code which uses `Timeout.timeout` and
-  checks out a connection within the timeout block.  This might cause
-  connections to get into a bad state and raise very odd errors. [tamird, #67]
-
-
-2.1.0
-------
-
-- Refactoring to better support connection pool subclasses [drbrain,
-  #55]
-- `with` should return value of the last expression [#59]
-
-
-2.0.0
------
-
-- The connection pool is now lazy.  Connections are created as needed
-  and retained until the pool is shut down. [drbrain, #52]
-
-1.2.0
------
-
-- Add `with(options)` and `checkout(options)`. [mattcamuto]
-  Allows the caller to override the pool timeout.
-```ruby
-@pool.with(:timeout => 2) do |conn|
-end
-```
-
-1.1.0
------
-
-- New `#shutdown` method (simao)
-
-    This method accepts a block and calls the block for each
-    connection in the pool. After calling this method, trying to get a
-    connection from the pool raises `PoolShuttingDownError`.
-
-1.0.0
------
-
-- `#with_connection` is now gone in favor of `#with`.
-
-- We no longer pollute the top level namespace with our internal
-`TimedStack` class.
-
-0.9.3
---------
-
-- `#with_connection` is now deprecated in favor of `#with`.
-
-    A warning will be issued in the 0.9 series and the method will be
-    removed in 1.0.
-
-- We now reuse objects when possible.
-
-    This means that under no contention, the same object will be checked
-    out from the pool after subsequent calls to `ConnectionPool#with`.
-
-    This change should have no impact on end user performance. If
-    anything, it should be an improvement, depending on what objects you
-    are pooling.
-
-0.9.2
---------
-
-- Fix reentrant checkout leading to early checkin.
-
-0.9.1
---------
-
-- Fix invalid superclass in version.rb
-
-0.9.0
---------
-
-- Move method\_missing magic into ConnectionPool::Wrapper (djanowski)
-- Remove BasicObject superclass (djanowski)
-
-0.1.0
---------
-
-- More precise timeouts and better error message
-- ConnectionPool now subclasses BasicObject so `method_missing` is more effective.

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/README.md

@@ -1,107 +0,0 @@
-connection\_pool
-=================
-[![Build Status](https://travis-ci.org/mperham/connection_pool.svg)](https://travis-ci.org/mperham/connection_pool)
-
-Generic connection pooling for Ruby.
-
-MongoDB has its own connection pool.  ActiveRecord has its own connection pool.
-This is a generic connection pool that can be used with anything, e.g. Redis,
-Dalli and other Ruby network clients.
-
-
-Usage
------
-
-Create a pool of objects to share amongst the fibers or threads in your Ruby
-application:
-
-``` ruby
-$memcached = ConnectionPool.new(size: 5, timeout: 5) { Dalli::Client.new }
-```
-
-Then use the pool in your application:
-
-``` ruby
-$memcached.with do |conn|
-  conn.get('some-count')
-end
-```
-
-If all the objects in the connection pool are in use, `with` will block
-until one becomes available.  If no object is available within `:timeout` seconds,
-`with` will raise a `Timeout::Error`.
-
-Optionally, you can specify a timeout override using the with-block semantics:
-
-``` ruby
-$memcached.with(timeout: 2.0) do |conn|
-  conn.get('some-count')
-end
-```
-
-This will only modify the resource-get timeout for this particular
-invocation. This is useful if you want to fail-fast on certain non critical
-sections when a resource is not available, or conversely if you are comfortable
-blocking longer on a particular resource. This is not implemented in the below
-`ConnectionPool::Wrapper` class.
-
-## Migrating to a Connection Pool
-
-You can use `ConnectionPool::Wrapper` to wrap a single global connection,
-making it easier to migrate existing connection code over time:
-
-``` ruby
-$redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.connect }
-$redis.sadd('foo', 1)
-$redis.smembers('foo')
-```
-
-The wrapper uses `method_missing` to checkout a connection, run the requested
-method and then immediately check the connection back into the pool.  It's
-**not** high-performance so you'll want to port your performance sensitive code
-to use `with` as soon as possible.
-
-``` ruby
-$redis.with do |conn|
-  conn.sadd('foo', 1)
-  conn.smembers('foo')
-end
-```
-
-Once you've ported your entire system to use `with`, you can simply remove
-`Wrapper` and use the simpler and faster `ConnectionPool`.
-
-
-## Shutdown
-
-You can shut down a ConnectionPool instance once it should no longer be used.
-Further checkout attempts will immediately raise an error but existing checkouts
-will work.
-
-```ruby
-cp = ConnectionPool.new { Redis.new }
-cp.shutdown { |conn| conn.quit }
-```
-
-Shutting down a connection pool will block until all connections are checked in and closed.
-**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim
-unreferenced pools under normal circumstances.
-
-
-Notes
------
-
-- Connections are lazily created as needed.
-- There is no provision for repairing or checking the health of a connection;
-  connections should be self-repairing.  This is true of the Dalli and Redis
-  clients.
-- **WARNING**: Don't ever use `Timeout.timeout` in your Ruby code or you will see
-  occasional silent corruption and mysterious errors.  The Timeout API is unsafe
-  and cannot be used correctly, ever.  Use proper socket timeout options as
-  exposed by Net::HTTP, Redis, Dalli, etc.
-
-
-Author
-------
-
-Mike Perham, [@mperham](https://twitter.com/mperham), <http://mikeperham.com>