sniffer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50fc6c81f9d42483702b1f7c58c784bb34098d4b687bb14463cdff1a115ca9b7
-  data.tar.gz: e075f394c7b28b95468039faf893f5cc3cb5a548111a065f69b81fbda715bfe2
+  metadata.gz: 25c004fd4e29948699cec6a077433d3b0d98f3571c361be81c4f15626f2143a3
+  data.tar.gz: f08cbb6c16a3d572a3536c2a08eff0978f87e4f4d35b489d4cbfdf3ea60c6af9
 SHA512:
-  metadata.gz: 71103bf582fe917cda1c4ad52c7e238c851c2aeb5459c5375b7157394cf0893e0cc2d2d1d100f3006d0a176accf083c6bf55d90d21d4f9f8b8ba395d50eefd60
-  data.tar.gz: d765279e5adb997fd1021a131587a96ae6057f8ee808af9debe657c1f67fdaecd537c23d62d8663729e79ae24f81e5f4f7f6bf54326870bf3a29e939bc04af05
+  metadata.gz: 9548307ea9f504e05ce9fa1f789a1e0d697906841f34a317f5c67c3e1c0ae669f69afab0537fe5e331550e10b531016227ff68321c1f4eadb4bc3f3d6d7a896b
+  data.tar.gz: 1cacd254ba99b6167c4d2221061ebbba0cb2565c281fe100df31190ac0e37035c14e008544d5f2f02b980a08609187841886d700354c6e76a95cd31afb84781e

data/.github/workflows/rspec.yml

@@ -12,13 +12,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["2.5.x", "2.6.x"]
+        ruby-version: ['3.1', '3.0', '2.7', '2.6', '2.5']
     steps:
-      - uses: actions/checkout@v1
-      - name: Set up Ruby
-        uses: actions/setup-ruby@v1
+      - uses: actions/checkout@v2
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
         with:
-          ruby-version: ${{ matrix.ruby }}
+          ruby-version: ${{ matrix.ruby-version }}
       - name: Install Bundler
         run: |
           gem install bundler
@@ -31,4 +31,7 @@ jobs:
           bundle install --jobs 4 --retry 3
       - name: Run RSpec
         run: |
-          bundle exec rake spec
+          bundle exec rspec
+      - name: Run RSpec (prepended)
+        run: |
+          bundle exec rspec -r all_prepend

data/CHANGELOG.md

