sniffer 0.3.1 → 0.5.0

data/lib/sniffer/adapters/ethon_adapter.rb

@@ -6,42 +6,43 @@ module Sniffer
     module EthonAdapter
       # overrides http_request method
       module Http
-        def self.included(base)
-          base.class_eval do
-            alias_method :http_request_without_sniffer, :http_request
-            alias_method :http_request, :http_request_with_sniffer
-          end
+        def http_request_with_sniffer(url, action_name, options = {})
+          make_sniffer_request(url, action_name, options)
+
+          http_request_without_sniffer(url, action_name, options)
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        def http_request_with_sniffer(url, action_name, options = {})
-          if Sniffer.enabled?
-            @data_item = Sniffer::DataItem.new
-            uri = URI("http://" + url)
+        private
 
-            @data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
-                                                                method: action_name.upcase,
-                                                                port: options[:port] || uri.port,
-                                                                headers: options[:headers].to_h,
-                                                                body: options[:body].to_s)
+        def make_sniffer_request(url, action_name, options)
+          return unless Sniffer.enabled?
 
-            Sniffer.store(@data_item)
-          end
+          @data_item = Sniffer::DataItem.new
+          uri = URI("http://#{url}")
 
-          http_request_without_sniffer(url, action_name, options)
+          @data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
+                                                              method: action_name.upcase,
+                                                              port: options[:port] || uri.port,
+                                                              headers: options[:headers].to_h,
+                                                              body: options[:body].to_s)
+
+          Sniffer.store(@data_item)
         end
-      end
-      # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
 
-      # overrides perform method
-      module Operations
-        def self.included(base)
-          base.class_eval do
-            alias_method :perform_without_sniffer, :perform
-            alias_method :perform, :perform_with_sniffer
+        # Only used when prepending, see all_prepend.rb
+        module Prepend
+          include Http
+
+          def http_request(url, action_name, options = {})
+            make_sniffer_request(url, action_name, options)
+
+            super(url, action_name, options)
           end
         end
+      end
 
+      # overrides perform method
+      module Operations
         # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
         def perform_with_sniffer
           bm = Benchmark.realtime do
@@ -49,12 +50,12 @@ module Sniffer
           end
 
           if Sniffer.enabled?
-            uri = URI("http://" + @url)
+            uri = URI("http://#{@url}")
             query = uri.path
             query += "?#{uri.query}" if uri.query
             @data_item.request.query = query
 
-            status = @response_headers.scan(%r{HTTP\/... (\d{3})}).flatten[0].to_i
+            status = @response_headers.scan(%r{HTTP/... (\d{3})}).flatten[0].to_i
             hash_headers = @response_headers
                            .split(/\r?\n/)[1..-1]
                            .each_with_object({}) do |item, res|
@@ -66,7 +67,7 @@ module Sniffer
                                                                   headers: hash_headers,
                                                                   body: @response_body,
                                                                   timing: bm)
-            @data_item.log
+            Sniffer.notify_response(@data_item)
 
           end
 
@@ -76,12 +77,33 @@ module Sniffer
           @return_code
         end
         # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+        # Only used when prepending, see all_prepend.rb
+        module Prepend
+          include Operations
+
+          def perform
+            perform_with_sniffer
+          end
+        end
       end
     end
   end
 end
 
 if defined?(::Ethon::Easy)
-  Ethon::Easy::Http.send(:include, Sniffer::Adapters::EthonAdapter::Http)
-  Ethon::Easy::Operations.send(:include, Sniffer::Adapters::EthonAdapter::Operations)
+  if defined?(Sniffer::Adapters::EthonAdapter::PREPEND)
+    Ethon::Easy.prepend Sniffer::Adapters::EthonAdapter::Http::Prepend
+    Ethon::Easy.prepend Sniffer::Adapters::EthonAdapter::Operations::Prepend
+  else
+    Ethon::Easy.class_eval do
+      include Sniffer::Adapters::EthonAdapter::Http
+      alias_method :http_request_without_sniffer, :http_request
+      alias_method :http_request, :http_request_with_sniffer
+
+      include Sniffer::Adapters::EthonAdapter::Operations
+      alias_method :perform_without_sniffer, :perform
+      alias_method :perform, :perform_with_sniffer
+    end
+  end
 end

