my_api_client 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b40beeb8a70a00452e59208a5c7e2d5dee2c8155d2e23b5cd950e1a7e6f3eb1
-  data.tar.gz: 15c927bb0954c12225a73955b23b7ccc71b784a2cb63832f7914a757f2ac2ed2
+  metadata.gz: 81476ec85e1664e0b1109e44ea2c5b29eaf110954e687712826886d5e986b06f
+  data.tar.gz: 226c07c69e767db0863449d66585b2c1c42ececb529a727147e14e5fe70049db
 SHA512:
-  metadata.gz: c57cfcf7db9a8b9d45ee0c603402c910d2ea59bc0f3b406ba2c91388e9b0bab0997fe948dea5944fbc06499ea259c83579a154158808cce7433ea8d0beb02236
-  data.tar.gz: acc4846d877c8aace073858a102c72cc13245d6b13c94542b90d5da43798d04a6317533797b3e92a7e7710f532936ae551a0fa9cb1dcc8151bf58c68f5f06e24
+  metadata.gz: '009f14b37302243f4063703f8d5dd41680e6821b013e935165e9110c680b5b98cca9317d5e3abac8fade76f6fb0ba07aac0edad3bfb2b441e4a86f7e95e14534'
+  data.tar.gz: b718464bb2245c646692f2b0e5ce2dcbac6e7f15f2d4b88b7c5393c097116ed627f59371f9a75a51fdbebedf773c3de73780a92334214b725ebe3373ba72d6f1

data/.dependabot/config.yml

@@ -2,16 +2,13 @@ version: 1
 update_configs:
   - package_manager: "ruby:bundler"
     directory: "/"
-    update_schedule: "weekly"
+    update_schedule: "live"
     default_reviewers:
       - "ryz310"
     default_assignees:
       - "ryz310"
     default_labels:
       - "dependabot"
-    ignored_updates:
-      - match:
-          dependency_name: "rubocop*"
     automerged_updates:
       - match:
           dependency_type: "development"
@@ -21,7 +18,7 @@ update_configs:
           update_type: "semver:patch"
   - package_manager: "ruby:bundler"
     directory: "/my_api"
-    update_schedule: "weekly"
+    update_schedule: "live"
     default_reviewers:
       - "ryz310"
     default_assignees:

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Change log
 
