nxt_http_client 0.3.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89185b814fea114ee2d74dd8e05afd3cf4773cdef8fb908cdf5e954775b4e885
-  data.tar.gz: 2d940e5c42051c09ca776d57901535a7a3d18bf8facb116b742f04a46b91e2ae
+  metadata.gz: 851b1b29746c3a64735f9cf29c98378fbe49ada821dbcbc8c69ae28312596d0b
+  data.tar.gz: 3cfcbc1b1a0db863ede586976f83afdbb96b1ca06596bd0d7c9610e04171ca3b
 SHA512:
-  metadata.gz: 2dea66682adbebf9800a68cbb3f9962d4b17623bc022163b7765fd1b4a889a78fc610dfc12719d137605e9e3b7c98b254e6f8f5ec80eca947318795b66dd48a2
-  data.tar.gz: 8f04ddb779773c29db1a6f1af0cc73065b4da4e19e7e1a0b43eb5e1c6ec09d94acefb47ca0bdff0880377e2366354a631bc6751adad2ab73c31161108d2fa540
+  metadata.gz: 5c2297ee0db6aa262e4becba99f02f26e274b03a1858cc5bb3359a8f9a2fabfd0098cfdf0e5b018e13ecdd3afafa41a25251ee6131b86a41ff5d9346d80b8ea9
+  data.tar.gz: bb3e3ab2e9a0e884f1b4968e88a7dcb5c56b6a4e142c4454b3a6ac83c6504a5a99826ad5e412553d77ed871216e09e60e3a1067ee8e6a1ad79d040bc843e1350

data/.circleci/config.yml

@@ -9,7 +9,7 @@ jobs:
       - image: circleci/ruby:2.7.0-node
       - image: circleci/redis:5.0.4
     environment:
-      BUNDLER_VERSION: 2.1.4
+      BUNDLER_VERSION: 2.2.4
 
     working_directory: ~/repo
 

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# v1.0.0 2021-01-10
+
+### Breaking changes
+- renamed register_response_handler to _response_handler
+- replace before_fire and after_fire hooks with proper callbacks before, after and around fire
+
+### Updated
+- error now includes more information about request and headers
+
 # v0.3.4 2021-01-05
 
 ### Updated

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nxt_http_client (0.3.4)
+    nxt_http_client (1.0.0)
       activesupport (~> 6.0)
       nxt_registry
       typhoeus