data/lib/sniffer/adapters/eventmachine_adapter.rb

@@ -6,58 +6,94 @@ module Sniffer
     module EventMachineAdapter
       # Overrides #send_request, #parse_response, #on_body_data
       module Client
-        def self.included(base)
-          base.class_eval do
-            alias_method :send_request_without_sniffer, :send_request
-            alias_method :send_request, :send_request_with_sniffer
-            alias_method :parse_response_header_without_sniffer, :parse_response_header
-            alias_method :parse_response_header, :parse_response_header_with_sniffer
-            alias_method :on_body_data_without_sniffer, :on_body_data
-            alias_method :on_body_data, :on_body_data_with_sniffer
-          end
-        end
-
-        # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
         def send_request_with_sniffer(head, body)
-          if Sniffer.enabled?
-            @data_item = Sniffer::DataItem.new
-            @data_item.response = Sniffer::DataItem::Response.new
-            @data_item.request = Sniffer::DataItem::Request.new(host: @req.host,
-                                                                method: @req.method.to_sym,
-                                                                query: encode_query(@req.uri, @req.query),
-                                                                headers: @req.headers,
-                                                                body: @req.body.to_s,
-                                                                port: @req.port)
-            Sniffer.store(@data_item)
-
-            @start_time = Time.now
-          end
-
+          send_request_sniffer(head, body)
           send_request_without_sniffer(head, body)
         end
-        # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
 
         def parse_response_header_with_sniffer(header, version, status)
-          if Sniffer.enabled?
-            @data_item.response.timing = Time.now - @start_time
-            @data_item.response.status = status
-            @data_item.response.headers = header
-          end
-
+          parse_response_header_sniffer(header, version, status)
           parse_response_header_without_sniffer(header, version, status)
         end
 
         def on_body_data_with_sniffer(data)
-          if Sniffer.enabled?
-            @data_item.response.body = data
-            @data_item.log
+          on_body_data_sniffer(data)
+          on_body_data_without_sniffer(data)
+        end
+
+        private
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def send_request_sniffer(_head, _body)
+          return unless Sniffer.enabled?
+
+          @data_item = Sniffer::DataItem.new
+          @data_item.response = Sniffer::DataItem::Response.new
+          @data_item.request = Sniffer::DataItem::Request.new(host: @req.host,
+                                                              method: @req.method.to_sym,
+                                                              query: encode_query(@req.uri, @req.query),
+                                                              headers: @req.headers,
+                                                              body: @req.body.to_s,
+                                                              port: @req.port)
+          Sniffer.store(@data_item)
+
+          @start_time = Time.now
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        def parse_response_header_sniffer(header, _version, status)
+          return unless Sniffer.enabled?
+
+          @data_item.response.timing = Time.now - @start_time
+          @data_item.response.status = status
+          @data_item.response.headers = header
+        end
+
+        def on_body_data_sniffer(data)
+          return unless Sniffer.enabled?
+
+          @data_item.response.body = data
+          Sniffer.notify_response(@data_item)
+        end
+
+        # Only used when prepending, see all_prepend.rb
+        module Prepend
+          include Client
+
+          def send_request(head, body)
+            send_request_sniffer(head, body)
+            super(head, body)
           end
 
-          on_body_data_without_sniffer(data)
+          def parse_response_header(header, version, status)
+            parse_response_header_sniffer(header, version, status)
+            super(header, version, status)
+          end
+
+          def on_body_data(data)
+            on_body_data_sniffer(data)
+            super(data)
+          end
         end
       end
     end
   end
 end
 
