chimera_http_client 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f53a50a92fd82daebeae2cad2156dd5a0eef366d4aec27d2ecb13fffe8f771f3
-  data.tar.gz: ef515b583ba8cbbd76286e626dfbe34cf06662710c04e441f9d4e926577962cb
+  metadata.gz: 5e2fa666cf4ec3fe21e1f4a8ecfb3932c5dac1cb6d0c7d16762eea73bf76fb44
+  data.tar.gz: df72864e42844dd77dcc9f64bfc23f69d73a66ee66f7589c8ef1e460524b831c
 SHA512:
-  metadata.gz: fa715d6646f2f924a67bd0049598156eaacee8b60a81d28858cddf86f8a7e42c2ae50097fd7be824d8d7ff91fd0bc1569713cb014b7e3a1859a634bf9c3d4568
-  data.tar.gz: '069987a5e71950ba299b313a93f9cb6533adfe275bbda057a076614aeb8d053fc1e574a7db588d75dfc36a7611d10260c6b0ebde9fac274474e5ef85603fe356'
+  metadata.gz: 52cd8916ab3bd1956753eac56a54a0c9b6130fdfbb38e9d7f2083b137097e1a585a8d205ad75f6e3b6713ee55cf66c1443b8136c22f7d48c8e0045da397612c5
+  data.tar.gz: 70f7a691115d59909ec1831d48ed1fc02f4aa7ce8057bc35cf015a4254ee1f09318b45a20cf30686548d2b0bd686644ac0df6f5f6e9e9c2303b09b5cedfbb611

data/.rubocop.yml

@@ -76,6 +76,9 @@ Style/NumericLiterals:
 Style/Semicolon:
   AllowAsExpressionSeparator: true
 
+Style/SymbolProc:
+  Enabled: false
+
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyleForMultiline, SupportedStyles.
 # SupportedStyles: comma, consistent_comma, no_comma

data/README.markdown

@@ -1,6 +1,10 @@
 # ChimeraHttpClient
 
-When starting to split monolithic apps into smaller services, you need an easy way to access the remote data from the other apps. This chimera_http_client gem should serve as a unified way to access endpoints from other apps. And what works for the internal communication between your own apps, will also work for external APIs that do not offer a client for simplified access.
+When starting to split monolithic apps into smaller services, you need an easy way to access the remote data from the other apps. This **chimera_http_client gem** should serve as **a comfortable and unifying way** to access endpoints from other apps.
+
+And what works for the internal communication between your own apps, will also work for external APIs that do not offer a client for simplified access.
+
+It offers an **easy to learn interface** and **nice error handling**. And it enables you to **queue HTTP requests to run them in parallel** for better performance.
 
 ## Dependencies
 
