logstash-output-scalyr 0.1.8 → 0.1.13

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -0,0 +1,165 @@
+begin
+  require 'excon'
+rescue LoadError
+  # excon not found
+end
+
+if defined?(Excon)
+  WebMock::VersionChecker.new('Excon', Excon::VERSION, '0.27.5').check_version!
+
+  module WebMock
+    module HttpLibAdapters
+
+      class ExconAdapter < HttpLibAdapter
+        PARAMS_TO_DELETE = [:expects, :idempotent,
+                            :instrumentor_name, :instrumentor,
+                            :response_block,
+                            :__construction_args, :stack,
+                            :connection, :response]
+
+        adapter_for :excon
+
+        instance_exec do
+          @original_excon_mock_default = nil
+          @stub = nil
+        end
+
+        def self.enable!
+          self.add_excon_stub
+        end
+
+        def self.disable!
+          self.remove_excon_stub
+        end
+
+        def self.add_excon_stub
+          if not @stub
+            @original_excon_mock_default = ::Excon.defaults[:mock]
+            ::Excon.defaults[:mock] = true
+            @stub = ::Excon.stub({}) do |params|
+              self.handle_request(params)
+            end
+          end
+        end
+
+        def self.remove_excon_stub
+          ::Excon.defaults[:mock] = @original_excon_mock_default
+          @original_excon_mock_default = nil
+          Excon.stubs.delete(@stub)
+          @stub = nil
+        end
+
+        def self.handle_request(params)
+          mock_request  = self.build_request params.dup
+          WebMock::RequestRegistry.instance.requested_signatures.put(mock_request)
+
+          if mock_response = WebMock::StubRegistry.instance.response_for_request(mock_request)
+            self.perform_callbacks(mock_request, mock_response, real_request: false)
+            response = self.real_response(mock_response)
+            response
+          elsif WebMock.net_connect_allowed?(mock_request.uri)
+            conn = new_excon_connection(params)
+            real_response = conn.request(request_params_from(params.merge(mock: false)))
+
+            ExconAdapter.perform_callbacks(mock_request, ExconAdapter.mock_response(real_response), real_request: true)
+
+            real_response.data
+          else
+            raise WebMock::NetConnectNotAllowedError.new(mock_request)
+          end
+        end
+
+        def self.new_excon_connection(params)
+          # Ensure the connection is constructed with the exact same args
+          # that the orginal connection was constructed with.
+          args = params.fetch(:__construction_args)
+          ::Excon::Connection.new(connection_params_from args.merge(mock: false))
+        end
+
+        def self.connection_params_from(hash)
+          hash = hash.dup
+          PARAMS_TO_DELETE.each { |key| hash.delete(key) }
+          hash
+        end
+
+        def self.request_params_from(hash)
+          hash = hash.dup
+          if defined?(Excon::VALID_REQUEST_KEYS)
+            hash.reject! {|key,_| !Excon::VALID_REQUEST_KEYS.include?(key) }
+          end
+          PARAMS_TO_DELETE.each { |key| hash.delete(key) }
+          hash
+        end
+
+        def self.to_query(hash)
+          string = "".dup
+          for key, values in hash
+            if values.nil?
+              string << key.to_s << '&'
+            else
+              for value in [*values]
+                string << key.to_s << '=' << CGI.escape(value.to_s) << '&'
+              end
+            end
+          end
+          string.chop! # remove trailing '&'
+        end
+
+        def self.build_request(params)
+          params = params.dup
+          params.delete(:user)
+          params.delete(:password)
+          method  = (params.delete(:method) || :get).to_s.downcase.to_sym
+          params[:query] = to_query(params[:query]) if params[:query].is_a?(Hash)
+          uri = Addressable::URI.new(params).to_s
+          WebMock::RequestSignature.new method, uri, body: body_from(params), headers: params[:headers]
+        end
+
+        def self.body_from(params)
+          body = params[:body]
+          return body unless body.respond_to?(:read)
+
+          contents = body.read
+          body.rewind if body.respond_to?(:rewind)
+          contents
+        end
+
+        def self.real_response(mock)
+          raise Excon::Errors::Timeout if mock.should_timeout
+          mock.raise_error_if_any
+          {
+            body: mock.body,
+            status: mock.status[0].to_i,
+            reason_phrase: mock.status[1],
+            headers: mock.headers || {}
+          }
+        end
+
+        def self.mock_response(real)
+          mock = WebMock::Response.new
+          mock.status  = [real.status, real.reason_phrase]
+          mock.headers = real.headers
+          mock.body    = real.body.dup
+          mock
+        end
+
+        def self.perform_callbacks(request, response, options = {})
+          return unless WebMock::CallbackRegistry.any_callbacks?
+          WebMock::CallbackRegistry.invoke_callbacks(options.merge(lib: :excon), request, response)
+        end
+      end
+    end
+  end
+
+  Excon::Connection.class_eval do
+    def self.new(args = {})
+      args.delete(:__construction_args)
+      super(args).tap do |instance|
+        instance.data[:__construction_args] = args
+      end
+    end
+  end
+
+  # Suppresses Excon connection argument validation warning
+  Excon::VALID_CONNECTION_KEYS << :__construction_args
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_lib_adapter.rb