-EventMachine::HttpClient.send(:include, Sniffer::Adapters::EventMachineAdapter::Client) if defined?(::EventMachine)
+EventMachine::HttpClient.include Sniffer::Adapters::EventMachineAdapter::Client if defined?(::EventMachine::HttpClient)
+
+if defined?(::EventMachine::HttpClient)
+  if defined?(Sniffer::Adapters::EventMachineAdapter::PREPEND)
+    EventMachine::HttpClient.prepend Sniffer::Adapters::EventMachineAdapter::Client::Prepend
+  else
+    EventMachine::HttpClient.class_eval do
+      include Sniffer::Adapters::EventMachineAdapter::Client
+      alias_method :send_request_without_sniffer, :send_request
+      alias_method :send_request, :send_request_with_sniffer
+      alias_method :parse_response_header_without_sniffer, :parse_response_header
+      alias_method :parse_response_header, :parse_response_header_with_sniffer
+      alias_method :on_body_data_without_sniffer, :on_body_data
+      alias_method :on_body_data, :on_body_data_with_sniffer
+    end
+  end
+end

data/lib/sniffer/adapters/excon_adapter.rb

@@ -4,46 +4,76 @@ module Sniffer
   module Adapters
     # Excon adapter
     module ExconAdapter
-      def self.included(base)
-        base.class_eval do
-          alias_method :request_without_sniffer, :request
-          alias_method :request, :request_with_sniffer
-        end
-      end
-
-      # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       def request_with_sniffer(params = {}, &block)
-        if Sniffer.enabled?
-          datum = data.merge(params)
-          data_item = Sniffer::DataItem.new
-          data_item.request = Sniffer::DataItem::Request.new(host: datum[:host],
-                                                             method: datum[:method],
-                                                             query: datum[:path] + ::Excon::Utils.query_string(datum),
-                                                             headers: datum[:headers] || {},
-                                                             body: datum[:body].to_s,
-                                                             port: datum[:port])
-
-          Sniffer.store(data_item)
-        end
+        data_item = request_sniffer_before(params)
 
         bm = Benchmark.realtime do
           @response = request_without_sniffer(params, &block)
         end
 
-        if Sniffer.enabled?
-          data_item.response = Sniffer::DataItem::Response.new(status: @response.status,
-                                                               headers: @response.headers,
-                                                               body: @response.body,
-                                                               timing: bm)
+        request_sniffer_after(params, bm, data_item)
+        @response
+      end
+
+      private
 
-          data_item.log
-        end
+      # rubocop:disable Metrics/MethodLength
+      def request_sniffer_before(params)
+        return unless Sniffer.enabled?
 
-        @response
+        datum = data.merge(params)
+        data_item = Sniffer::DataItem.new
+        data_item.request = Sniffer::DataItem::Request.new(host: datum[:host],
+                                                           method: datum[:method],
+                                                           query: datum[:path] + ::Excon::Utils.query_string(datum),
+                                                           headers: datum[:headers] || {},
+                                                           body: datum[:body].to_s,
+                                                           port: datum[:port])
+
+        Sniffer.store(data_item)
+
+        data_item
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def request_sniffer_after(_params, benchmark, data_item)
+        return unless Sniffer.enabled?
+
+        data_item.response = Sniffer::DataItem::Response.new(status: @response.status,
+                                                             headers: @response.headers,
+                                                             body: @response.body,
+                                                             timing: benchmark)
+
+        Sniffer.notify_response(data_item)
+      end
+
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include ExconAdapter
+
+        def request(params = {}, &block)
+          data_item = request_sniffer_before(params)
+
+          bm = Benchmark.realtime do
+            @response = super(params, &block)
+          end
+
+          request_sniffer_after(params, bm, data_item)
+          @response
+        end
       end
-      # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
     end
   end
 end
 
-::Excon::Connection.send(:include, Sniffer::Adapters::ExconAdapter) if defined?(::Excon::Connection)
+if defined?(::Excon::Connection)
+  if defined?(Sniffer::Adapters::ExconAdapter::PREPEND)
+    ::Excon::Connection.prepend Sniffer::Adapters::ExconAdapter::Prepend
+  else
+    ::Excon::Connection.class_eval do
+      include Sniffer::Adapters::ExconAdapter
+      alias_method :request_without_sniffer, :request
+      alias_method :request, :request_with_sniffer
+    end
+  end
+end

data/lib/sniffer/adapters/http_adapter.rb

@@ -4,13 +4,6 @@ module Sniffer
   module Adapters
     # HTTP adapter
     module HTTPAdapter