+## v0.16.0 (Mar 29, 2020)
+
+### Breaking Change
+
+#### [#225](https://github.com/ryz310/my_api_client/pull/225) Raise an exception whenever an error is detected ([@ryz310](https://github.com/ryz310))
+
+Until now, using `with` or `block` in `error_handling` did not automatically raise an exception, but will now always raise an exception when an error is detected.
+You can specify raising error class with `raise` option.
+
+**Before**
+
+```rb
+error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
+
+def my_error_handling
+  # Executes this method when an error is detected.
+  # No exception is raised. You can raise an error if necessary.
+end
+```
+```rb
+error_handling status_code: 500..599 do |_params, logger|
+  # Executes this block when an error is detected.
+  # No exception is raised. You can raise an error if necessary.
+end
+```
+
+**After**
+
+```rb
+error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
+
+def my_error_handling
+  # Executes this method when an error is detected.
+  # And then raise `MyApiClient::Error`.
+end
+```
+```rb
+error_handling status_code: 500..599 do |params, logger|
+  # Executes this block when an error is detected.
+  # And then raise `MyApiClient::Error`.
+end
+```
+
+#### [#226](https://github.com/ryz310/my_api_client/pull/226) Default error handlers ([@ryz310](https://github.com/ryz310))
+
+Until now, you needed define all `error_handling` or `retry_on` yourself. But will now some `error_handling` and `retry_on` are prepared as default.
+
+You can check default `error_handling` or `retry_on` here.
+
+See: https://github.com/ryz310/my_api_client/blob/master/lib/my_api_client/default_error_handlers.rb
+
+### Dependabot
+
+* [#227](https://github.com/ryz310/my_api_client/pull/227) ryz310/dependabot/bundler/pry-byebug-3.9.0 ([@ryz310](https://github.com/ryz310))
+* [#228](https://github.com/ryz310/my_api_client/pull/228) ryz310/dependabot/bundler/my_api/jets-2.3.15 ([@ryz310](https://github.com/ryz310))
+
+### Misc
+
+* [#229](https://github.com/ryz310/my_api_client/pull/229) Edit dependabot configuration ([@ryz310](https://github.com/ryz310))
+
 ## v0.15.0 (Mar 21, 2020)
 
 ### Feature

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    my_api_client (0.15.0)
+    my_api_client (0.16.0)
       activesupport (>= 4.2.0)
       faraday (>= 0.17.1)
       jsonpath
@@ -37,19 +37,19 @@ GEM
     jsonpath (1.0.5)
       multi_json
       to_regexp (~> 0.2.1)
-    method_source (0.9.2)
+    method_source (1.0.0)
     minitest (5.14.0)
     multi_json (1.14.1)
     multipart-post (2.1.1)
     parallel (1.19.1)
-    parser (2.7.0.4)
+    parser (2.7.0.5)
       ast (~> 2.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.8.0)
+    pry (0.13.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
       byebug (~> 11.0)
-      pry (~> 0.10)
+      pry (~> 0.13.0)
     public_suffix (4.0.3)
     rainbow (3.0.0)
     rake (13.0.1)

data/README.jp.md

@@ -6,7 +6,9 @@ MyApiClient は API リクエストクラスを作成するための汎用的な
 
 ただし、 Sawyer はダミーデータの作成が難しかったり、他の gem で競合することがよくあるので、将来的には依存しないように変更していくかもしれません。
 
-また、 Ruby on Rails で利用することを想定してますが、それ以外の環境でも動作するように作っているつもりです。不具合などあれば Issue ページからご報告下さい。
+また、 Ruby on Rails で利用することを想定してますが、それ以外の環境でも動作するように作っています。不具合などあれば Issue ページからご報告下さい。
+
+[toc]
 
 ## Supported Versions
 
@@ -147,30 +149,31 @@ end
 
 ### Error handling
 
-上記のコードにエラーハンドリングを追加してみます。
+`my_api_client` ではレスポンスの内容によって例外を発生させるエラーハンドリングを定義できます。ここでは例として前述のコードにエラーハンドリングを定義しています。
 
 ```ruby
 class ExampleApiClient < MyApiClient::Base
   endpoint 'https://example.com'
 
-  error_handling status_code: 400..499, raise: MyApiClient::ClientError
+  error_handling status_code: 400..499,
+                 raise: MyApiClient::ClientError
 
-  error_handling status_code: 500..599 do |params, logger|
+  error_handling status_code: 500..599, raise: MyApiClient::ServerError do |_params, logger|
     logger.warn 'Server error occurred.'
-    raise MyApiClient::ServerError, params
   end
 
-  error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
+  error_handling json: { '$.errors.code': 10..19 },
+                 raise: MyApiClient::ClientError,
+                 with: :my_error_handling
 
   # Omission...
 
   private
 
-  # @param params [MyApiClient::Params::Params] HTTP req and res params
+  # @param params [MyApiClient::Params::Params] HTTP reqest and response params
   # @param logger [MyApiClient::Request::Logger] Logger for a request processing
   def my_error_handling(params, logger)
     logger.warn "Response Body: #{params.response.body.inspect}"
-    raise MyApiClient::ClientError, params
   end
 end
 ```
@@ -183,29 +186,26 @@ error_handling status_code: 400..499, raise: MyApiClient::ClientError
 
 これは `ExampleApiClient` からのリクエスト全てにおいて、レスポンスのステータスコードが `400..499` であった場合に `MyApiClient::ClientError` が例外として発生するようになります。 `ExampleApiClient` を継承したクラスにもエラーハンドリングは適用されます。ステータスコードのエラーハンドリングは親クラスで定義すると良いと思います。
 
-なお、 `status_code` には `Integer` `Range` `Regexp` が指定可能です。`raise` には `MyApiClient::Error` を継承したクラスが指定可能です。`my_api_client` で標準で定義しているエラークラスについては以下のソースコードをご確認下さい。
+なお、 `status_code` には `Integer` `Range` `Regexp` が指定可能です。
+
+`raise` には `MyApiClient::Error` を継承したクラスが指定可能です。`my_api_client` で標準で定義しているエラークラスについては以下のソースコードをご確認下さい。 `raise` を省略した場合は `MyApiClient::Error` を発生するようになります。
 
-https://github.com/ryz310/my_api_client/blob/master/lib/my_api_client/errors.rb
+https://github.com/ryz310/my_api_client/blob/master/lib/my_api_client/errors
 
-次に、 `raise` の代わりに `block` を指定する場合について。
+次に、 `block` を指定する場合について。
 
 ```ruby
-error_handling status_code: 500..599 do |params, logger|
+error_handling status_code: 500..599, raise: MyApiClient::ServerError do |_params, logger|
   logger.warn 'Server error occurred.'
-  raise MyApiClient::ServerError, params
 end
 ```
 
-上記の例であれば、ステータスコードが `500..599` の場合に `block` の内容が実行れます。引数の `params` にはリクエスト情報とレスポンス情報が含まれています。`logger` はログ出力用インスタンスですが、このインスタンスを使ってログ出力すると、以下のようにリクエスト情報がログ出力に含まれるようになり、デバッグの際に便利です。
+上記の例であれば、ステータスコードが `500..599` の場合に `MyApiClient::ServerError`  を発生させる前に `block` の内容が実行れます。引数の `params` にはリクエスト情報とレスポンス情報が含まれています。`logger` はログ出力用インスタンスですが、このインスタンスを使ってログ出力すると、以下のようにリクエスト情報がログ出力に含まれるようになり、デバッグの際に便利です。
 
 ```text
 API request `GET https://example.com/path/to/resouce`: "Server error occurred."
 ```
 
-リクエストに失敗した場合は例外処理を実行する、という設計が一般的だと思われるので、基本的にブロックの最後に `raise` を実行する事になると思います。
-
-最後に `json` と `with` を利用する場合について。
-
 ```ruby
 error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
 ```
@@ -221,17 +221,28 @@ error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
 }
 ```
 
-`with` にはインスタンスメソッド名を指定することで、エラーを検出した際に任意のメソッドを実行させることができます。メソッドに渡される引数は `block` 定義の場合と同じく `params` と `logger` です。
+`with` にはインスタンスメソッド名を指定することで、エラーを検出した際、例外を発生させる前に任意のメソッドを実行させることができます。メソッドに渡される引数は `block` 定義の場合と同じく `params` と `logger` です。なお、 `block` と `with` は同時には利用できません。
 
 ```ruby
 # @param params [MyApiClient::Params::Params] HTTP req and res params
 # @param logger [MyApiClient::Request::Logger] Logger for a request processing
 def my_error_handling(params, logger)
   logger.warn "Response Body: #{params.response.body.inspect}"
-  raise MyApiClient::ClientError, params
 end
 ```
 
+#### Default error handling
+
+`my_api_client` では、標準でステータスコード 400 ~ 500 番台のレスポンスを例外として処理するようにしています。ステータスコードが 400 番台場合は `MyApiClient::ClientError`、 500 番台の場合は `MyApiClient::ServerError` を継承した例外クラスが raise されます。
+
+また、 `MyApiClient::NetworkError` に対しても標準で `retry_on` が定義されています。
+
+いずれも override 可能ですので、必要に応じて `error_handling` を定義して下さい。
+
+以下のファイルで定義しています。
+
+https://github.com/ryz310/my_api_client/blob/master/lib/my_api_client/default_error_handlers.rb
+
 #### Symbol を利用する
 
 ```ruby
@@ -300,7 +311,9 @@ end
 
 API リクエストを何度も実行していると回線の不調などによりネットワークエラーが発生する事があります。長時間ネットワークが使えなくなるケースもありますが、瞬間的なエラーであるケースも多々あります。 `MyApiClient` ではネットワーク系の例外はまとめて `MyApiClient::NetworkError` として `raise` されます。この例外の詳細は後述しますが、 `retry_on` を利用する事で、 `ActiveJob` のように任意の例外処理を補足して、一定回数、一定の期間を空けて API リクエストをリトライさせる事ができます。
 
-ただし、 `ActiveJob` とは異なり同期処理でリトライするため、ネットワークの瞬断に備えたリトライ以外ではあまり使う機会はないのではないかと思います。上記の例のように API Limit に備えてリトライするケースもあるかと思いますが、こちらは `ActiveJob` で対応した方が良いと思います。
+なお、 `retry_on MyApiClient::NetworkError` は標準実装されているため、特別に定義せずとも自動的に適用されます。 `wait` や `attempts` に任意の値を設定したい場合のみ定義してご利用ください。
+
+ただし、 `ActiveJob` とは異なり同期処理でリトライするため、ネットワークの瞬断に備えたリトライ以外ではあまり使う機会はないのではないかと思います。上記の例のように API Rate Limit に備えてリトライするケースもあるかと思いますが、こちらは `ActiveJob` で対応した方が良いかもしれません。
 
 ちなみに一応 `discard_on` も実装していますが、作者自身が有効な用途を見出せていないので、詳細は割愛します。良い利用方法があれば教えてください。
 

data/example/api_clients/application_api_client.rb

@@ -10,12 +10,4 @@ class ApplicationApiClient < MyApiClient::Base
 
   http_open_timeout 2.seconds
   http_read_timeout 3.seconds
-
-  retry_on MyApiClient::NetworkError, wait: 0.seconds, attempts: 3
-
-  error_handling status_code: 400..499, raise: MyApiClient::ClientError
-  error_handling status_code: 500..599 do |params, logger|
-    logger.warn 'Server error occurred.'
-    raise MyApiClient::ServerError, params
-  end
 end

data/lib/generators/rails/templates/application_api_client.rb.erb

@@ -20,15 +20,4 @@ class ApplicationApiClient < MyApiClient::Base
   # seconds.
   #
   # http_read_timeout 3.seconds
-
-  # Catch the exception and re-execution after any seconds, like as ActiveJob.
-  # Please note that it is executed as a synchronous process unlike ActiveJob.
-  #
-  # retry_on MyApiClient::NetworkError, wait: 5.seconds, attempts: 3
-
-  # Set a HTTP response verifyment and behavior. If conflicting conditions are
-  # set, the processing defined later takes precedence
-  #
-  # error_handling status_code: 400..499, raise: MyApiClient::ClientError
-  # error_handling status_code: 500..599, raise: MyApiClient::ServerError
 end

data/lib/my_api_client.rb

@@ -19,6 +19,11 @@ require 'my_api_client/request/executor'
 require 'my_api_client/request/basic'
 require 'my_api_client/request/pagination'
 require 'my_api_client/errors'
+require 'my_api_client/errors/api_limit_error'
+require 'my_api_client/errors/client_error'
+require 'my_api_client/errors/network_error'
+require 'my_api_client/errors/server_error'
+require 'my_api_client/default_error_handlers'
 require 'my_api_client/params/params'
 require 'my_api_client/params/request'
 require 'my_api_client/request'

data/lib/my_api_client/base.rb

@@ -18,6 +18,8 @@ module MyApiClient
       self.error_handlers = []
     end
 
+    include MyApiClient::DefaultErrorHandlers
+
     # NOTE: This class **MUST NOT** implement #initialize method. Because it
     #       will become constraint that need call #super in the #initialize at
     #       definition of the child classes.

data/lib/my_api_client/default_error_handlers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # Provides default error handlers.
+  module DefaultErrorHandlers
+    extend ActiveSupport::Concern
+
+    # rubocop:disable Metrics/BlockLength
+    included do
+      # NOTE: The built-in error handlers are following. Although they are prepared
+      #       to save the trouble of defining, but you can override any error handlers
+      #       in your API client class.
+      error_handling status_code: 400..499, raise: ClientError
+      error_handling status_code: 400, raise: ClientError::BadRequest
+      error_handling status_code: 401, raise: ClientError::Unauthorized
+      error_handling status_code: 402, raise: ClientError::PaymentRequired
+      error_handling status_code: 403, raise: ClientError::Forbidden
+      error_handling status_code: 404, raise: ClientError::NotFound
+      error_handling status_code: 405, raise: ClientError::MethodNotAllowed
+      error_handling status_code: 406, raise: ClientError::NotAcceptable
+      error_handling status_code: 407, raise: ClientError::ProxyAuthenticationRequired
+      error_handling status_code: 408, raise: ClientError::RequestTimeout
+      error_handling status_code: 409, raise: ClientError::Conflict
+      error_handling status_code: 410, raise: ClientError::Gone
+      error_handling status_code: 411, raise: ClientError::LengthRequired
+      error_handling status_code: 412, raise: ClientError::PreconditionFailed
+      error_handling status_code: 413, raise: ClientError::RequestEntityTooLarge
+      error_handling status_code: 414, raise: ClientError::RequestUriTooLong
+      error_handling status_code: 415, raise: ClientError::UnsupportedMediaType
+      error_handling status_code: 416, raise: ClientError::RequestedRangeNotSatisfiable
+      error_handling status_code: 417, raise: ClientError::ExpectationFailed
+      error_handling status_code: 418, raise: ClientError::IamTeapot
+      error_handling status_code: 421, raise: ClientError::MisdirectedRequest
+      error_handling status_code: 422, raise: ClientError::UnprocessableEntity
+      error_handling status_code: 423, raise: ClientError::Locked
+      error_handling status_code: 424, raise: ClientError::FailedDependency
+      error_handling status_code: 425, raise: ClientError::TooEarly
+      error_handling status_code: 426, raise: ClientError::UpgradeRequired
+      error_handling status_code: 428, raise: ClientError::PreconditionRequired
+      error_handling status_code: 429, raise: ClientError::TooManyRequests
+      error_handling status_code: 431, raise: ClientError::RequestHeaderFieldsTooLarge
+      error_handling status_code: 451, raise: ClientError::UnavailableForLegalReasons
+
+      error_handling status_code: 500..599, raise: ServerError
+      error_handling status_code: 500, raise: ServerError::InternalServerError
+      error_handling status_code: 501, raise: ServerError::NotImplemented
+      error_handling status_code: 502, raise: ServerError::BadGateway
+      error_handling status_code: 503, raise: ServerError::ServiceUnavailable
+      error_handling status_code: 504, raise: ServerError::GatewayTimeout
+      error_handling status_code: 505, raise: ServerError::HttpVersionNotSupported
+      error_handling status_code: 506, raise: ServerError::VariantAlsoNegotiates
+      error_handling status_code: 507, raise: ServerError::InsufficientStorage
+      error_handling status_code: 508, raise: ServerError::LoopDetected
+      error_handling status_code: 509, raise: ServerError::BandwidthLimitExceeded
+      error_handling status_code: 510, raise: ServerError::NotExtended
+      error_handling status_code: 511, raise: ServerError::NetworkAuthenticationRequired
+
+      # Catch the exception and re-execution after any seconds, like as ActiveJob.
+      # Please note that it is executed as a synchronous process unlike ActiveJob.
+      retry_on NetworkError, wait: 0.3.seconds, attempts: 3
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/my_api_client/error_handling.rb

@@ -9,9 +9,8 @@ module MyApiClient
   # @example
   #   error_handling status_code: 200, json: :forbid_nil
   #   error_handling status_code: 400..499, raise: MyApiClient::ClientError
-  #   error_handling status_code: 500..599 do |params, logger|
+  #   error_handling status_code: 500..599, raise: MyApiClient::ServerError do |params, logger|
   #     logger.warn 'Server error occurred.'
-  #     raise MyApiClient::ServerError, params
   #   end
   #
   #   error_handling json: { '$.errors.code': 10..19 }, with: :my_error_handling
@@ -33,7 +32,7 @@ module MyApiClient
       #   as JsonPath expression.
       #   If specified `:forbid_nil`, it forbid `nil` at the response body.
       # @option with [Symbol]
-      #   Calls specified method when error detected
+      #   Calls specified method before raising exception when error detected.
       # @option raise [MyApiClient::Error]
       #   Raises specified error when an invalid response detected.
       #   Should be inherited `MyApiClient::Error` class.
@@ -42,7 +41,7 @@ module MyApiClient
       #   If the error detected, retries the API request. Requires `raise` option.
       #   You can set `true` or `retry_on` options (`wait` and `attempts`).
       # @yield [MyApiClient::Params::Params, MyApiClient::Request::Logger]
-      #   Executes the block when error detected.
+      #   Executes the block before raising exception when error detected.
       #   Forbid to be used with the` retry` option.
       def error_handling(**options, &block)
         options[:block] = block

data/lib/my_api_client/error_handling/generator.rb

@@ -23,8 +23,8 @@ module MyApiClient
       #   Raises specified error when error detected. default: MyApiClient::Error
       # @option block [Proc]
       #   Executes the block when error detected
-      # @return [Proc]
-      #   Returns value as `Proc`.
+      # @return [Proc, nil]
+      #   Returns the error handler as "Proc". If no error occurs, return `nil`.
       def initialize(**options)
         options[:raise] ||= MyApiClient::Error
         verify_and_set_arguments(**options)
@@ -43,14 +43,32 @@ module MyApiClient
 
       def generate_error_handler
         if _block
-          ->(params, logger) { _block.call(params, logger) }
+          block_caller
         elsif _with
-          ->(params, logger) { _instance.send(_with, params, logger) }
+          method_caller
         else
-          ->(params, _) { raise _raise, params }
+          error_raiser
         end
       end
 
+      def block_caller
+        lambda { |params, logger|
+          _block.call(params, logger)
+          error_raiser.call(params, logger)
+        }
+      end
+
+      def method_caller
+        lambda { |params, logger|
+          _instance.send(_with, params, logger)
+          error_raiser.call(params, logger)
+        }
+      end
+
+      def error_raiser
+        ->(params, _) { raise _raise, params }
+      end
+
       # Verify given options and raise error if they are incorrect.
       # If not, set them to instance variables.
       #

data/lib/my_api_client/errors.rb

@@ -25,57 +25,4 @@ module MyApiClient
       { error: super, params: params }.inspect
     end
   end
-
-  NETWORK_ERRORS = [
-    Faraday::TimeoutError,
-    Faraday::ConnectionFailed,
-    Faraday::SSLError,
-    OpenSSL::SSL::SSLError,
-    Net::OpenTimeout,
-    Net::ReadTimeout,
-    SocketError,
-  ].freeze
-
-  # Raises it when occurred to some network error
-  class NetworkError < Error
-    attr_reader :original_error
-
-    # Initialize the error class
-    #
-    # @param params [MyApiClient::Params::Params]
-    #   The request and response parameters
-    # @param original_error [StandardError]
-    #   Some network error
-    def initialize(params, original_error)
-      @original_error = original_error
-      super params, original_error.message
-    end
-
-    # Returns contents as string for to be readable for human
-    #
-    # @return [String] Contents as string
-    def inspect
-      { error: original_error, params: params }.inspect
-    end
-
-    # Generate metadata for bugsnag.
-    #
-    # @return [Hash] Metadata for bugsnag
-    def metadata
-      super.merge(original_error: original_error.inspect)
-    end
-  end
-
-  # NOTE: The built-in error classes are following. Although they are prepared
-  #       to save the trouble of defining, but you can create any error classes
-  #       which inherit the ancestor error class.
-
-  # For 4xx client error
-  class ClientError < Error; end
-
-  # For 5xx server error
-  class ServerError < Error; end
-
-  # For API request limit error
-  class ApiLimitError < Error; end
 end

data/lib/my_api_client/errors/api_limit_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For API request limit error
+  class ApiLimitError < Error; end
+end

data/lib/my_api_client/errors/client_error.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 4xx client error
+  class ClientError < Error
+    # 400 Bad Request
+    class BadRequest < ClientError; end
+
+    # 401 Unauthorized
+    class Unauthorized < ClientError; end
+
+    # 402 Payment Required
+    class PaymentRequired < ClientError; end
+
+    # 403 Forbidden
+    class Forbidden < ClientError; end
+
+    # 404 Not Found
+    class NotFound < ClientError; end
+
+    # 405 Method Not Allowed
+    class MethodNotAllowed < ClientError; end
+
+    # 406 Not Acceptable
+    class NotAcceptable < ClientError; end
+
+    # 407 Proxy Authentication Required
+    class ProxyAuthenticationRequired < ClientError; end
+
+    # 408 Request Timeout
+    class RequestTimeout < ClientError; end
+
+    # 409 Conflict
+    class Conflict < ClientError; end
+
+    # 410 Gone
+    class Gone < ClientError; end
+
+    # 411 Length Required
+    class LengthRequired < ClientError; end
+
+    # 412 Precondition Failed
+    class PreconditionFailed < ClientError; end
+
+    # 413 Payload Too Large
+    class RequestEntityTooLarge < ClientError; end
+
+    # 414 URI Too Long
+    class RequestUriTooLong < ClientError; end
+
+    # 415 Unsupported Media Type
+    class UnsupportedMediaType < ClientError; end
+
+    # 416 Range Not Satisfiable
+    class RequestedRangeNotSatisfiable < ClientError; end
+
+    # 417 Expectation Failed
+    class ExpectationFailed < ClientError; end
+
+    # 418 I'm a teapot
+    class IamTeapot < ClientError; end
+
+    # 421 Misdirected Request
+    class MisdirectedRequest < ClientError; end
+
+    # 422 Unprocessable Entity
+    class UnprocessableEntity < ClientError; end
+
+    # 423 Locked
+    class Locked < ClientError; end
+
+    # 424 Failed Dependency
+    class FailedDependency < ClientError; end
+
+    # 425 Too Early
+    class TooEarly < ClientError; end
+
+    # 426 Upgrade Required
+    class UpgradeRequired < ClientError; end
+
+    # 428 Precondition Required
+    class PreconditionRequired < ClientError; end
+
+    # 429 Too Many Requests
+    class TooManyRequests < ClientError; end
+
+    # 431 Request Header Fields Too Large
+    class RequestHeaderFieldsTooLarge < ClientError; end
+
+    # 451 Unavailable for Legal Reasons
+    class UnavailableForLegalReasons < ClientError; end
+  end
+end

data/lib/my_api_client/errors/network_error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  NETWORK_ERRORS = [
+    Faraday::TimeoutError,
+    Faraday::ConnectionFailed,
+    Faraday::SSLError,
+    OpenSSL::SSL::SSLError,
+    Net::OpenTimeout,
+    Net::ReadTimeout,
+    SocketError,
+  ].freeze
+
+  # Raises it when occurred to some network error
+  class NetworkError < Error
+    attr_reader :original_error
+
+    # Initialize the error class
+    #
+    # @param params [MyApiClient::Params::Params]
+    #   The request and response parameters
+    # @param original_error [StandardError]
+    #   Some network error
+    def initialize(params, original_error)
+      @original_error = original_error
+      super params, original_error.message
+    end
+
+    # Returns contents as string for to be readable for human
+    #
+    # @return [String] Contents as string
+    def inspect
+      { error: original_error, params: params }.inspect
+    end
+
+    # Generate metadata for bugsnag.
+    #
+    # @return [Hash] Metadata for bugsnag
+    def metadata
+      super.merge(original_error: original_error.inspect)
+    end
+  end
+end

data/lib/my_api_client/errors/server_error.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 5xx server error
+  class ServerError < Error
+    # 500 Internal Server Error
+    class InternalServerError < ServerError; end
+
+    # 501 Not Implemented
+    class NotImplemented < ServerError; end
+
+    # 502 Bad Gateway
+    class BadGateway < ServerError; end
+
+    # 503 Service Unavailable
+    class ServiceUnavailable < ServerError; end
+
+    # 504 Gateway Timeout
+    class GatewayTimeout < ServerError; end
+
+    # 505 HTTP Version Not Supported
+    class HttpVersionNotSupported < ServerError; end
+
+    # 506 Variant Also Negotiates
+    class VariantAlsoNegotiates < ServerError; end
+
+    # 507 Insufficient Storage
+    class InsufficientStorage < ServerError; end
+
+    # 508 Loop Detected
+    class LoopDetected < ServerError; end
+
+    # 509 Bandwidth Limit Exceeded
+    class BandwidthLimitExceeded < ServerError; end
+
+    # 510 Not Extended
+    class NotExtended < ServerError; end
+
+    # 511 Network Authentication Required
+    class NetworkAuthenticationRequired < ServerError; end
+  end
+end

data/lib/my_api_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MyApiClient
-  VERSION = '0.15.0'
+  VERSION = '0.16.0'
 end

data/my_api/Gemfile.lock

@@ -45,7 +45,7 @@ GEM
       rainbow
       thor
       zeitwerk
-    aws-partitions (1.285.0)
+    aws-partitions (1.290.0)
     aws-sdk-apigateway (1.37.0)
       aws-sdk-core (~> 3, >= 3.71.0)
       aws-sigv4 (~> 1.1)
@@ -55,7 +55,7 @@ GEM
     aws-sdk-cloudwatchlogs (1.29.0)
       aws-sdk-core (~> 3, >= 3.71.0)
       aws-sigv4 (~> 1.1)
-    aws-sdk-core (3.91.1)
+    aws-sdk-core (3.92.0)
       aws-eventstream (~> 1.0, >= 1.0.2)
       aws-partitions (~> 1, >= 1.239.0)
       aws-sigv4 (~> 1.1)
@@ -118,7 +118,7 @@ GEM
     hashie (4.1.0)
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)
-    jets (2.3.14)
+    jets (2.3.15)
       actionmailer (~> 6.0.0)
       actionpack (~> 6.0.0)
       actionview (~> 6.0.0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: my_api_client
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - ryz310
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-21 00:00:00.000000000 Z
+date: 2020-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -267,10 +267,15 @@ files:
 - lib/my_api_client.rb
 - lib/my_api_client/base.rb
 - lib/my_api_client/config.rb
+- lib/my_api_client/default_error_handlers.rb
 - lib/my_api_client/error_handling.rb
 - lib/my_api_client/error_handling/generator.rb
 - lib/my_api_client/error_handling/retry_option_processor.rb
 - lib/my_api_client/errors.rb
+- lib/my_api_client/errors/api_limit_error.rb
+- lib/my_api_client/errors/client_error.rb
+- lib/my_api_client/errors/network_error.rb
+- lib/my_api_client/errors/server_error.rb
 - lib/my_api_client/exceptions.rb
 - lib/my_api_client/integrations/bugsnag.rb
 - lib/my_api_client/params/params.rb