@@ -0,0 +1,7 @@
+module WebMock
+  class HttpLibAdapter
+    def self.adapter_for(lib)
+      WebMock::HttpLibAdapterRegistry.instance.register(lib, self)
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_lib_adapter_registry.rb

@@ -0,0 +1,19 @@
+module WebMock
+  class HttpLibAdapterRegistry
+    include Singleton
+
+    attr_accessor :http_lib_adapters
+
+    def initialize
+      @http_lib_adapters = {}
+    end
+
+    def register(lib, adapter)
+      @http_lib_adapters[lib] = adapter
+    end
+
+    def each_adapter(&block)
+      @http_lib_adapters.each(&block)
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb/client.rb

@@ -0,0 +1,17 @@
+module HTTP
+  class Client
+    alias_method :__perform__, :perform
+
+    def perform(request, options)
+      return __perform__(request, options) unless webmock_enabled?
+
+      response = WebMockPerform.new(request) { __perform__(request, options) }.exec
+      options.features.each { |_name, feature| response = feature.wrap_response(response) }
+      response
+    end
+
+    def webmock_enabled?
+      ::WebMock::HttpLibAdapters::HttpRbAdapter.enabled?
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb/request.rb

@@ -0,0 +1,16 @@
+module HTTP
+  class Request
+    def webmock_signature
+      request_body = if defined?(HTTP::Request::Body)
+                       ''.tap { |string| body.each { |part| string << part } }
+                     else
+                       body
+                     end
+
+      ::WebMock::RequestSignature.new(verb, uri.to_s, {
+        headers: headers.to_h,
+        body: request_body
+      })
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb/response.rb

@@ -0,0 +1,64 @@
+module HTTP
+  class Response
+    def to_webmock
+      webmock_response = ::WebMock::Response.new
+
+      webmock_response.status  = [status.to_i, reason]
+      webmock_response.body    = body.to_s
+      webmock_response.headers = headers.to_h
+
+      webmock_response
+    end
+
+    class << self
+      def from_webmock(request, webmock_response, request_signature = nil)
+        status  = Status.new(webmock_response.status.first)
+        headers = webmock_response.headers || {}
+        uri     = normalize_uri(request_signature && request_signature.uri)
+
+        # HTTP.rb 3.0+ uses a keyword argument to pass the encoding, but 1.x
+        # and 2.x use a positional argument, and 0.x don't support supplying
+        # the encoding.
+        body = if HTTP::VERSION < "1.0.0"
+          Body.new(Streamer.new(webmock_response.body))
+        elsif HTTP::VERSION < "3.0.0"
+          Body.new(Streamer.new(webmock_response.body), webmock_response.body.encoding)
+        else
+          Body.new(Streamer.new(webmock_response.body), encoding: webmock_response.body.encoding)
+        end
+
+        return new(status, "1.1", headers, body, uri) if HTTP::VERSION < "1.0.0"
+
+        # 5.0.0 had a breaking change to require request instead of uri.
+        if HTTP::VERSION < '5.0.0'
+          return new({
+            status: status,
+            version: "1.1",
+            headers: headers,
+            body: body,
+            uri: uri
+          })
+        end
+
+        new({
+          status: status,
+          version: "1.1",
+          headers: headers,
+          body: body,
+          request: request,
+        })
+      end
+
+      private
+
+      def normalize_uri(uri)
+        return unless uri
+
+        uri = Addressable::URI.parse uri
+        uri.port = nil if uri.default_port && uri.port == uri.default_port
+
+        uri
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb/streamer.rb