@@ -1,6 +1,13 @@
+## 0.5.0 (May 6, 2022) ##
+
+* Added prepend of all adapters by [@nate-at-gusto](https://github.com/nate-at-gusto)
+* Replaced `active_attr` to `dry-initializer`
+* Added rubies `2.7`, `3.0`, `3.1` support
+
+
 ## 0.4.0 (March 19, 2020) ##
 
-* Added middleware support
+* Added middleware support by [@dsalahutdinov](https://github.com/dsalahutdinov)
 
 
 ## 0.3.2 (January 12, 2018) ##

data/README.md

@@ -31,6 +31,20 @@ Add this line to your application's Gemfile:
 gem 'sniffer'
 ```
 
+If you wish Sniffer to use `Module#prepend` instead of `alias_method`, you can cause individual adapters to use `prepend` instead with:
+
+```ruby
+gem 'sniffer', require: ['http_prepend', 'httpclient_prepend', 'sniffer']
+```
+
+It's important that `'sniffer'` is the last item in the list. See the `lib` directory for a list of prependable adapters.
+
+If you want all adapters to use `prepend`:
+
+```ruby
+gem 'sniffer', require: ['all_prepend', 'sniffer']
+```
+
 And then execute:
 
     $ bundle
@@ -203,6 +217,15 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+
+## Development (with Docker)
+
+Get local development environment working and tests running is very easy with docker-compose:
+```sh
+docker-compose run app bundle
+docker-compose run app bundle exec rspec
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/aderyabin/sniffer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
@@ -215,6 +238,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/aderya
 * [Stanislav Chereshkevich](https://github.com/dissident)
 * [Anatoliy Kurichev](https://github.com/russo-matrosso)
 * [Dmitriy Ivliev](https://github.com/moofkit)
+* [Nate Berkopec](https://github.com/nate-at-gusto)
 
 ## License
 

data/docker-compose.yml

@@ -0,0 +1,18 @@
+version: '3.4'
+
+services:
+  app:
+    image: ruby:latest
+    environment:
+      - BUNDLE_PATH=/bundle
+      - BUNDLE_CONFIG=/app/.bundle/config
+    command: bash
+    working_dir: /app
+    volumes:
+      - .:/app:cached
+      - bundler_data:/bundle
+    tmpfs:
+      - /tmp
+
+volumes:
+  bundler_data:

data/lib/all_prepend.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'curb_prepend'
+require 'ethon_prepend'
+require 'eventmachine_prepend'
+require 'excon_prepend'
+require 'http_prepend'
+require 'httpclient_prepend'
+require 'net_http_prepend'
+require 'patron_prepend'

data/lib/curb_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module CurlAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/ethon_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module EthonAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/eventmachine_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module EventMachineAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/excon_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module ExconAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/http_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module HTTPAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/httpclient_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module HTTPClientAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/net_http_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module NetHttpAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/patron_prepend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    module PatronAdapter
+      PREPEND = true
+    end
+  end
+end

data/lib/sniffer/adapters/curb_adapter.rb

@@ -4,16 +4,6 @@ module Sniffer
   module Adapters
     # Curl adapter
     module CurlAdapter
-      def self.included(base)
-        base.class_eval do
-          alias_method :http_without_sniffer, :http
-          alias_method :http, :http_with_sniffer
-
-          alias_method :http_post_without_sniffer, :http_post
-          alias_method :http_post, :http_post_with_sniffer
-        end
-      end
-
       def http_with_sniffer(verb)
         sniffer_request(verb)
 
@@ -40,6 +30,37 @@ module Sniffer
         @res
       end
 
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include CurlAdapter
+
+        def http(verb)
+          sniffer_request(verb)
+
+          super(verb)
+
+          bm = Benchmark.realtime do
+            @res = super(verb)
+          end
+
+          sniffer_response(bm)
+
+          @res
+        end
+
+        def http_post(*args)
+          sniffer_request(:POST, *args)
+
+          bm = Benchmark.realtime do
+            @res = super(*args)
+          end
+
+          sniffer_response(bm)
+
+          @res
+        end
+      end
+
       private
 
       def data_item
@@ -82,4 +103,17 @@ module Sniffer
   end
 end
 
-Curl::Easy.include Sniffer::Adapters::CurlAdapter if defined?(::Curl::Easy)
+if defined?(::Curl::Easy)
+  if defined?(Sniffer::Adapters::CurlAdapter::PREPEND)
+    Curl::Easy.prepend Sniffer::Adapters::CurlAdapter::Prepend
+  else
+    Curl::Easy.class_eval do
+      include Sniffer::Adapters::CurlAdapter
+      alias_method :http_without_sniffer, :http
+      alias_method :http, :http_with_sniffer
+
+      alias_method :http_post_without_sniffer, :http_post
+      alias_method :http_post, :http_post_with_sniffer
+    end
+  end
+end

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|
@@ -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.include Sniffer::Adapters::EthonAdapter::Http
-  Ethon::Easy::Operations.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,54 +6,74 @@ 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
-            Sniffer.notify_response(@data_item)
+          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
@@ -61,3 +81,19 @@ module Sniffer
 end
 
 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
 
-          Sniffer.notify_response(data_item)
-        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.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
@@ -65,8 +58,27 @@ module Sniffer
         end
       end
       # 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.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,28 +4,8 @@ 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
-        end
-      end
-
-      # 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
+        data_item = do_get_block_sniffer_before(req)
 
         retryable_response = nil
 
@@ -35,23 +15,77 @@ module Sniffer
           retryable_response = e
         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)
+        do_get_block_sniffer_after(data_item, conn, bm)
+
+        raise retryable_response unless retryable_response.nil?
+      end
+
+      private
 
-          conn.push(res)
+      # rubocop:disable Metrics/AbcSize
+      def do_get_block_sniffer_before(req)
+        return unless Sniffer.enabled?
 
-          Sniffer.notify_response(data_item)
-        end
+        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)
 
-        raise retryable_response unless retryable_response.nil?
+        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
+
+          do_get_block_sniffer_after(data_item, conn, bm)
+
+          raise retryable_response unless retryable_response.nil?
+        end
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
   end
 end
 
-HTTPClient.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)
-
-          Sniffer.notify_response(data_item)
-        end
+        request_sniffer_after(data_item, bm)
 
         @response
       end
-      # rubocop:enable Metrics/AbcSize, 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.include Sniffer::Adapters::NetHttpAdapter

data/lib/sniffer/adapters/patron_adapter.rb

@@ -4,46 +4,78 @@ module Sniffer
   module Adapters
     # HTTP adapter
     module PatronAdapter
-      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(action_name, url, headers, options = {})
-        if Sniffer.enabled?
-          data_item = Sniffer::DataItem.new
-          uri = URI(base_url)
-          data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
-                                                             method: action_name,
-                                                             query: url,
-                                                             headers: headers.dup,
-                                                             body: options[:data].to_s,
-                                                             port: uri.port)
-
-          Sniffer.store(data_item)
-        end
+        data_item = request_sniffer_before(action_name, url, headers, options)
 
         bm = Benchmark.realtime do
           @res = request_without_sniffer(action_name, url, headers, options)
         end
 
-        if Sniffer.enabled?
-          data_item.response = Sniffer::DataItem::Response.new(status: @res.status,
-                                                               headers: @res.headers,
-                                                               body: @res.body.to_s,
-                                                               timing: bm)
-
-          Sniffer.notify_response(data_item)
-        end
+        request_sniffer_after(data_item, bm)
 
         @res
       end
-      # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def request_sniffer_before(action_name, url, headers, options)
+        return unless Sniffer.enabled?
+
+        data_item = Sniffer::DataItem.new
+        uri = URI(base_url)
+        data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
+                                                           method: action_name,
+                                                           query: url,
+                                                           headers: headers.dup,
+                                                           body: options[:data].to_s,
+                                                           port: uri.port)
+
+        Sniffer.store(data_item)
+
+        data_item
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def request_sniffer_after(data_item, benchmark)
+        return unless Sniffer.enabled?
+
+        data_item.response = Sniffer::DataItem::Response.new(status: @res.status,
+                                                             headers: @res.headers,
+                                                             body: @res.body.to_s,
+                                                             timing: benchmark)
+
+        Sniffer.notify_response(data_item)
+      end
+
+      # Only used when prepending, see all_prepend.rb
+      module Prepend
+        include PatronAdapter
+
+        def request(action_name, url, headers, options = {})
+          data_item = request_sniffer_before(action_name, url, headers, options)
+
+          bm = Benchmark.realtime do
+            @res = super(action_name, url, headers, options)
+          end
+
+          request_sniffer_after(data_item, bm)
+
+          @res
+        end
+      end
     end
   end
 end
 
-::Patron::Session.include Sniffer::Adapters::PatronAdapter if defined?(::Patron::Session)
+if defined?(::Patron::Session)
+  if defined?(Sniffer::Adapters::PatronAdapter::PREPEND)
+    Patron::Session.prepend Sniffer::Adapters::PatronAdapter::Prepend
+  else
+    Patron::Session.class_eval do
+      include Sniffer::Adapters::PatronAdapter
+      alias_method :request_without_sniffer, :request
+      alias_method :request, :request_with_sniffer
+    end
+  end
+end

data/lib/sniffer/config.rb

@@ -27,10 +27,8 @@ module Sniffer
                 url_blacklist: nil
 
     def middleware
-      @middleware ||= begin
-        Middleware::Chain.new.tap do |chain|
-          chain.add(Sniffer::Middleware::Logger, logger, severity)
-        end
+      @middleware ||= Middleware::Chain.new.tap do |chain|
+        chain.add(Sniffer::Middleware::Logger, logger, severity)
       end
 
       yield @middleware if block_given?

data/lib/sniffer/data_item.rb

@@ -1,33 +1,23 @@
 # frozen_string_literal: true
 
-require 'active_attr'
+require 'dry-initializer'
 require 'json'
 require_relative 'request_policy'
 
 module Sniffer
   # Sniffer data item stores a request info
   class DataItem
-    include ActiveAttr::MassAssignment
-    attr_accessor :request, :response
+    extend Dry::Initializer
+
+    attr_writer :request, :response
+
+    option :request, optional: true
+    option :response, optional: true
 
     def to_h
       {
-        request: # frozen_string_literal: true
-# Sniffer data item stores a request info
-# Basic object for request and response objects
-# Stores http request data
-# rubocop:enable
-# Stores http response data
-
-request&.to_h,
-        response: # frozen_string_literal: true
-# Sniffer data item stores a request info
-# Basic object for request and response objects
-# Stores http request data
-# rubocop:enable
-# Stores http response data
-
-response&.to_h
+        request: request&.to_h,
+        response: response&.to_h
       }
     end
 
@@ -49,7 +39,7 @@ response&.to_h
 
     # Basic object for request and response objects
     class HttpObject
-      include ActiveAttr::MassAssignment
+      extend Dry::Initializer
 
       def log_message
         raise NotImplementedError
@@ -62,7 +52,14 @@ response&.to_h
 
     # Stores http request data
     class Request < HttpObject
-      attr_accessor :host, :port, :query, :method, :headers, :body
+      option :host, optional: true
+      option :port, optional: true
+      option :query, optional: true
+      option :method, optional: true
+      option :headers, optional: true
+      option :body, optional: true
+
+      attr_writer :host, :port, :query, :method, :headers, :body
 
       def to_h
         {
@@ -70,14 +67,7 @@ response&.to_h
           query: query,
           port: port,
           headers: headers,
-          body: # frozen_string_literal: true
-# Sniffer data item stores a request info
-# Basic object for request and response objects
-# Stores http request data
-# rubocop:enable
-# Stores http response data
-
-body&.to_s,
+          body: body&.to_s,
           method: method
         }
       end
@@ -106,20 +96,18 @@ body&.to_s,
 
     # Stores http response data
     class Response < HttpObject
-      attr_accessor :status, :headers, :body, :timing
+      attr_writer :status, :headers, :body, :timing
+
+      option :status, optional: true
+      option :headers, optional: true
+      option :body, optional: true
+      option :timing, optional: true
 
       def to_h
         {
           status: status,
           headers: headers,
-          body: # frozen_string_literal: true
-# Sniffer data item stores a request info
-# Basic object for request and response objects
-# Stores http request data
-# rubocop:enable
-# Stores http response data
-
-body&.to_s,
+          body: body&.to_s,
           timing: timing
         }
       end

data/lib/sniffer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sniffer
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/sniffer.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "anyway_config", ">= 1.0"
-  spec.add_dependency "active_attr", ">= 0.10.2"
+  spec.add_dependency "dry-initializer", "~> 3"
 
   spec.add_development_dependency "bundler", "~> 2"
   spec.add_development_dependency "rake", ">= 12.3.3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sniffer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrey Deryabin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-19 00:00:00.000000000 Z
+date: 2022-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anyway_config
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: active_attr
+  name: dry-initializer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.2
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.2
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -272,6 +272,16 @@ files:
 - assets/demo.gif
 - bin/console
 - bin/setup
+- docker-compose.yml
+- lib/all_prepend.rb
+- lib/curb_prepend.rb
+- lib/ethon_prepend.rb
+- lib/eventmachine_prepend.rb
+- lib/excon_prepend.rb
+- lib/http_prepend.rb
+- lib/httpclient_prepend.rb
+- lib/net_http_prepend.rb
+- lib/patron_prepend.rb
 - lib/sniffer.rb
 - lib/sniffer/adapters/curb_adapter.rb
 - lib/sniffer/adapters/ethon_adapter.rb
@@ -309,7 +319,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Analyze HTTP Requests