sniffer 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22daa9fd347dedf98632f9ade85208a09770bb63
-  data.tar.gz: d254ffb4370a0f83882f83aae05ed662bc1143a2
+  metadata.gz: e61d38c32a8f74c8fabdd9113a45892685be34c8
+  data.tar.gz: 5ab43be1021421ec32cde7df4d2f33692318fda9
 SHA512:
-  metadata.gz: 9b796b5f06b841997f856afbd800ded12e7a2c21fddd2c0c69472c77af1875be0581f4b1ba1fafc5a9a5b623ac9ec82d50961309e9397867a7af99bee66e52fa
-  data.tar.gz: bcd3c000a02b25d620c4698660310edd6458457fbee9de227b27628029049c279f14fa17fa6d12b1d1b1d4272f7282ca29d620eb85ef134b938ba56975f3e401
+  metadata.gz: 66ed0687f93be90af88b3a6b440350163f1f25284827e8359ed36dec78554c4fc8f55607f365090a358539f4a1e4e8db7ba4ac4f7b993c1a7d6c477c6c47fe55
+  data.tar.gz: ae3bb49ab20fd5fb84f9fe7e70c05c00e16141f43ee04aec53b627ec2e9f0269a2feb3fd54cd66a2de897390ebb96bfecd392f1e9bc4ce7945a75b7058002463

data/.rubocop.yml

@@ -13,7 +13,7 @@ AllCops:
   StyleGuideCopsOnly: false
   TargetRubyVersion: 2.4
 
-Style/AccessorMethodName:
+Naming/AccessorMethodName:
   Enabled: false
 
 Style/PercentLiteralDelimiters:
@@ -26,7 +26,7 @@ Style/Documentation:
   Exclude:
     - 'spec/**/*.rb'
 
-Style/StringLiterals: 
+Style/StringLiterals:
   Enabled: false
 
 Style/BlockDelimiters:
@@ -44,7 +44,7 @@ Metrics/MethodLength:
     - 'spec/**/*.rb'
 
 Metrics/LineLength:
-  Max: 100
+  Max: 120
   Exclude:
     - 'spec/**/*.rb'
 
@@ -56,4 +56,7 @@ Rails/Date:
   Enabled: false
 
 Rails/TimeZone:
-  Enabled: false
+  Enabled: false
+
+Security/YAMLLoad:
+  Enabled: false

data/.travis.yml

@@ -1,5 +1,14 @@
 sudo: false
 language: ruby
+env:
+  global:
+    - CC_TEST_REPORTER_ID=bc054bdf814431bf40559f1cd62a86956fa5666296895400e1282a47ec6d1c69
 rvm:
   - 2.4.2
 before_install: gem install bundler -v 1.15.4
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -4,5 +4,3 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in sniffer.gemspec
 gemspec
-
-gem 'rubocop'

data/README.md