@@ -0,0 +1,29 @@
+module HTTP
+  class Response
+    class Streamer
+      def initialize(str)
+        @io = StringIO.new str
+      end
+
+      def readpartial(size = nil, outbuf = nil)
+        unless size
+          if defined?(HTTP::Client::BUFFER_SIZE)
+            size = HTTP::Client::BUFFER_SIZE
+          elsif defined?(HTTP::Connection::BUFFER_SIZE)
+            size = HTTP::Connection::BUFFER_SIZE
+          end
+        end
+
+        @io.read size, outbuf
+      end
+
+      def close
+        @io.close
+      end
+
+      def sequence_id
+        -1
+      end
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb/webmock.rb

@@ -0,0 +1,68 @@
+module HTTP
+  class WebMockPerform
+    def initialize(request, &perform)
+      @request = request
+      @perform = perform
+      @request_signature = nil
+    end
+
+    def exec
+      replay || perform || halt
+    end
+
+    def request_signature
+      unless @request_signature
+        @request_signature = @request.webmock_signature
+        register_request(@request_signature)
+      end
+
+      @request_signature
+    end
+
+    protected
+
+    def response_for_request(signature)
+      ::WebMock::StubRegistry.instance.response_for_request(signature)
+    end
+
+    def register_request(signature)
+      ::WebMock::RequestRegistry.instance.requested_signatures.put(signature)
+    end
+
+    def replay
+      webmock_response = response_for_request request_signature
+
+      return unless webmock_response
+
+      raise_timeout_error if webmock_response.should_timeout
+      webmock_response.raise_error_if_any
+
+      invoke_callbacks(webmock_response, real_request: false)
+      ::HTTP::Response.from_webmock @request, webmock_response, request_signature
+    end
+
+    def raise_timeout_error
+      raise Errno::ETIMEDOUT if HTTP::VERSION < "1.0.0"
+      raise HTTP::TimeoutError, "connection error: #{Errno::ETIMEDOUT.new}"
+    end
+
+    def perform
+      return unless ::WebMock.net_connect_allowed?(request_signature.uri)
+      response = @perform.call
+      invoke_callbacks(response.to_webmock, real_request: true)
+      response
+    end
+
+    def halt
+      raise ::WebMock::NetConnectNotAllowedError.new request_signature
+    end
+
+    def invoke_callbacks(webmock_response, options = {})
+      ::WebMock::CallbackRegistry.invoke_callbacks(
+        options.merge({ lib: :http_rb }),
+        request_signature,
+        webmock_response
+      )
+    end
+  end
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/http_rb_adapter.rb

@@ -0,0 +1,37 @@
+begin
+  require "http"
+rescue LoadError
+  # HTTP gem not found
+end
+
+if defined?(HTTP) && defined?(HTTP::VERSION)
+  WebMock::VersionChecker.new("HTTP Gem", HTTP::VERSION, "0.6.0").check_version!
+
+  module WebMock
+    module HttpLibAdapters
+      class HttpRbAdapter < HttpLibAdapter
+        adapter_for :http_rb
+
+        class << self
+          def enable!
+            @enabled = true
+          end
+
+          def disable!
+            @enabled = false
+          end
+
+          def enabled?
+            @enabled
+          end
+        end
+      end
+    end
+  end
+
+  require "webmock/http_lib_adapters/http_rb/client"
+  require "webmock/http_lib_adapters/http_rb/request"
+  require "webmock/http_lib_adapters/http_rb/response"
+  require "webmock/http_lib_adapters/http_rb/streamer"
+  require "webmock/http_lib_adapters/http_rb/webmock"
+end

