logstash-output-scalyr 0.1.5 → 0.1.6

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/logging/formatter.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-module Faraday
-  module Logging
-    # Serves as an integration point to customize logging
-    class Formatter
-      extend Forwardable
-
-      DEFAULT_OPTIONS = { headers: true, bodies: false,
-                          log_level: :info }.freeze
-
-      def initialize(logger:, options:)
-        @logger = logger
-        @filter = []
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-      def request(env)
-        request_log = proc do
-          "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
-        end
-        public_send(log_level, 'request', &request_log)
-
-        log_headers('request', env.request_headers) if log_headers?(:request)
-        log_body('request', env[:body]) if env[:body] && log_body?(:request)
-      end
-
-      def response(env)
-        status = proc { "Status #{env.status}" }
-        public_send(log_level, 'response', &status)
-
-        log_headers('response', env.response_headers) if log_headers?(:response)
-        log_body('response', env[:body]) if env[:body] && log_body?(:response)
-      end
-
-      def filter(filter_word, filter_replacement)
-        @filter.push([filter_word, filter_replacement])
-      end
-
-      private
-
-      def dump_headers(headers)
-        headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
-      end
-
-      def dump_body(body)
-        if body.respond_to?(:to_str)
-          body.to_str
-        else
-          pretty_inspect(body)
-        end
-      end
-
-      def pretty_inspect(body)
-        body.pretty_inspect
-      end
-
-      def log_headers?(type)
-        case @options[:headers]
-        when Hash
-          @options[:headers][type]
-        else
-          @options[:headers]
-        end
-      end
-
-      def log_body?(type)
-        case @options[:bodies]
-        when Hash
-          @options[:bodies][type]
-        else
-          @options[:bodies]
-        end
-      end
-
-      def apply_filters(output)
-        @filter.each do |pattern, replacement|
-          output = output.to_s.gsub(pattern, replacement)
-        end
-        output
-      end
-
-      def log_level
-        unless %i[debug info warn error fatal].include?(@options[:log_level])
-          return :info
-        end
-
-        @options[:log_level]
-      end
-
-      def log_headers(type, headers)
-        headers_log = proc { apply_filters(dump_headers(headers)) }
-        public_send(log_level, type, &headers_log)
-      end
-
-      def log_body(type, body)
-        body_log = proc { apply_filters(dump_body(body)) }
-        public_send(log_level, type, &body_log)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/middleware.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Middleware is the basic base class of any Faraday middleware.
-  class Middleware
-    extend MiddlewareRegistry
-    extend DependencyLoader
-
-    def initialize(app = nil)
-      @app = app
-    end
-
-    def close
-      if @app.respond_to?(:close)
-        @app.close
-      else
-        warn "#{@app} does not implement \#close!"
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/middleware_registry.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'monitor'
-
-module Faraday
-  # Adds the ability for other modules to register and lookup
-  # middleware classes.
-  module MiddlewareRegistry
-    # Register middleware class(es) on the current module.
-    #
-    # @param autoload_path [String] Middleware autoload path
-    # @param mapping [Hash{
-    #          Symbol => Module,
-    #          Symbol => Array<Module, Symbol, String>,
-    #        }] Middleware mapping from a lookup symbol to a reference to the
-    #        middleware.
-    #        Classes can be expressed as:
-    #          - a fully qualified constant
-    #          - a Symbol
-    #          - a Proc that will be lazily called to return the former
-    #          - an array is given, its first element is the constant or symbol,
-    #            and its second is a file to `require`.
-    # @return [void]
-    #
-    # @example Lookup by a constant
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
-    #       register_middleware foo: Foo
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :bar returns
-    #       # Faraday::Whatever.const_get(:Bar)
-    #       register_middleware bar: :Bar
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol and string in an array
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :baz requires 'baz' and returns
-    #       # Faraday::Whatever.const_get(:Baz)
-    #       register_middleware baz: [:Baz, 'baz']
-    #     end
-    #   end
-    #
-    def register_middleware(autoload_path = nil, mapping = nil)
-      if mapping.nil?
-        mapping = autoload_path
-        autoload_path = nil
-      end
-      middleware_mutex do
-        @middleware_autoload_path = autoload_path if autoload_path
-        (@registered_middleware ||= {}).update(mapping)
-      end
-    end
-
-    # Unregister a previously registered middleware class.
-    #
-    # @param key [Symbol] key for the registered middleware.
-    def unregister_middleware(key)
-      @registered_middleware.delete(key)
-    end
-
-    # Lookup middleware class with a registered Symbol shortcut.
-    #
-    # @param key [Symbol] key for the registered middleware.
-    # @return [Class] a middleware Class.
-    # @raise [Faraday::Error] if given key is not registered
-    #
-    # @example
-    #
-    #   module Faraday
-    #     class Whatever
-    #       register_middleware foo: Foo
-    #     end
-    #   end
-    #
-    #   Faraday::Whatever.lookup_middleware(:foo)
-    #   # => Faraday::Whatever::Foo
-    #
-    def lookup_middleware(key)
-      load_middleware(key) ||
-        raise(Faraday::Error, "#{key.inspect} is not registered on #{self}")
-    end
-
-    def middleware_mutex(&block)
-      @middleware_mutex ||= Monitor.new
-      @middleware_mutex.synchronize(&block)
-    end
-
-    def fetch_middleware(key)
-      defined?(@registered_middleware) && @registered_middleware[key]
-    end
-
-    def load_middleware(key)
-      value = fetch_middleware(key)
-      case value
-      when Module
-        value
-      when Symbol, String
-        middleware_mutex do
-          @registered_middleware[key] = const_get(value)
-        end
-      when Proc
-        middleware_mutex do
-          @registered_middleware[key] = value.call
-        end
-      when Array
-        middleware_mutex do
-          const, path = value
-          if (root = @middleware_autoload_path)
-            path = "#{root}/#{path}"
-          end
-          require(path)
-          @registered_middleware[key] = const
-        end
-        load_middleware(key)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/faraday-1.0.1/lib/faraday/options.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Subclasses Struct with some special helpers for converting from a Hash to
-  # a Struct.
-  class Options < Struct
-    # Public
-    def self.from(value)
-      value ? new.update(value) : new
-    end
-
-    # Public
-    def each
-      return to_enum(:each) unless block_given?
-
-      members.each do |key|
-        yield(key.to_sym, send(key))
-      end
-    end
-
-    # Public
-    def update(obj)
-      obj.each do |key, value|
-        sub_options = self.class.options_for(key)
-        if sub_options
-          new_value = sub_options.from(value) if value
-        elsif value.is_a?(Hash)
-          new_value = value.dup
-        else
-          new_value = value
-        end
-
-        send("#{key}=", new_value) unless new_value.nil?
-      end
-      self
-    end
-
-    # Public
-    def delete(key)
-      value = send(key)
-      send("#{key}=", nil)
-      value
-    end
-
-    # Public
-    def clear
-      members.each { |member| delete(member) }
-    end
-
-    # Public
-    def merge!(other)
-      other.each do |key, other_value|
-        self_value = send(key)
-        sub_options = self.class.options_for(key)
-        new_value = if self_value && sub_options && other_value
-                      self_value.merge(other_value)
-                    else
-                      other_value
-                    end
-        send("#{key}=", new_value) unless new_value.nil?
-      end
-      self
-    end
-
-    # Public
-    def merge(other)
-      dup.merge!(other)
-    end
-
-    # Public
-    def deep_dup
-      self.class.from(self)
-    end
-
-    # Public
-    def fetch(key, *args)
-      unless symbolized_key_set.include?(key.to_sym)
-        key_setter = "#{key}="
-        if !args.empty?
-          send(key_setter, args.first)
-        elsif block_given?
-          send(key_setter, yield(key))
-        else
-          raise self.class.fetch_error_class, "key not found: #{key.inspect}"
-        end
-      end
-      send(key)
-    end
-
-    # Public
-    def values_at(*keys)
-      keys.map { |key| send(key) }
-    end
-
-    # Public
-    def keys
-      members.reject { |member| send(member).nil? }
-    end
-
-    # Public
-    def empty?
-      keys.empty?
-    end
-
-    # Public
-    def each_key
-      return to_enum(:each_key) unless block_given?
-
-      keys.each do |key|
-        yield(key)
-      end
-    end
-
-    # Public
-    def key?(key)
-      keys.include?(key)
-    end
-
-    alias has_key? key?
-
-    # Public
-    def each_value
-      return to_enum(:each_value) unless block_given?
-
-      values.each do |value|
-        yield(value)
-      end
-    end
-
-    # Public
-    def value?(value)
-      values.include?(value)
-    end
-
-    alias has_value? value?
-
-    # Public
-    def to_hash
-      hash = {}
-      members.each do |key|
-        value = send(key)
-        hash[key.to_sym] = value unless value.nil?
-      end
-      hash
-    end
-
-    # Internal
-    def inspect
-      values = []
-      members.each do |member|
-        value = send(member)
-        values << "#{member}=#{value.inspect}" if value
-      end
-      values = values.empty? ? '(empty)' : values.join(', ')
-
-      %(#<#{self.class} #{values}>)
-    end
-
-    # Internal
-    def self.options(mapping)
-      attribute_options.update(mapping)
-    end
-
-    # Internal
-    def self.options_for(key)
-      attribute_options[key]
-    end
-
-    # Internal
-    def self.attribute_options
-      @attribute_options ||= {}
-    end
-
-    def self.memoized(key, &block)
-      unless block_given?
-        raise ArgumentError, '#memoized must be called with a block'
-      end
-
-      memoized_attributes[key.to_sym] = block
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{key}() self[:#{key}]; end
-      RUBY
-    end
-
-    def self.memoized_attributes
-      @memoized_attributes ||= {}
-    end
-
-    def [](key)
-      key = key.to_sym
-      if (method = self.class.memoized_attributes[key])
-        super(key) || (self[key] = instance_eval(&method))
-      else
-        super
-      end
-    end
-
-    def symbolized_key_set
-      @symbolized_key_set ||= Set.new(keys.map(&:to_sym))
-    end
-
-    def self.inherited(subclass)
-      super
-      subclass.attribute_options.update(attribute_options)
-      subclass.memoized_attributes.update(memoized_attributes)
-    end
-
-    def self.fetch_error_class
-      @fetch_error_class ||= if Object.const_defined?(:KeyError)
-                               ::KeyError
-                             else
-                               ::IndexError
-                             end
-    end
-  end
-end
-
-require 'faraday/options/request_options'
-require 'faraday/options/ssl_options'
-require 'faraday/options/proxy_options'
-require 'faraday/options/connection_options'
-require 'faraday/options/env'