@@ -8,10 +12,43 @@ The `chimera_http_client` gem is using the _libcurl_ wrapper [**Typhoeus**](http
 
 It does not have any other runtime dependencies.
 
-### optional
+### ENV variables
 
 Setting the environment variable `ENV['CHIMERA_HTTP_CLIENT_LOG_REQUESTS']` to `true` (or `'true'`) will provide more detailed error messages for logging and also add additional information to the Error JSON. It is recommended to use this only in development environments.
 
+## Table of Contents
+
+<!-- TOC depthFrom:1 depthTo:4 withLinks:1 updateOnSave:0 orderedList:0 -->
+
+- [ChimeraHttpClient](#chimerahttpclient)
+	- [Table of Contents](#table-of-contents)
+	- [Dependencies](#dependencies)
+		- [ENV variables](#env-variables)
+	- [The Connection class](#the-connection-class)
+		- [Initialization](#initialization)
+			- [Mandatory initialization parameter `base_url`](#mandatory-initialization-parameter-baseurl)
+			- [Optional initialization parameters](#optional-initialization-parameters)
+		- [Request methods](#request-methods)
+			- [Mandatory request parameter `endpoint`](#mandatory-request-parameter-endpoint)
+			- [Optional request parameters](#optional-request-parameters)
+			- [Basic auth](#basic-auth)
+			- [Timeout duration](#timeout-duration)
+			- [Custom logger](#custom-logger)
+			- [Caching responses](#caching-responses)
+		- [Example usage](#example-usage)
+	- [The Request class](#the-request-class)
+	- [The Response class](#the-response-class)
+	- [Error classes](#error-classes)
+	- [The Queue class](#the-queue-class)
+		- [Queueing requests](#queueing-requests)
+		- [Executing requests in parallel](#executing-requests-in-parallel)
+	- [Installation](#installation)
+	- [Maintainers and Contributors](#maintainers-and-contributors)
+		- [Roadmap](#roadmap)
+	- [Chimera](#chimera)
+
+<!-- /TOC -->
+
 ## The Connection class
 
 The basic usage looks like this:
@@ -21,38 +58,119 @@ connection = ChimeraHttpClient::Connection.new(base_url: 'http://localhost/names
 response = connection.get!(endpoint, params: params)
 ```
 
-`ChimeraHttpClient::Connection.new` expects an options hash as parameter. The only required option is **base_url** which should include the host, port and base path to the API endpoints you want to call, e.g.  
-`base_url: 'http://localhost:3000/v1'`.
+### Initialization
+
+`connection = ChimeraHttpClient::Connection.new(base_url: 'http://localhost:3000/v1', logger: logger, cache: cache)`
+
+#### Mandatory initialization parameter `base_url`
+
+The mandatory parameter is **base_url** which should include the host, port and base path to the API endpoints you want to call, e.g. `'http://localhost:3000/v1'`.
+
+Setting the `base_url` is meant to be a comfort feature, as you can then pass short endpoints to each request like `/users`. You could set an empty string `''` as `base_url` and then pass full qualified URLs as endpoint of the requests.
+
+#### Optional initialization parameters
 
-On this connection object, you can call methods like `#get!` or `#post!` with an endpoint and an options hash as parameters, e.g.  
-`connection.get!("users/#{id}")`  
-or  
-`connection.get(['users', id], options: { headers: { '	Accept-Charset' => 'utf-8' })`  
+The optional parameters are:
 
-Please take note that _the endpoint can be given as a String, a Symbol, or as an Array._  
-While they do no harm, there is _no need to pass leading or trailing `/` in endpoints._
-When passing the endpoint as an Array, _it's elements are converted to Strings and concatenated with `/`._  
-On each request _the http-headers can be amended or overwritten_ completely or partially.
+* `logger` - an instance of a logger class that implements `#info` and `#warn` methods
+* `timeout` - the timeout for all requests, can be overwritten in any request, the default are 3 seconds
+* `user_agent` - if you would like your calls to identify with a specific user agent
+* `verbose` - the default is `false`, set it to true while debugging issues
+* `cache` - an instance of your cache solution, can be overwritten in any request
 
-### Basic auth
+### Request methods
+
+The available methods are:
+
+* `get` / `get!`
+* `post` / `post!`
+* `put` / `put`
+* `patch` / `patch!`
+* `delete` / `delete!`
+
+where the methods ending on a _bang!_ will raise an error (which you should handle in your application) while the others will return an error object.
+
+#### Mandatory request parameter `endpoint`
+
+The `base_url` set in the connection will together with the `endpoint` determine the URL to make a request to.
+
+```ruby
+connection.get([:users, id])
+connection.get(["users", id])
+connection.get("users/#{id}")
+connection.get("/users/#{id}")
+```
 
-In case you need to use an API that is protected by **basic_auth** just pass the credentials in the options hash:  
-`options: { username: 'admin', password: 'secret' }`
+All forms above ave valid and will make a request to the same URL.
 
-### Timeout duration
+* Please take note that _the endpoint can be given as a String, a Symbol, or an Array._  
+* While they do no harm, there is _no need to pass leading or trailing `/` in endpoints._  
+* When passing the endpoint as an Array, _it's elements are converted to Strings and concatenated with `/`._  
+
+#### Optional request parameters
+
+All request methods expect a mandatory `endpoint` and an optional hash as parameters. In the latter the following keywords are treated specially:
+
+* `body` - the mandatory body of a `post`, `put` or `patch` request
+* `headers` - a hash of HTTP headers
+* `params` - parameters of a HTTP request
+* `username` - used for a BasicAuth login
+* `password` - used for a BasicAuth login
+* `timeout` - set a custom timeout per request (the default is 3 seconds)
+* `cache` - optionally overwrite the cache store set in `Connection` in any request
+
+Example:
+
+```ruby
+connection.post(
+  :users,
+  body: { name: "Andy" },
+  params: { origin: `Twitter`},
+  headers: { "Authorization" => "Bearer #{token}" },
+  timeout: 10,
+  cache: nil
+)
+```
+
+#### Basic auth
+
+In case you need to use an API that is protected by **basic_auth** just pass the credentials as optional parameters:  
+`username: 'admin', password: 'secret'`
+
+#### Timeout duration
 
 The default timeout duration is **3 seconds**.
 
 If you want to use a different timeout, you can pass the key `timeout` when initializing the `Connection`. You can also overwrite it on every call.
 
-### Custom logger
+#### Custom logger
 
 By default no logging is happening. If you need request logging, you can pass your custom Logger to the key `logger` when initializing the `Connection`. It will write to `logger.info` when starting and when completing a request.
 
-### Caching responses
+#### Caching responses
 
 To cache all the reponses of a connection, just pass the optional parameter `cache` to its initializer. You can also overwrite the connection's cache configuration by passing the parameter `cache` to any `get` call.
 
+It could be an instance of an implementation as simple as this:
+
+```ruby
+class Cache
+  def initialize
+    @memory = {}
+  end
+
+  def get(request)
+    @memory[request]
+  end
+
+  def set(request, response)
+    @memory[request] = response
+  end
+end
+```
+
+Or use an adapter for Dalli, Redis, or Rails cache that also support an optional time-to-live `default_ttl` parameter.
+
 Read more about how to use it: https://github.com/typhoeus/typhoeus#caching
 
 ### Example usage
@@ -180,6 +298,52 @@ The error classes and their corresponding http error codes:
     ServerError               # 500..599
     TimeoutError              # timeout
 
+## The Queue class
+
+Instead of making single requests immediately, the ChimeraHttpClient allows to queue requests and run them in **parallel**.
+
+The number of parallel requests is limited by your system. There is a hard limit for 200 concurrent requests. You will have to measure yourself where the sweet spot for optimal performance is - and when things start to get flaky. I recommend to queue not much more than 20 requests before running them.
+
+### Queueing requests
+
+The initializer of the `Queue` class expects and handles the same parameters as the `Connection` class.
+
+```ruby
+queue = ChimeraHttpClient::Queue.new(base_url: 'http://localhost:3000/v1')
+```
+
+`queue.add` expects and handles the same parameters as the requests methods of a connection.
+
+```ruby
+queue.add(method, endpoint, options = {})
+```
+
+The only difference is that a parameter to set the HTTP method has to prepended. Valid options for `method` are:
+
+* `:get` / `'get'` / `'GET'`
+* `:post` / `'post'` / `'POST'`
+* `:put` / `'put'` / `'PUT'`
+* `:patch` / `'patch'` / `'PATCH'`
+* `:delete` / `'delete'` / `'DELETE'`
+
+### Executing requests in parallel
+
+Once the queue is filled, run all the requests concurrently with:
+
+```ruby
+responses = queue.execute
+```
+
+`responses` will contain an Array of `ChimeraHttpClient::Response` objects when all calls succeed. If any calls fail, the Array will also contain `ChimeraHttpClient::Error` objects. It is in your responsibility to handle the errors.
+
+> Tip: every `Response` and every `Error` make the underlying `Typheous::Request` available over `object.response.request`, which could help with debugging, or with building your own retry mechanism.
+
+### Empty the queue
+
+The queue is emptied after execution. You could also empty it at any other point before by calling `queue.empty`.
+
+To inspect the requests waiting for execution, call `queue.queued_requests`.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -196,7 +360,7 @@ When updating the version, do not forget to run
 
 ## Maintainers and Contributors
 
-After checking out the repo, run `rake` to run the **tests and rubocop**.
+After checking out the repo, run `bundle install` and then `bundle execute rake` to run the **tests and rubocop**.
 
 You can also run `rake console` to open an irb session with the `ChimeraHttpClient` pre-loaded that will allow you to experiment.
 

data/Rakefile

@@ -5,7 +5,12 @@ RSpec::Core::RakeTask.new(:rspec)
 
 desc "Open a console with the ChimeraHttpClient loaded"
 task :console do
-  system "irb -r lib/chimera_http_client.rb"
+  puts "Console with the gem and awesome_print loaded:"
+  ARGV.clear
+  require "irb"
+  require "ap"
+  load "lib/chimera_http_client.rb"
+  IRB.start
 end
 
 desc "Run Rubocop"

data/TODO.markdown

@@ -15,11 +15,11 @@ _none known_
 
 ### Logger
 
-* ~allow to pass a logger~
-* ~add logger.info when starting a http call~
-* ~add logger.info when finishing a successful http call~
-* ~include the total_time of the requests in the log~
-* ~add (example) to README~
+* ~~allow to pass a logger~~
+* ~~add logger.info when starting a http call~~
+* ~~add logger.info when finishing a successful http call~~
+* ~~include the total_time of the requests in the log~~
+* ~~add (example) to README~~
 * add logger.warn / .error for error cases (?)
 
 ### Custom Serializer
@@ -35,28 +35,46 @@ _none known_
 * use custom deserializer in #parsed_body instead of default JSON parsing
 * add example to README
 
-### Queueing
+### Queueing / running in parallel
 
-* allow to queue multiple calls
-* execute (up to 10) calls in parallel
+* ~~allow to queue multiple requests~~
+* ~~execute (up to 200) requests in parallel~~
+* allow to pass one proc / block (for all requests) to use as on_complete handler for each request
 * add example to README
 
-### Caching
+### Queueing / run requests serialized
 
-* optional per connection or call
+* allow to queue multiple requests
+* execute (up to 5) queued requests
+* allow to pass a proc (per request) to use the response for the next request
+* or just explain how to code that yourself?
 * add example to README
 
+### Caching
+
+* ~~optional per connection or call~~
+* ~~add example to README~~
+
 ### Timeout
 
-* ~allow to set custom timeout per connection~
-* ~allow to set custom timeout per call~
-* ~add (example) to README~
+* ~~allow to set custom timeout per connection~~
+* ~~allow to set custom timeout per call~~
+* ~~add (example) to README~~
 
 ### Release
 
-* ~rename module to have unique namespace~
-* ~release to rubygems to add to the plethora of similar gems~
-* ~make repo public~
+* ~~rename module to have unique namespace~~
+* ~~release to rubygems to add to the plethora of similar gems~~
+* ~~make repo public~~
 * hook up Travis-CI
 * ensure it runs with Ruby 2.4 and newer
 * get feedback
+
+### File Uploads
+
+* add example to README
+
+### Streaming response bodies
+
+* enable to pass on_headers, on_body, on_complete procs
+* add example to README

data/chimera_http_client.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "typhoeus", "~> 1.1"
 
+  spec.add_development_dependency "awesome_print", "~> 1.8"
   spec.add_development_dependency "bundler",       "~> 1.13"
   spec.add_development_dependency "irb",           "~> 1.0"
   spec.add_development_dependency "rake",          ">= 10.0"

data/lib/chimera_http_client/base.rb

@@ -0,0 +1,54 @@
+module ChimeraHttpClient
+  class Base
+    USER_AGENT = "ChimeraHttpClient (by mediafinger)".freeze
+
+    def initialize(base_url:, logger: nil, timeout: nil, user_agent: USER_AGENT, verbose: false, cache: nil)
+      fail(ChimeraHttpClient::ParameterMissingError, "base_url expected, but not given") if base_url.nil?
+
+      @base_url = base_url
+      @logger = logger
+      @timeout = timeout
+
+      Typhoeus::Config.user_agent = user_agent
+      Typhoeus::Config.verbose = verbose
+      Typhoeus::Config.memoize = false
+      Typhoeus::Config.cache = cache
+    end
+
+    private
+
+    # Add default values to call options
+    def augmented_options(options)
+      options[:timeout] ||= @timeout
+
+      options
+    end
+
+    def extract_body(options)
+      body = options.delete(:body)
+      body_optional = options.delete(:body_optional)
+      fail(ChimeraHttpClient::ParameterMissingError, "body expected, but not given") if body.nil? && !body_optional
+      body
+    end
+
+    def extract_headers(options, headers)
+      given_headers = options.delete(:headers) || {}
+      headers.merge(given_headers)
+    end
+
+    def default_headers
+      { "Content-Type" => "application/json" }
+    end
+
+    # Build URL out of @base_url and endpoint given as String or Array, while trimming redundant "/"
+    def url(endpoint)
+      trimmed_endpoint = Array(endpoint).map { |e| trim(e) }
+      [@base_url.chomp("/"), trimmed_endpoint].flatten.reject(&:empty?).join("/")
+    end
+
+    # Remove leading and trailing "/" from a give part of a String (usually URL or endpoint)
+    def trim(element)
+      element.to_s.sub(%r{^\/}, "").chomp("/")
+    end
+  end
+end

data/lib/chimera_http_client/connection.rb

@@ -2,22 +2,11 @@
 # The bang methods get!, post!, put!, patch! and delete! raise a Error in case of failure
 
 module ChimeraHttpClient
-  class Connection
-    USER_AGENT = "ChimeraHttpClient (by mediafinger)".freeze
-
-    def initialize(base_url:, logger: nil, timeout: nil, user_agent: USER_AGENT, verbose: false, cache: nil)
-      fail(ChimeraHttpClient::ParameterMissingError, "base_url expected, but not given") if base_url.nil?
-
-      @base_url = base_url
-      @logger = logger
-      @timeout = timeout
+  class Connection < Base
+    def initialize(options = {})
+      super(options)
 
       define_bang_methods
-
-      Typhoeus::Config.user_agent = user_agent
-      Typhoeus::Config.verbose = verbose
-      Typhoeus::Config.memoize = false
-      Typhoeus::Config.cache = cache
     end
 
     def request
@@ -25,70 +14,34 @@ module ChimeraHttpClient
     end
 
     def get(endpoint, options = {})
-      headers = extract_headers(options, default_headers)
-
-      request.run(url: url(endpoint), method: :get, options: augmented_options(options), headers: headers)
+      run(:get, endpoint, options.merge(body_optional: true))
     end
 
     def post(endpoint, options = {})
-      run_with_body(:post, endpoint, options)
+      run(:post, endpoint, options)
     end
 
     def put(endpoint, options = {})
-      run_with_body(:put, endpoint, options)
+      run(:put, endpoint, options)
     end
 
     def patch(endpoint, options = {})
-      run_with_body(:patch, endpoint, options)
+      run(:patch, endpoint, options)
     end
 
     def delete(endpoint, options = {})
-      run_with_body(:delete, endpoint, options.merge(body_optional: true))
+      run(:delete, endpoint, options.merge(body_optional: true))
     end
 
     private
 
-    # Add default values to call options
-    def augmented_options(options)
-      options[:timeout] ||= @timeout
-
-      options
-    end
-
-    def run_with_body(method, endpoint, options = {})
+    def run(method, endpoint, options = {})
       body = extract_body(options)
       headers = extract_headers(options, default_headers)
 
       request.run(url: url(endpoint), method: method, body: body, options: augmented_options(options), headers: headers)
     end
 
-    # Build URL out of @base_url and endpoint given as String or Array, while trimming redundant "/"
-    def url(endpoint)
-      trimmed_endpoint = Array(endpoint).map { |e| trim(e) }
-      [@base_url.chomp("/"), trimmed_endpoint].flatten.reject(&:empty?).join("/")
-    end
-
-    # Remove leading and trailing "/" from a give part of a String (usually URL or endpoint)
-    def trim(element)
-      element.to_s.sub(%r{^\/}, "").chomp("/")
-    end
-
-    def extract_body(options)
-      body = options.delete(:body)
-      body_optional = options.delete(:body_optional)
-      fail(ChimeraHttpClient::ParameterMissingError, "body expected, but not given") if body.nil? && !body_optional
-      body
-    end
-
-    def extract_headers(options, headers)
-      given_headers = options.delete(:headers) || {}
-      headers.merge(given_headers)
-    end
-
-    def default_headers
-      { "Content-Type" => "application/json" }
-    end
-
     # get! post! put! patch! delete! return an Response when successful, but raise an Error otherwise
     def define_bang_methods
       {

data/lib/chimera_http_client/queue.rb

@@ -0,0 +1,49 @@
+module ChimeraHttpClient
+  class Queue < Base
+    def add(method, endpoint, options = {})
+      http_method = method.downcase.to_sym
+      options[:body_optional] = true if %i[get delete].include?(http_method)
+
+      body = extract_body(options)
+      headers = extract_headers(options, default_headers)
+
+      req = Request.new(logger: @logger).create(
+        url: url(endpoint),
+        method: http_method,
+        body: body,
+        options: augmented_options(options),
+        headers: headers
+      )
+
+      queued_requests << req
+    end
+
+    def execute
+      queued_requests.each do |request|
+        hydra.queue(request.request)
+      end
+
+      hydra.run
+
+      responses = queued_requests.map { |request| request.result }
+
+      empty
+
+      responses
+    end
+
+    def empty
+      @queued_requests = []
+    end
+
+    def queued_requests
+      @queued_requests ||= []
+    end
+
+    private
+
+    def hydra
+      @hydra ||= Typhoeus::Hydra.new
+    end
+  end
+end

data/lib/chimera_http_client/request.rb

@@ -2,11 +2,21 @@ module ChimeraHttpClient
   class Request
     TIMEOUT_SECONDS = 3
 
+    attr_reader :request, :result
+
     def initialize(logger: nil)
       @logger = logger
     end
 
     def run(url:, method:, body: nil, options: {}, headers: {})
+      create(url: url, method: method, body: body, options: options, headers: headers)
+
+      @request.run
+
+      @result
+    end
+
+    def create(url:, method:, body: nil, options: {}, headers: {})
       request_params = {
         method:          method,
         body:            body,
@@ -22,20 +32,19 @@ module ChimeraHttpClient
       password = options.fetch(:password, nil)
       request_params[:userpwd] = "#{username}:#{password}" if username && password
 
-      request = Typhoeus::Request.new(url, request_params)
+      @request = Typhoeus::Request.new(url, request_params)
 
-      result = nil
-      request.on_complete do |response|
+      @result = nil
+      @request.on_complete do |response|
         @logger&.info("Completed HTTP request: #{method.upcase} #{url} " \
           "in #{response.total_time&.round(3)}sec with status code #{response.code}")
 
-        result = on_complete_handler(response)
+        @result = on_complete_handler(response)
       end
 
       @logger&.info("Starting HTTP request: #{method.upcase} #{url}")
-      request.run
 
-      result
+      self
     end
 
     private

data/lib/chimera_http_client/version.rb

@@ -1,3 +1,3 @@
 module ChimeraHttpClient
-  VERSION = "0.4.0".freeze
+  VERSION = "0.5.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chimera_http_client
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andreas Finger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-15 00:00:00.000000000 Z
+date: 2019-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -126,8 +140,10 @@ files:
 - TODO.markdown
 - chimera_http_client.gemspec
 - lib/chimera_http_client.rb
+- lib/chimera_http_client/base.rb
 - lib/chimera_http_client/connection.rb
 - lib/chimera_http_client/error.rb
+- lib/chimera_http_client/queue.rb
 - lib/chimera_http_client/request.rb
 - lib/chimera_http_client/response.rb
 - lib/chimera_http_client/version.rb