data/vendor/bundle/jruby/2.5.0/gems/webmock-3.13.0/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -0,0 +1,259 @@
+begin
+  require 'httpclient'
+  require 'jsonclient' # defined in 'httpclient' gem as well
+rescue LoadError
+  # httpclient not found
+  # or jsonclient not defined (in old versions of httclient gem)
+end
+
+if defined?(::HTTPClient)
+
+  module WebMock
+    module HttpLibAdapters
+      class HTTPClientAdapter < HttpLibAdapter
+        adapter_for :httpclient
+
+        unless const_defined?(:OriginalHttpClient)
+          OriginalHttpClient = ::HTTPClient
+        end
+
+        unless const_defined?(:OriginalJsonClient)
+          OriginalJsonClient = ::JSONClient if defined?(::JSONClient)
+        end
+
+        def self.enable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, WebMockHTTPClient)
+          if defined? ::JSONClient
+            Object.send(:remove_const, :JSONClient)
+            Object.send(:const_set, :JSONClient, WebMockJSONClient)
+          end
+        end
+
+        def self.disable!
+          Object.send(:remove_const, :HTTPClient)
+          Object.send(:const_set, :HTTPClient, OriginalHttpClient)
+          if defined? ::JSONClient
+            Object.send(:remove_const, :JSONClient)
+            Object.send(:const_set, :JSONClient, OriginalJsonClient)
+          end
+        end
+      end
+    end
+  end
+
+  module WebMockHTTPClients
+
+    REQUEST_RESPONSE_LOCK = Mutex.new
+
+    def do_get_block(req, proxy, conn, &block)
+      do_get(req, proxy, conn, false, &block)
+    end
+
+    def do_get_stream(req, proxy, conn, &block)
+      do_get(req, proxy, conn, true, &block)
+    end
+
+    def do_get(req, proxy, conn, stream = false, &block)
+      request_signature = build_request_signature(req, :reuse_existing)
+
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+      if webmock_responses[request_signature]
+        webmock_response = synchronize_request_response { webmock_responses.delete(request_signature) }
+        response = build_httpclient_response(webmock_response, stream, req.header, &block)
+        @request_filter.each do |filter|
+          filter.filter_response(req, response)
+        end
+        res = conn.push(response)
+        WebMock::CallbackRegistry.invoke_callbacks(
+          {lib: :httpclient}, request_signature, webmock_response)
+        res
+      elsif WebMock.net_connect_allowed?(request_signature.uri)
+        # in case there is a nil entry in the hash...
+        synchronize_request_response { webmock_responses.delete(request_signature) }
+
+        res = if stream
+          do_get_stream_without_webmock(req, proxy, conn, &block)
+        elsif block
+          body = ''
+          do_get_block_without_webmock(req, proxy, conn) do |http_res, chunk|
+            if chunk && chunk.bytesize > 0
+              body += chunk
+              block.call(http_res, chunk)
+            end
+          end
+        else
+          do_get_block_without_webmock(req, proxy, conn)
+        end
+        res = conn.pop
+        conn.push(res)
+        if WebMock::CallbackRegistry.any_callbacks?
+          webmock_response = build_webmock_response(res, body)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {lib: :httpclient, real_request: true}, request_signature,
+            webmock_response)
+        end
+        res
+      else
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
+      end
+    end
+
+    def do_request_async(method, uri, query, body, extheader)
+      req = create_request(method, uri, query, body, extheader)
+      request_signature = build_request_signature(req)
+      synchronize_request_response { webmock_request_signatures << request_signature }
+
+      if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
+        super
+      else
+        raise WebMock::NetConnectNotAllowedError.new(request_signature)
+      end
+    end
+
+    def build_httpclient_response(webmock_response, stream = false, req_header = nil, &block)
+      body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
+      response = HTTP::Message.new_response(body, req_header)
+      response.header.init_response(webmock_response.status[0])
+      response.reason=webmock_response.status[1]
+      webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
+
+      raise HTTPClient::TimeoutError if webmock_response.should_timeout
+      webmock_response.raise_error_if_any
+
+      block.call(response, body) if block && body && body.bytesize > 0
+
+      response
+    end
+
+    def build_webmock_response(httpclient_response, body = nil)
+      webmock_response = WebMock::Response.new
+      webmock_response.status = [httpclient_response.status, httpclient_response.reason]
+
+      webmock_response.headers = {}.tap do |hash|
+        httpclient_response.header.all.each do |(key, value)|
+          if hash.has_key?(key)
+            hash[key] = Array(hash[key]) + [value]
+          else
+            hash[key] = value
+          end
+        end
+      end
+
+      if body
+        webmock_response.body = body
+      elsif httpclient_response.content.respond_to?(:read)
+        webmock_response.body = httpclient_response.content.read
+        body = HTTP::Message::Body.new
+        body.init_response(StringIO.new(webmock_response.body))
+        httpclient_response.body = body
+      else
+        webmock_response.body = httpclient_response.content
+      end
+      webmock_response
+    end
+
+    def build_request_signature(req, reuse_existing = false)
+      uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
+      uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query, notation: WebMock::Config.instance.query_values_notation) if req.header.request_query
+      uri.port = req.header.request_uri.port
+
+      @request_filter.each do |filter|
+        filter.filter_request(req)
+      end
+
+      headers = req.header.all.inject({}) do |hdrs, header|
+        hdrs[header[0]] ||= []
+        hdrs[header[0]] << header[1]
+        hdrs
+      end
+      headers = headers_from_session(uri).merge(headers)
+
+      signature = WebMock::RequestSignature.new(
+        req.header.request_method.downcase.to_sym,
+        uri.to_s,
+        body: req.http_body.dump,
+        headers: headers
+      )
+
+      # reuse a previous identical signature object if we stored one for later use
+      if reuse_existing && previous_signature = previous_signature_for(signature)
+        return previous_signature
+      end
+
+      signature
+    end
+
+    def webmock_responses
+      @webmock_responses ||= Hash.new do |hash, request_signature|
+        synchronize_request_response do
+          hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        end
+      end
+    end
+
+    def webmock_request_signatures
+      @webmock_request_signatures ||= []
+    end
+
+    def previous_signature_for(signature)
+      synchronize_request_response do
+        return nil unless index = webmock_request_signatures.index(signature)
+        webmock_request_signatures.delete_at(index)
+      end
+    end
+
+    private
+
+    # some of the headers sent by HTTPClient are derived from
+    # the client session
+    def headers_from_session(uri)
+      session_headers = HTTP::Message::Headers.new
+      @session_manager.send(:open, uri).send(:set_header, MessageMock.new(session_headers))
+      session_headers.all.inject({}) do |hdrs, header|
+        hdrs[header[0]] = header[1]
+        hdrs
+      end
+    end
+
+    def synchronize_request_response
+      if REQUEST_RESPONSE_LOCK.owned?
+        yield
+      else
+        REQUEST_RESPONSE_LOCK.synchronize do
+          yield
+        end
+      end
+    end
+  end
+
+  class WebMockHTTPClient < HTTPClient
+    alias_method :do_get_block_without_webmock, :do_get_block
+    alias_method :do_get_stream_without_webmock, :do_get_stream
+
+    include WebMockHTTPClients
+  end
+
+  if defined? ::JSONClient
+    class WebMockJSONClient < JSONClient
+      alias_method :do_get_block_without_webmock, :do_get_block
+      alias_method :do_get_stream_without_webmock, :do_get_stream
+
+      include WebMockHTTPClients
+    end
+  end
+
+
+  # Mocks a HTTPClient HTTP::Message
+  class MessageMock
+    attr_reader :header
+
+    def initialize(headers)
+      @header = headers
+    end
+
+    def http_version=(value);end
+  end
+
+end