@@ -1,8 +1,28 @@
-# Sniffer
+# Sniffer [![Build Status](https://travis-ci.org/aderyabin/sniffer.svg?branch=master)](https://travis-ci.org/aderyabin/sniffer) [![Gem Version](https://badge.fury.io/rb/sniffer.svg)](https://rubygems.org/gems/sniffer) [![Maintainability](https://api.codeclimate.com/v1/badges/640cb17b3d748a49653f/maintainability)](https://codeclimate.com/github/aderyabin/sniffer/maintainability)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sniffer`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-TODO: Delete this and the text above, and describe your gem
+Sniffer aims to help:
+
+  * Log outgoing HTTP requests. Sniffer logs as JSON format for export to ELK, Logentries and etc.
+  * Debug requests. Sniffer allows to save all requests/responses in storage for future debugging
+
+Sniffer supports most common HTTP accessing libraries:
+
+* [Net::HTTP](http://ruby-doc.org/stdlib-2.4.2/libdoc/net/http/rdoc/Net/HTTP.html)
+* [HTTP](https://github.com/httprb/http)
+* [HTTPClient](https://github.com/nahi/httpclient)
+* [Patron](https://github.com/toland/patron)
+* [Curb](https://github.com/taf2/curb/)
+* [Ethon](https://github.com/typhoeus/ethon)
+* [Typhoeus](https://github.com/typhoeus/typhoeus)
+
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Demo
+
+![demo](https://github.com/aderyabin/sniffer/blob/master/assets/demo.gif?raw=true)
 
 ## Installation
 
@@ -20,9 +40,94 @@ Or install it yourself as:
 
     $ gem install sniffer
 
+## Configuration
+
+Sniffer default options:
+
+```ruby
+Sniffer.config do
+  logger: Logger.new($stdout),
+  severity: Logger::Severity::DEBUG,
+  # HTTP options to log
+  log: {
+    request_url: true,
+    request_headers: true,
+    request_body: true,
+    request_method: true,
+    response_status: true,
+    response_headers: true,
+    response_body: true,
+    timing: true
+  },
+  store: true, # save requests/responses to Sniffer.data
+  enabled: false  # Sniffer disabled by default
+end
+```
+
 ## Usage
 
-TODO: Write usage instructions here
+Here's some simple examples to get you started:
+
+```ruby
+require 'http'
+require 'sniffer'
+
+Sniffer.enable!
+
+HTTP.get('http://example.com/?lang=ruby&author=matz')
+Sniffer.data[0].to_h
+# => {:request=>
+#   {:host=>"example.com",
+#    :query=>"/?lang=ruby&author=matz",
+#    :port=>80,
+#    :headers=>{"Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3", "Connection"=>"close"},
+#    :body=>"",
+#    :method=>:get},
+#  :response=>
+#   {:status=>200,
+#    :headers=>
+#     {"Content-Encoding"=>"gzip",
+#      "Cache-Control"=>"max-age=604800",
+#      "Content-Type"=>"text/html",
+#      "Date"=>"Thu, 26 Oct 2017 13:47:00 GMT",
+#      "Etag"=>"\"359670651+gzip\"",
+#      "Expires"=>"Thu, 02 Nov 2017 13:47:00 GMT",
+#      "Last-Modified"=>"Fri, 09 Aug 2013 23:54:35 GMT",
+#      "Server"=>"ECS (lga/1372)",
+#      "Vary"=>"Accept-Encoding",
+#      "X-Cache"=>"HIT",
+#      "Content-Length"=>"606",
+#      "Connection"=>"close"},
+#    :body=> "OK",
+#    :timing=>0.23753299983218312}}
+```
+
+You can clear saved data
+
+```
+Sniffer.clear!
+```
+
+You can reset config to default
+
+```
+Sniffer.reset!
+```
+
+You can enable and disable Sniffer
+
+```
+Sniffer.enable!
+Sniffer.disable!
+```
+
+By default output log looks like that:
+
+```
+D, [2017-10-26T16:47:14.007152 #59511] DEBUG -- : {"port":80,"host":"example.com","query":"/?lang=ruby&author=matz","rq_connection":"close","method":"get","request_body":"","status":200,"rs_accept_ranges":"bytes","rs_cache_control":"max-age=604800","rs_content_type":"text/html","rs_date":"Thu, 26 Oct 2017 13:47:13 GMT","rs_etag":"\"359670651+gzip\"","rs_expires":"Thu, 02 Nov 2017 13:47:13 GMT","rs_last_modified":"Fri, 09 Aug 2013 23:54:35 GMT","rs_server":"ECS (lga/1385)","rs_vary":"Accept-Encoding","rs_x_cache":"HIT","rs_content_length":"1270","rs_connection":"close","timing":0.513012999901548,"response_body":"OK"}
+```
+where `rq_xxx` is request header and `rs_xxx` - response header
+
 
 ## Development
 

data/lib/sniffer/adapters/curb_adapter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+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
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def http_with_sniffer(verb)
+        sniffer_request(verb)
+
+        http_without_sniffer(verb)
+
+        bm = Benchmark.realtime do
+          @res = http_without_sniffer(verb)
+        end
+
+        sniffer_response(bm)
+
+        @res
+      end
+
+      def http_post_with_sniffer(*args)
+        sniffer_request(:POST, *args)
+
+        bm = Benchmark.realtime do
+          @res = http_post_without_sniffer(*args)
+        end
+
+        sniffer_response(bm)
+
+        @res
+      end
+
+      private
+
+      def data_item
+        @data_item ||= Sniffer::DataItem.new if Sniffer.enabled?
+      end
+
+      def sniffer_request(verb, *args)
+        return unless data_item
+
+        uri = URI(url)
+        query = uri.path
+        query += "?#{uri.query}" if uri.query
+
+        data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
+                                                           method: verb,
+                                                           query: query,
+                                                           headers: headers.collect.to_h,
+                                                           body: args.join("&"),
+                                                           port: uri.port)
+
+        Sniffer.store(data_item)
+      end
+
+      def sniffer_response(timing)
+        return unless data_item
+
+        _, *http_headers = header_str.split(/[\r\n]+/).map(&:strip)
+        http_headers = Hash[http_headers.flat_map { |s| s.scan(/^(\S+): (.+)/) }]
+
+        data_item.response = Sniffer::DataItem::Response.new(status: status.to_i,
+                                                             headers: http_headers,
+                                                             body: body_str,
+                                                             timing: timing)
+
+        data_item.log
+      end
+    end
+  end
+end
+
+Curl::Easy.send(:include, Sniffer::Adapters::CurlAdapter) if defined?(::Curl::Easy)

data/lib/sniffer/adapters/ethon_adapter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Sniffer
+  module Adapters
+    # Ethon adapter
+    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
+        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)
+
+            @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
+
+          http_request_without_sniffer(url, action_name, options)
+        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
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def perform_with_sniffer
+          bm = Benchmark.realtime do
+            @return_code = Ethon::Curl.easy_perform(handle)
+          end
+
+          if Sniffer.enabled?
+            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
+            hash_headers = @response_headers
+                           .split(/\r?\n/)[1..-1]
+                           .each_with_object({}) do |item, res|
+              k, v = item.split(": ")
+              res[k] = v
+            end
+
+            @data_item.response = Sniffer::DataItem::Response.new(status: status,
+                                                                  headers: hash_headers,
+                                                                  body: @response_body,
+                                                                  timing: bm)
+            @data_item.log
+
+          end
+
+          if Ethon.logger.debug?
+            Ethon.logger.debug { "ETHON: performed #{log_inspect}" }
+          end
+          complete
+
+          @return_code
+        end
+        # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+      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)
+end

data/lib/sniffer/adapters/http_adapter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+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
+      def request_with_sniffer(verb, uri, opts = {})
+        opts    = @default_options.merge(opts)
+        uri     = make_request_uri(uri, opts)
+        headers = make_request_headers(opts)
+        body    = make_request_body(opts, headers)
+        proxy   = opts.proxy
+
+        req = HTTP::Request.new(
+          verb: verb,
+          uri: uri,
+          headers: headers,
+          proxy: proxy,
+          body: body,
+          auto_deflate: opts.feature(:auto_deflate)
+        )
+
+        if Sniffer.enabled?
+          data_item = Sniffer::DataItem.new
+          query = uri.path
+          query += "?#{uri.query}" if uri.query
+
+          data_item.request = Sniffer::DataItem::Request.new(host: uri.host,
+                                                             method: verb,
+                                                             query: query,
+                                                             headers: headers.collect.to_h,
+                                                             body: body.to_s,
+                                                             port: uri.port)
+
+          Sniffer.store(data_item)
+        end
+
+        bm = Benchmark.realtime do
+          @res = perform(req, opts)
+        end
+
+        if Sniffer.enabled?
+          data_item.response = Sniffer::DataItem::Response.new(status: @res.code,
+                                                               headers: @res.headers.collect.to_h,
+                                                               body: @res.body.to_s,
+                                                               timing: bm)
+
+          data_item.log
+        end
+
+        return @res unless opts.follow
+
+        HTTP::Redirector.new(opts.follow).perform(req, @res) do |request|
+          perform(request, opts)
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    end
+  end
+end
+
+HTTP::Client.send(:include, Sniffer::Adapters::HTTPAdapter) if defined?(::HTTP::Client)

data/lib/sniffer/adapters/httpclient_adapter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+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
+
+        retryable_response = nil
+
+        bm = Benchmark.realtime do
+          begin
+            do_get_block_without_sniffer(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)
+
+          data_item.log
+        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)

data/lib/sniffer/adapters/net_http_adapter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'benchmark'
+
+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
+
+        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
+
+        @response
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+    end
+  end
+end
+Net::HTTP.send(:include, Sniffer::Adapters::NetHttpAdapter)

data/lib/sniffer/adapters/patron_adapter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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
+
+        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)
+
+          data_item.log
+        end
+
+        @res
+      end
+      # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+    end
+  end
+end
+
+::Patron::Session.send(:include, Sniffer::Adapters::PatronAdapter) if defined?(::Patron::Session)

data/lib/sniffer/config.rb

@@ -8,13 +8,18 @@ module Sniffer
     config_name :sniffer
 
     attr_config logger: Logger.new($stdout),
-                request_headers: false,
-                requst_body: true,
-                response_status: true,
-                response_headers: false,
-                response_body: true,
-                whitelist_url:  /.*/,
-                blacklist_url: nil,
-                store: true
+                severity: Logger::Severity::DEBUG,
+                log: {
+                  request_url: true,
+                  request_headers: true,
+                  request_body: true,
+                  request_method: true,
+                  response_status: true,
+                  response_headers: true,
+                  response_body: true,
+                  timing: true
+                },
+                store: true,
+                enabled: false
   end
 end

data/lib/sniffer/data_item.rb

@@ -1,9 +1,113 @@
 # frozen_string_literal: true
 
+require 'active_attr'
+require 'json'
+
 module Sniffer
   # Sniffer data item stores a request info
   class DataItem
-    attr_accessor :request_headers, :requst_body,
-                  :response_status, :response_headers, :response_body
+    include ActiveAttr::MassAssignment
+    attr_accessor :request, :response
+
+    def to_h
+      {
+        request: request&.to_h,
+        response: response&.to_h
+      }
+    end
+
+    def log
+      Sniffer.logger.log(Sniffer.config.severity, to_json)
+    end
+
+    def to_log
+      return {} unless Sniffer.config.logger
+      request.to_log.merge(response.to_log)
+    end
+
+    def to_json
+      to_log.to_json
+    end
+
+    # Basic object for request and response objects
+    class HttpObject
+      include ActiveAttr::MassAssignment
+
+      def log_message
+        raise NotImplementedError
+      end
+
+      def log_settings
+        Sniffer.config.log || {}
+      end
+    end
+
+    # Stores http request data
+    class Request < HttpObject
+      attr_accessor :host, :port, :query, :method, :headers, :body
+
+      def to_h
+        {
+          host: host,
+          query: query,
+          port: port,
+          headers: headers,
+          body: body,
+          method: method
+        }
+      end
+
+      # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def to_log
+        {}.tap do |hash|
+          if log_settings["request_url"]
+            hash[:port] = port
+            hash[:host] = host
+            hash[:query] = query
+          end
+
+          if log_settings["request_headers"]
+            headers.each do |(k, v)|
+              hash[:"rq_#{k.to_s.tr("-", '_').downcase}"] = v
+            end
+          end
+
+          hash[:method] = method if log_settings["request_method"]
+          hash[:request_body] = body if log_settings["request_body"]
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+    # Stores http response data
+    class Response < HttpObject
+      attr_accessor :status, :headers, :body, :timing
+
+      def to_h
+        {
+          status: status,
+          headers: headers,
+          body: body,
+          timing: timing
+        }
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def to_log
+        {}.tap do |hash|
+          hash[:status] = status if log_settings["response_status"]
+
+          if log_settings["response_headers"]
+            headers.each do |(k, v)|
+              hash[:"rs_#{k.to_s.tr("-", '_').downcase}"] = v
+            end
+          end
+
+          hash[:timing] = timing if log_settings["timing"]
+          hash[:response_body] = body if log_settings["response_body"]
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
   end
 end

data/lib/sniffer/version.rb

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

data/lib/sniffer.rb

@@ -2,15 +2,33 @@
 
 require "logger"
 
-require "sniffer/version"
-require "sniffer/config"
-require "sniffer/data_item"
+require_relative "sniffer/version"
+require_relative "sniffer/config"
+require_relative "sniffer/data_item"
 
 # Sniffer allows to log http requests
 module Sniffer
+  @data = Set.new
+
   class << self
+    attr_reader :data
+
     def config
       @config ||= Config.new
+      yield @config if block_given?
+      @config
+    end
+
+    def enable!
+      config.enabled = true
+    end
+
+    def disable!
+      config.enabled = false
+    end
+
+    def enabled?
+      config.enabled
     end
 
     def configure
@@ -18,16 +36,27 @@ module Sniffer
     end
 
     def clear!
-      @data = []
+      data.clear
     end
 
-    def data
-      @data ||= []
+    def reset!
+      @config = Config.new
+      clear!
     end
 
     def store(data_item)
-      data
-      @data << data_item
+      @data.add(data_item) if config.store
+    end
+
+    def logger
+      config.logger
     end
   end
 end
+
+require_relative "sniffer/adapters/net_http_adapter"
+require_relative "sniffer/adapters/httpclient_adapter"
+require_relative "sniffer/adapters/http_adapter"
+require_relative "sniffer/adapters/patron_adapter"
+require_relative "sniffer/adapters/curb_adapter"
+require_relative "sniffer/adapters/ethon_adapter"

data/sniffer.gemspec

@@ -17,14 +17,22 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "anyway_config", "~> 1.0"
+  spec.add_dependency "active_attr", ">= 0.10.2"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop", "~> 0.50"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "sinatra", "~> 2.0"
+  spec.add_development_dependency "puma", ">= 3.10.0"
+  spec.add_development_dependency "httpclient", ">= 2.8.3"
+  spec.add_development_dependency "http", ">= 3.0.0"
+  spec.add_development_dependency "patron", ">= 0.10.0"
+  spec.add_development_dependency "curb", ">= 0.9.4"
+  spec.add_development_dependency "ethon", ">= 0.11.0"
+  spec.add_development_dependency "typhoeus", ">= 0.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sniffer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrey Deryabin
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2017-10-18 00:00:00.000000000 Z
+date: 2017-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anyway_config
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: active_attr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,132 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.50'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+- !ruby/object:Gem::Dependency
+  name: ethon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
 description: Analyze HTTP Requests
 email:
 - aderyabin@evilmartians.com
@@ -97,9 +237,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- assets/demo.gif
 - bin/console
 - bin/setup
 - lib/sniffer.rb
+- lib/sniffer/adapters/curb_adapter.rb
+- lib/sniffer/adapters/ethon_adapter.rb
+- lib/sniffer/adapters/http_adapter.rb
+- lib/sniffer/adapters/httpclient_adapter.rb
+- lib/sniffer/adapters/net_http_adapter.rb
+- lib/sniffer/adapters/patron_adapter.rb
 - lib/sniffer/config.rb
 - lib/sniffer/data_item.rb
 - lib/sniffer/version.rb