-      def self.included(base)
-        base.class_eval do
-          alias_method :request_without_sniffer, :request
-          alias_method :request, :request_with_sniffer
-        end
-      end
-
       # private
 
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -55,7 +48,7 @@ module Sniffer
                                                                body: @res.body,
                                                                timing: bm)
 
-          data_item.log
+          Sniffer.notify_response(data_item)
         end
 
         return @res unless opts.follow
@@ -64,9 +57,28 @@ module Sniffer
           perform(request, opts)
         end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include HTTPAdapter
+
+        def request(*args)
+          request_with_sniffer(*args)
+        end
+      end
     end
   end
 end
 
-HTTP::Client.send(:include, Sniffer::Adapters::HTTPAdapter) if defined?(::HTTP::Client)
+if defined?(::HTTP::Client)
+  if defined?(Sniffer::Adapters::HTTPAdapter::PREPEND)
+    HTTP::Client.prepend Sniffer::Adapters::HTTPAdapter::Prepend
+  else
+    HTTP::Client.class_eval do
+      include Sniffer::Adapters::HTTPAdapter
+      alias_method :request_without_sniffer, :request
+      alias_method :request, :request_with_sniffer
+    end
+  end
+end

data/lib/sniffer/adapters/httpclient_adapter.rb

@@ -4,56 +4,88 @@ module Sniffer
   module Adapters
     # HttpClient adapter
     module HTTPClientAdapter
-      def self.included(base)
-        base.class_eval do
-          alias_method :do_get_block_without_sniffer, :do_get_block
-          alias_method :do_get_block, :do_get_block_with_sniffer
+      def do_get_block_with_sniffer(req, proxy, conn, &block)
+        data_item = do_get_block_sniffer_before(req)
+
+        retryable_response = nil
+
+        bm = Benchmark.realtime do
+          do_get_block_without_sniffer(req, proxy, conn, &block)
+        rescue HTTPClient::RetryableResponse => e
+          retryable_response = e
         end
+
+        do_get_block_sniffer_after(data_item, conn, bm)
+
+        raise retryable_response unless retryable_response.nil?
       end
 
-      # private
+      private
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def do_get_block_with_sniffer(req, proxy, conn, &block)
-        if Sniffer.enabled?
-          data_item = Sniffer::DataItem.new
-          data_item.request = Sniffer::DataItem::Request.new(host: req.header.request_uri.host,
-                                                             query: req.header.create_query_uri,
-                                                             method: req.header.request_method,
-                                                             headers: req.headers,
-                                                             body: req.body,
-                                                             port: req.header.request_uri.port)
-
-          Sniffer.store(data_item)
-        end
+      # rubocop:disable Metrics/AbcSize
+      def do_get_block_sniffer_before(req)
+        return unless Sniffer.enabled?
 
-        retryable_response = nil
+        data_item = Sniffer::DataItem.new
+        data_item.request = Sniffer::DataItem::Request.new(host: req.header.request_uri.host,
+                                                           query: req.header.create_query_uri,
+                                                           method: req.header.request_method,
+                                                           headers: req.headers,
+                                                           body: req.body,
+                                                           port: req.header.request_uri.port)
 
-        bm = Benchmark.realtime do
-          begin
-            do_get_block_without_sniffer(req, proxy, conn, &block)
+        Sniffer.store(data_item)
+
+        data_item
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def do_get_block_sniffer_after(data_item, conn, benchmark)
+        return unless Sniffer.enabled?
+
+        res = conn.pop
+        data_item.response = Sniffer::DataItem::Response.new(status: res.status_code.to_i,
+                                                             headers: res.headers,
+                                                             body: res.body,
+                                                             timing: benchmark)
+
+        conn.push(res)
+
+        Sniffer.notify_response(data_item)
+      end
+
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include HTTPClientAdapter
+
+        def do_get_block(req, proxy, conn, &block)
+          data_item = do_get_block_sniffer_before(req)
+
+          retryable_response = nil
+
+          bm = Benchmark.realtime do
+            super(req, proxy, conn, &block)
           rescue HTTPClient::RetryableResponse => e
             retryable_response = e
           end