@@ -9,7 +9,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.0)
+    activesupport (6.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -24,12 +24,12 @@ GEM
     diff-lcs (1.4.4)
     ethon (0.12.0)
       ffi (>= 1.3.0)
-    ffi (1.13.1)
+    ffi (1.14.2)
     hashdiff (1.0.1)
     i18n (1.8.7)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    minitest (5.14.2)
+    minitest (5.14.3)
     nxt_registry (0.3.6)
       activesupport
     nxt_vcr_harness (0.1.4)
@@ -57,6 +57,7 @@ GEM
     rspec-support (3.10.1)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
+    timecop (0.9.2)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
     tzinfo (2.0.4)
@@ -69,10 +70,10 @@ GEM
     zeitwerk (2.4.2)
 
 PLATFORMS
-  ruby
+  x86_64-darwin-19
 
 DEPENDENCIES
-  bundler (~> 1.17)
+  bundler (~> 2.2)
   nxt_http_client!
   nxt_vcr_harness
   pry
@@ -80,8 +81,9 @@ DEPENDENCIES
   redis
   rspec (~> 3.0)
   rspec_junit_formatter
+  timecop
   vcr
   webmock
 
 BUNDLED WITH
-   1.17.3
+   2.2.4

data/README.md

@@ -1,9 +1,11 @@
 # NxtHttpClient
 
-Build http clients with ease. NxtHttpClient is a simple DSL on top of the awesome typhoeus gem.
-The idea is that you can configure your http clients on the class level and then adjust or further configure
-request options on the instance level. All http interactions are handled by typhoeus. If you need to 
-access the original `Typhoeus::Request` in your instance, you can do that. 
+Build http clients with ease. NxtHttpClient is a simple DSL on top of the [typhoeus](https://github.com/typhoeus/typhoeus)
+gem. NxtHttpClient mostly provides you a simple configuration functionality to setup http connections on the class level. 
+Furthermore it's mostly a callback framework that allows you to seamlessly handle your responses. Since it's is just a simple
+layer on top of [typhoeus](https://github.com/typhoeus/typhoeus) it also allows to access and configure the original 
+`Typhoeus::Request` before making a request.
+
 
 ## Installation
 
@@ -23,16 +25,33 @@ Or install it yourself as:
 
 ## Usage
 
+A typical client could look something like this:
+
 ```ruby
-class MyClient < NxtHttpClient
-  
-  # In your subclasses you probably want to deep_merge options in order to not overwrite options inherited 
-  # from the parent class. Of course this will not influence the parent class and you can also reset them 
-  # to a new hash here.
+class UserFetcher < Client
+  def initialize(id)
+    @url = ".../users/#{id}"
+  end
+
+  def call
+    get(url) do |response_handler|
+      response_handler.on(:success) do |response|
+        JSON(response.body)
+      end
+    end
+  end
   
-  # Also be aware that the result of x_request_id_proc will be hashed into the cache key and thus might cause 
-  # your request not to be cached if not used properly
+  private
 
+  attr_reader :url
+end
+```
+
+In order to setup a shared configuration you would therefore setup a client base class. The configuration and any 
+response handler or callbacks you setup in your base class are then inherited to your concrete client implementations.
+
+```ruby
+class Client < NxtHttpClient
   configure do |config|
     config.base_url = 'www.example.com'
     config.request_options.deep_merge!(
@@ -43,54 +62,14 @@ class MyClient < NxtHttpClient
     config.x_request_id_proc = -> { ('a'..'z').to_a.shuffle.take(10).join } 
   end
   
-  register_response_handler do |handler|
-    handler.on(:error) do |response|
-      Raven.extra_context(error_details: error.to_h) # call error.to_h to inspect request and response
-      raise StandardError, "I can't handle this: #{response.code}"
-    end
-  end
-  
-  # Will be called before fire so you can reconfigure your handler before fire
-  before_fire do |client, request, handler|
-    handler.on!(200) do |response|
-      # ...
-    end
+  log do |info|
+    Rails.logger.info(info)
   end
   
-  # Will be called after fire. You probably want to return the result here in order for your code 
-  # to be able to access the result from the response handler from before. 
-  # In case one of the response handler callbacks raises an error
-  # after fire will has access to it and you may want to reraise the error in that case.
-
-  after_fire do |client, request, response, result, error|
-    if error
-      raise error
-    else  
-      result
-    end
-  end
-  
-  def fetch_details
-    fire('details', method: :get) do |handler|
-      handler.on(:success) do |response|
-        response.body
-      end
-      
-      handler.on(404) do |response|
-        raise StandardError, '404'
-      end
-      
-      # You can also fuzzy match response codes using the wildcard *
-      handler.on('5**') do |response|
-        raise StandardError, 'This is bad'
-      end
-    end
-  end
-  
-  # there are also convenience methods for all http verbs (get post patch put delete head)
-  def update
-    post(params: { my: 'payload' }) do |handler|
-    # ...
+  response_handler do |handler|
+    handler.on(:error) do |response|
+      Raven.extra_context(error_details: error.to_h)
+      raise StandardError, "I can't handle this: #{response.code}"
     end
   end
 end
@@ -98,11 +77,10 @@ end
 
 ### HTTP Methods
 
-Instead of fire you can simply use the http verbs as methods
+In order to build a request and execute it NxtHttpClient implements all http standard methods. 
 
 ```ruby
-class MyClient < NxtHttpClient
-  
+class Client < NxtHttpClient
   def initialize(url)
     @url = url
   end
@@ -131,21 +109,22 @@ class MyClient < NxtHttpClient
 end
 ```
 
-
 ### configure
 
-Register default request options on the class level. Available options are `request_options` that are passed directly to 
-the underlying Typhoeus Request. Then there is `base_url` and `x_request_id_proc`. 
+Register your default request options on the class level. Available options are `request_options` that are passed 
+directly to the underlying Typhoeus Request. Then there is `base_url` and `x_request_id_proc`.
 
-### register_response_handler
+### response_handler
 
-Register a default response handler for your client class. 
-You can reconfigure or overwrite it this completely later on the instance level. 
+Register a default response handler for your client class. You can reconfigure or overwrite this in subclasses and 
+on the instance level. 
 
 ### fire
 
-Use `fire('uri', **request_options)` to actually fire your requests and define what to do with the response by using
-the NxtHttpClient DSL. Registered callbacks have a hierarchy by which they are executed. Specific callbacks will come first 
+All http methods internally are delegate to `fire('uri', **request_options)`. Since `fire` is a public method you can 
+also use it to fire your requests and use the response handler to register callbacks for specific responses.
+
+Registered callbacks have a hierarchy by which they are executed. Specific callbacks will come first 
 and more common callbacks will come later in case none of the specific callbacks matched. It this is not what you want you
 can simply put the logic you need into one common callback that is called in any case. You can also use strings with wildcards
 to match a group of response by status code. `handler.on('4**') { ... }` basically would match all client errors.   
@@ -184,15 +163,83 @@ end
 
 ### Callbacks around fire
 
-You can also hook into the before_fire and after_fire callbacks to do something before and after the actual request is executed.
-These callbacks are inherited down the class hierarchy but are not being chained. Meaning when you overwrite those in your subclass,
-the callbacks defined by your parent class will not be called anymore.
+Next to implementing callbacks for handling responses there are also callbacks around making requests. Note tht you can 
+have as many callbacks as you want. In case you need to reset them because you do not want to inherit them from your 
+parent class (might be a smell when you need to...) you can reset callbacks via `clear_fire_callbacks` on the class level.
+
+```ruby
+
+clear_fire_callbacks # Call this to clear callbacks setup in the parent class
+
+before_fire do |client, request, response_handler|
+  # here you have access to the client, request and response_handler  
+end
+
+around_fire do |client, request, response_handler, fire|
+  # here you have access to the client, request and response_handler
+  fire.call # You have to call fire here and return the result to the next callback in the chain
+end
+
+after_fire do |client, request, response, result, error|
+  result # The result of the last callback in the chain is the result of fire!
+end
+```
+
 
 ### NxtHttpClient::Error
 
 NxtHttpClient also provides an error base class that you might want to use as the base for your client errors.
 It comes with a nice set of useful methods. You can ask the error for the request and response options since it
-requires the response for initialization. 
+requires the response for initialization. Furthermore it has a handy `to_h` method that provides you all info about 
+the request and response.
+
+### Logging
+
+NxtHttpClient also comes with a log method on the class level that you can pass a proc if you want to log your request.
+Your proc needs to accept an argument in order to get access to information about the request and response made.  
+
+```ruby
+log do |info|
+  Rails.logger.info(info)
+end
+
+# info is a hash that is implemented as follows:
+
+{
+  client: client,
+  started_at: started_at,
+  request: request,
+  finished_at: now,
+  elapsed_time_in_milliseconds: finished_at - started_at,
+  response: request.response,
+  http_status: request.response&.code
+}
+```
+
+### Caching
+
+Typhoeus ships with caching built in. Checkout the [typhoeus](https://github.com/typhoeus/typhoeus) docu to figure out 
+how to set it up. NxtHttpClient builds some functionality on top of this and offer to cache requests within the current 
+thread or globally. You can simply make use of it by providing one of the caching options `:thread` or`:global` as config 
+request option or the actual request options when building the request. 
+
+```ruby
+class Client < NxtHttpClient::Client
+  configure do |config|
+    config.request_options = { cache: :thread }
+  end
+  
+  response_handler do |handler|
+    handler.on(200) do |response|
+      # ...
+    end
+  end
+  
+  def call
+    get('.../url.com', cache: :thread) # configure caching per request level
+  end
+end
+```
 
 ## Development
 
@@ -202,7 +249,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/nxt_http_client.
+Bug reports and pull requests are welcome on GitHub at https://github.com/nxt-insurance/nxt_http_client.
 
 ## License
 

data/lib/nxt_http_client.rb

@@ -3,8 +3,12 @@ require 'typhoeus'
 require 'nxt_registry'
 
 require 'nxt_http_client/version'
+require 'nxt_http_client/headers'
 require 'nxt_http_client/response_handler'
-require 'nxt_http_client/default_config'
+require 'nxt_http_client/config'
+require 'nxt_http_client/undefined'
+require 'nxt_http_client/logger'
+require 'nxt_http_client/fire_callbacks'
 require 'nxt_http_client/client_dsl'
 require 'nxt_http_client/client'
 require 'nxt_http_client/error'

data/lib/nxt_http_client/client.rb

@@ -11,42 +11,30 @@ module NxtHttpClient
       Typhoeus::Request.new(url, **opts.symbolize_keys)
     end
 
-    delegate :before_fire_callback, :after_fire_callback, to: :class
-
     def fire(url = '', **opts, &block)
-      response_handler = opts.fetch(:response_handler) { dup_handler_from_class || NxtHttpClient::ResponseHandler.new }
-      response_handler.configure(&block) if block_given?
+      response_handler = build_response_handler(opts[:response_handler], &block)
       request = build_request(url, **opts.except(:response_handler))
-      before_fire_callback && instance_exec(self, request, response_handler, &before_fire_callback)
-
-      if response_handler.callbacks.resolve('headers')
-        request.on_headers do |response|
-          response_handler.eval_callback(self, 'headers', response)
-        end
-      end
 
-      if response_handler.callbacks.resolve('body')
-        request.on_body do |response|
-          response_handler.eval_callback(self, 'body', response)
-        end
-      end
-
-      result = nil
       current_error = nil
+      result = nil
+
+      setup_on_headers_callback(request, response_handler)
+      setup_on_body_callback(request, response_handler)
 
       request.on_complete do |response|
         result = callback_or_response(response, response_handler)
+      end
+
+      run_before_fire_callbacks(request, response_handler)
+
+      run_around_fire_callbacks(request, response_handler) do
+        request.run
       rescue StandardError => error
         current_error = error
-      ensure
-        if after_fire_callback
-          result = instance_exec(self, request, response, result, current_error, &after_fire_callback)
-        else
-          result || (raise current_error)
-        end
       end
 
-      request.run
+      result = run_after_fire_callbacks(request, request.response, result, current_error)
+      result || (raise current_error if current_error)
 
       result
     end
@@ -60,7 +48,7 @@ module NxtHttpClient
     private
 
     def build_url(opts, url)
-      base_url = opts.delete(:base_url) || default_config.base_url
+      base_url = opts.delete(:base_url) || config.base_url
       url = [base_url, url].reject(&:blank?).join('/')
 
       url_without_duplicated_hashes(url)
@@ -68,11 +56,11 @@ module NxtHttpClient
     end
 
     def build_headers(opts)
-      opts = default_config.request_options.with_indifferent_access.deep_merge(opts.with_indifferent_access)
+      opts = config.request_options.with_indifferent_access.deep_merge(opts.with_indifferent_access)
       opts[:headers] ||= {}
 
-      if default_config.x_request_id_proc
-        opts[:headers]['X-Request-ID'] ||= default_config.x_request_id_proc.call
+      if config.x_request_id_proc
+        opts[:headers][XRequestId] ||= config.x_request_id_proc.call
       end
 
       build_cache_header(opts)
@@ -83,8 +71,8 @@ module NxtHttpClient
       self.class.response_handler.dup
     end
 
-    def default_config
-      self.class.default_config
+    def config
+      self.class.config
     end
 
     def build_cache_header(opts)
@@ -92,13 +80,13 @@ module NxtHttpClient
         strategy = opts.delete(:cache)
 
         case strategy.to_s
-        when 'thread'
-          cache_key = Thread.current[:nxt_http_client_cache_key] ||= "#{SecureRandom.base58}::#{DateTime.current}"
-          opts[:headers].reverse_merge!(cache_key: cache_key)
-        when 'global'
-          opts[:headers].delete(:cache_key)
-        else
-          raise ArgumentError, "Cache strategy unknown: #{strategy}. Options are #{CACHE_STRATEGIES}"
+          when 'thread'
+            cache_key = Thread.current[:nxt_http_client_cache_key] ||= "#{SecureRandom.base58}::#{DateTime.current}"
+            opts[:headers].reverse_merge!(cache_key: cache_key)
+          when 'global'
+            opts[:headers].delete(:cache_key)
+          else
+            raise ArgumentError, "Cache strategy unknown: #{strategy}. Options are #{CACHE_STRATEGIES}"
         end
       end
     end
@@ -116,5 +104,56 @@ module NxtHttpClient
       callback = response_handler.callback_for_response(response)
       callback && instance_exec(response, &callback) || response
     end
+
+    def build_response_handler(handler, &block)
+      response_handler = handler || dup_handler_from_class || NxtHttpClient::ResponseHandler.new
+      response_handler.configure(&block) if block_given?
+      response_handler
+    end
+
+    def run_before_fire_callbacks(request, response_handler)
+      callbacks.run_before(target: self, request: request, response_handler: response_handler)
+    end
+
+    def run_around_fire_callbacks(request, response_handler, &fire)
+      callbacks.run_around(
+        target: self,
+        request: request,
+        response_handler: response_handler,
+        fire: fire
+      )
+    end
+
+    def run_after_fire_callbacks(request, response, result, current_error)
+      return result unless callbacks.any_after_callbacks?
+
+      callbacks.run_after(
+        target: self,
+        request: request,
+        response: response,
+        result: result,
+        error: current_error
+      )
+    end
+
+    def setup_on_headers_callback(request, response_handler)
+      return unless response_handler.callbacks.resolve('headers')
+
+      request.on_headers do |response|
+        response_handler.eval_callback(self, 'headers', response)
+      end
+    end
+
+    def setup_on_body_callback(request, response_handler)
+      return unless response_handler.callbacks.resolve('body')
+
+      request.on_body do |response|
+        response_handler.eval_callback(self, 'body', response)
+      end
+    end
+
+    def callbacks
+      @callbacks ||= self.class.callbacks
+    end
   end
 end

data/lib/nxt_http_client/client_dsl.rb

@@ -1,57 +1,79 @@
 module NxtHttpClient
   module ClientDsl
     def configure(opts = {}, &block)
-      opts.each { |k, v| default_config.send(k, v) }
-      default_config.tap { |d| block.call(d) }
-      default_config
+      opts.each { |k, v| config.send(k, v) }
+      config.tap { |d| block.call(d) }
+      config
     end
 
-    def before_fire(&block)
-      @before_fire_callback = block
+    def log(&block)
+      @logger ||= block || dup_option_from_ancestor(:@logger)
+
+      return unless @logger.present?
+      logger = @logger
+
+      around_fire do |client, request, response_handler, fire|
+        Logger.new(logger).call(client, request, response_handler, fire)
+      end
     end
 
-    def before_fire_callback
-      @before_fire_callback ||= dup_instance_variable_from_ancestor_chain(:@before_fire_callback)
+    def clear_fire_callbacks(*kinds)
+      callbacks.clear(*kinds)
+    end
+
+    def before_fire(&block)
+      callbacks.register(:before, block)
     end
 
     def after_fire(&block)
-      @after_fire_callback = block
+      callbacks.register(:after, block)
+    end
+
+    def around_fire(&block)
+      callbacks.register(:around, block)
     end
 
-    def after_fire_callback
-      @after_fire_callback ||= dup_instance_variable_from_ancestor_chain(:@after_fire_callback)
+    def config
+      @config ||= dup_option_from_ancestor(:@config) { Config.new }
     end
 
-    def default_config
-      @default_config ||= dup_instance_variable_from_ancestor_chain(:@default_config) { DefaultConfig.new }
+    def callbacks
+      @callbacks ||= dup_option_from_ancestor(:@callbacks) { FireCallbacks.new }
     end
 
-    def register_response_handler(handler = nil, &block)
-      @response_handler = handler
-      @response_handler ||= dup_instance_variable_from_ancestor_chain(:@response_handler) { NxtHttpClient::ResponseHandler.new }
+    def response_handler(handler = Undefined.new, &block)
+      if undefined?(handler)
+        @response_handler ||= dup_option_from_ancestor(:@response_handler) { NxtHttpClient::ResponseHandler.new }
+      else
+        @response_handler = handler
+      end
+
       @response_handler.configure(&block) if block_given?
       @response_handler
     end
 
-    def response_handler
-      @response_handler ||= dup_instance_variable_from_ancestor_chain(:@response_handler) { NxtHttpClient::ResponseHandler.new }
-    end
+    alias_method :response_handler, :response_handler
+
+    private
 
     def client_ancestors
       ancestors.select { |ancestor| ancestor <= NxtHttpClient::Client }
     end
 
-    def instance_variable_from_ancestor_chain(instance_variable_name)
-      client = client_ancestors.find { |c| c.instance_variable_get(instance_variable_name) }
-
-      client.instance_variable_get(instance_variable_name)
+    def option_from_ancestors(name)
+      client = client_ancestors.find { |c| c.instance_variable_get(name) }
+      client && client.instance_variable_get(name)
     end
 
-    def dup_instance_variable_from_ancestor_chain(instance_variable_name)
-      result = instance_variable_from_ancestor_chain(instance_variable_name).dup
+    def dup_option_from_ancestor(name)
+      result = option_from_ancestors(name).dup
       return result unless block_given?
 
       result || yield
     end
+
+    def undefined?(value)
+      value.is_a?(Undefined)
+    end
   end
 end

data/lib/nxt_http_client/{default_config.rb → config.rb}

@@ -1,7 +1,7 @@
 module NxtHttpClient
   CONFIGURABLE_OPTIONS = %i[request_options base_url x_request_id_proc].freeze
 
-  DefaultConfig = Struct.new('DefaultConfig', *CONFIGURABLE_OPTIONS) do
+  Config = Struct.new('Config', *CONFIGURABLE_OPTIONS) do
     def initialize(request_options: ActiveSupport::HashWithIndifferentAccess.new, base_url: '', x_request_id_proc: nil)
       self.request_options = request_options
       self.base_url = base_url

data/lib/nxt_http_client/error.rb

@@ -13,7 +13,7 @@ module NxtHttpClient
     alias_method :to_s, :message
 
     def default_message
-      "NxtHttpClient::Error::#{response_code}"
+      "#{self.class.name}::#{response_code}"
     end
 
     def to_h
@@ -23,12 +23,14 @@ module NxtHttpClient
         response_code: response_code,
         request_options: request_options,
         response_headers: response_headers,
-        body: body
+        request_headers: request_headers,
+        body: body,
+        x_request_id: x_request_id
       }
     end
 
     def body
-      if response_content_type&.starts_with?('application/json')
+      if response_content_type&.starts_with?(ApplicationJson)
         JSON.parse(response.body)
       else
         response.body
@@ -49,6 +51,10 @@ module NxtHttpClient
       request.url
     end
 
+    def x_request_id
+      request_headers[XRequestId]
+    end
+
     def request_options
       @request_options ||= (request.original_options || {}).with_indifferent_access
     end

data/lib/nxt_http_client/fire_callbacks.rb

@@ -0,0 +1,66 @@
+module NxtHttpClient
+  class FireCallbacks
+    def initialize
+      @registry = build_registry
+    end
+
+    def clear(*kinds)
+      Array(kinds).each { |kind| registry.register!(kind, []) }
+    end
+
+    def register(kind, callback)
+      registry.resolve!(kind) << callback
+    end
+
+    def run(target, kind, *args)
+      registry.resolve!(kind).each do |callback|
+        run_callback(target, callback, *args)
+      end
+    end
+
+    def run_before(target:, request:, response_handler:)
+      registry.resolve!(:before).each do |callback|
+        run_callback(target, callback, *[target, request, response_handler])
+      end
+    end
+
+    def run_after(target:, request:, response:, result:, error:)
+      registry.resolve!(:after).inject(result) do |_, callback|
+        run_callback(target, callback, *[target, request, response, result, error])
+      end
+    end
+
+    def any_after_callbacks?
+      registry.resolve(:after).any?
+    end
+
+    def run_around(target:, request:, response_handler:, fire:)
+      around_callbacks = registry.resolve!(:around)
+      return fire.call unless around_callbacks.any?
+
+      args = *[target, request, response_handler]
+      callback_chain = around_callbacks.reverse.inject(fire) do |previous, callback|
+        -> { target.instance_exec(*args, previous, &callback) }
+      end
+
+      callback_chain.call
+    end
+
+    private
+
+    attr_reader :registry
+
+    def run_callback(target, callback, *args)
+      args = args.take(callback.arity)
+      target.instance_exec(*args, &callback)
+    end
+
+    def build_registry
+      NxtRegistry::Registry.new(:callbacks) do
+        register(:before, [])
+        register(:around, [])
+        register(:after, [])
+      end
+    end
+  end
+end

data/lib/nxt_http_client/headers.rb

@@ -0,0 +1,4 @@
+module NxtHttpClient
+  XRequestId = 'X-Request-ID'.freeze
+  ApplicationJson = 'application/json'
+end

data/lib/nxt_http_client/logger.rb

@@ -0,0 +1,47 @@
+module NxtHttpClient
+  class Logger
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def call(client, request, _response_handler, fire)
+      started_at = now
+      error = nil
+      result = nil
+
+      options = {
+        client: client,
+        started_at: started_at,
+        request: request
+      }
+
+      begin
+        result = fire.call
+      rescue => e
+        error = e
+        options.merge!(error: e)
+      ensure
+        finished_at = now
+        options.merge!(
+          finished_at: now,
+          elapsed_time_in_milliseconds: finished_at - started_at,
+          response: request.response,
+          http_status: request.response&.code
+        )
+      end
+
+      logger.call(options)
+      raise error if error
+
+      result
+    end
+
+    private
+
+    attr_reader :logger
+
+    def now
+      Time.current.to_i * 1000
+    end
+  end
+end

data/lib/nxt_http_client/response_handler.rb

@@ -10,8 +10,6 @@ module NxtHttpClient
     attr_accessor :result
 
     def eval_callback(target, key, response)
-      return unless callbacks.resolve!(key)
-
       target.instance_exec(response, &callbacks.resolve(key))
     end
 
@@ -20,6 +18,8 @@ module NxtHttpClient
     end
 
     def register_callback(code, overwrite: false, &block)
+      code = regex_or_code(code)
+
       if overwrite
         callbacks.register!(code, block)
       else
@@ -36,14 +36,10 @@ module NxtHttpClient
 
     def callback_for_response(response)
       key_from_response = response.code.to_s
-      return callbacks.resolve('any') if callbacks.resolve('any').present?
-
-      first_matching_key = callbacks.keys.sort.reverse.find do |key|
-        regex_key = key.gsub('*', '[0-9]{1}')
-        key_from_response =~ /\A#{regex_key}\z/
-      end
+      matching_any_callback = callbacks.resolve('any')
+      return matching_any_callback if matching_any_callback.present?
 
-      first_matching_key && callbacks.resolve(first_matching_key) ||
+      callbacks.resolve(key_from_response) ||
         response.success? && callbacks.resolve('success') ||
         response.timed_out? && callbacks.resolve('timed_out') ||
         !response.success? && callbacks.resolve('error') ||
@@ -60,6 +56,14 @@ module NxtHttpClient
 
     private
 
+    def regex_or_code(key)
+      return key if key.is_a?(Regexp)
+      return key if key.to_s.exclude?('*')
+
+      regex_key = key.to_s.gsub('*', '[0-9]{1}')
+      /\A#{regex_key}\z/
+    end
+
     def raise_callback_already_registered(code)
       msg = "Callback already registered for status: #{code}."
       msg << ' Use bang method to overwrite the callback.'

data/lib/nxt_http_client/undefined.rb

@@ -0,0 +1,4 @@
+module NxtHttpClient
+  class Undefined
+  end
+end

data/lib/nxt_http_client/version.rb

@@ -1,3 +1,3 @@
 module NxtHttpClient
-  VERSION = "0.3.4"
+  VERSION = "1.0.0"
 end

data/nxt_http_client.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport', '~> 6.0'
   spec.add_dependency 'nxt_registry'
 
-  spec.add_development_dependency 'bundler', '~> 1.17'
+  spec.add_development_dependency 'bundler', '~> 2.2'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'pry'
@@ -48,4 +48,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'nxt_vcr_harness'
   spec.add_development_dependency 'redis'
   spec.add_development_dependency 'rspec_junit_formatter'
+  spec.add_development_dependency 'timecop'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_http_client
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -61,14 +61,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -181,6 +181,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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'
 description: NxtHttpClinet allows you to easily create and configure http clients.
 email:
 - a.robecke@getsafe.de
@@ -203,9 +217,13 @@ files:
 - lib/nxt_http_client.rb
 - lib/nxt_http_client/client.rb
 - lib/nxt_http_client/client_dsl.rb
-- lib/nxt_http_client/default_config.rb
+- lib/nxt_http_client/config.rb
 - lib/nxt_http_client/error.rb
+- lib/nxt_http_client/fire_callbacks.rb
+- lib/nxt_http_client/headers.rb
+- lib/nxt_http_client/logger.rb
 - lib/nxt_http_client/response_handler.rb
+- lib/nxt_http_client/undefined.rb
 - lib/nxt_http_client/version.rb
 - nxt_http_client.gemspec
 homepage: https://github.com/nxt-insurance