-        end
-
-        if Sniffer.enabled?
-          res = conn.pop
-          data_item.response = Sniffer::DataItem::Response.new(status: res.status_code.to_i,
-                                                               headers: res.headers,
-                                                               body: res.body,
-                                                               timing: bm)
 
-          conn.push(res)
+          do_get_block_sniffer_after(data_item, conn, bm)
 
-          data_item.log
+          raise retryable_response unless retryable_response.nil?
         end
-
-        raise retryable_response unless retryable_response.nil?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
     end
   end
 end
 
-HTTPClient.send(:include, Sniffer::Adapters::HTTPClientAdapter) if defined?(::HTTPClient)
+if defined?(::HTTPClient)
+  if defined?(Sniffer::Adapters::HTTPClientAdapter::PREPEND)
+    HTTPClient.prepend Sniffer::Adapters::HTTPClientAdapter::Prepend
+  else
+    HTTPClient.class_eval do
+      include Sniffer::Adapters::HTTPClientAdapter
+      alias_method :do_get_block_without_sniffer, :do_get_block
+      alias_method :do_get_block, :do_get_block_with_sniffer
+    end
+  end
+end

data/lib/sniffer/adapters/net_http_adapter.rb

@@ -7,44 +7,75 @@ module Sniffer
   module Adapters
     # Net::HTTP adapter
     module NetHttpAdapter
-      def self.included(base)
-        base.class_eval do
-          alias_method :request_without_sniffer, :request
-          alias_method :request, :request_with_sniffer
-        end
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def request_with_sniffer(req, body = nil, &block)
-        if started? && Sniffer.enabled?
-          data_item = Sniffer::DataItem.new
-          data_item.request = Sniffer::DataItem::Request.new(host: @address,
-                                                             method: req.method,
-                                                             query: req.path,
-                                                             port: @port,
-                                                             headers: req.each_header.collect.to_h,
-                                                             body: req.body.to_s)
-
-          Sniffer.store(data_item)
-        end
+        data_item = request_sniffer_before(req)
 
         bm = Benchmark.realtime do
           @response = request_without_sniffer(req, body, &block)
         end
 
-        if started? && Sniffer.enabled?
-          data_item.response = Sniffer::DataItem::Response.new(status: @response.code.to_i,
-                                                               headers: @response.each_header.collect.to_h,
-                                                               body: @response.body.to_s,
-                                                               timing: bm)
-
-          data_item.log
-        end
+        request_sniffer_after(data_item, bm)
 
         @response
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      private
+
+      def request_sniffer_before(req)
+        return unless started? && Sniffer.enabled?
+
+        data_item = Sniffer::DataItem.new
+        data_item.request = Sniffer::DataItem::Request.new(host: @address,
+                                                           method: req.method,
+                                                           query: req.path,
+                                                           port: @port,
+                                                           headers: req.each_header.collect.to_h,
+                                                           body: req.body.to_s)
+
+        Sniffer.store(data_item)
+
+        data_item
+      end
+
+      def request_sniffer_after(data_item, benchmark)
+        return unless started? && Sniffer.enabled?
+
+        data_item.response = Sniffer::DataItem::Response.new(status: @response.code.to_i,
+                                                             headers: @response.each_header.collect.to_h,
+                                                             body: @response.body.to_s,
+                                                             timing: benchmark)
+
+        Sniffer.notify_response(data_item)
+      end
+
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include NetHttpAdapter
+
+        def request(req, body = nil, &block)
+          data_item = request_sniffer_before(req)
+
+          bm = Benchmark.realtime do
+            @response = super(req, body, &block)
+          end
+
+          request_sniffer_after(data_item, bm)
+
+          @response
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Net::HTTP)
+  if defined?(Sniffer::Adapters::NetHttpAdapter::PREPEND)
+    Net::HTTP.prepend Sniffer::Adapters::NetHttpAdapter::Prepend
+  else
+    Net::HTTP.class_eval do
+      include Sniffer::Adapters::NetHttpAdapter
+      alias_method :request_without_sniffer, :request
+      alias_method :request, :request_with_sniffer
     end
   end
 end
-Net::HTTP.send(:include, Sniffer::Adapters::NetHttpAdapter)