nxt_http_client 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c6ed0e9821cb3c06245006c1c79a99788e4f46d2fc3ab2fbc4ab6e5009a48f3
-  data.tar.gz: 30462fe5cfa99f8b5f3dbd6c5dacbcab75841dc93a155a41afb4f66ebcbb58fd
+  metadata.gz: b2c6e9588a07ff6820f7988990ce130bbe7ad8b0cc3467b83b5222e7a7061ed3
+  data.tar.gz: 6bf74b2f2c1788cc1140fa63444238a04a55130fe1bdd2ac6d1621d941aad22f
 SHA512:
-  metadata.gz: 0dcf0bd755f9ee72b3961ac8cf57c3b6cc32c712fe2f4e4ff357ff98a0074a13436d84e395e35da1ea02e9ef173a7177f57487fa8b6207e98582c72b43800c41
-  data.tar.gz: d22767005133cd7bf1a2b6fd7c0804a37e7bae777af7e93493cc0678207037dbcafa05493c0dab7ebf4d23b31c8bedfc1d3178de15953514fe8980efc4f70897
+  metadata.gz: 479a2c6036211c446ccab839f750aba66b3d10df80676eca0134f23be474798f65b1524e38e8e85c834b2e353c92f4561140b7190d41849227a9f175a9915381
+  data.tar.gz: a7694a6c37e29420f042b0bc65588586783fee0e4509771accb72e4f3cd2dc204992b05d98604288546a4351c45cb361d711bebdeffef514c52fb47e21c20615

data/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ["3.3", "3.4", "4.0"]
+    services:
+      redis:
+        image: redis:7
+        ports:
+          - 6379:6379
+        options: --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - run: bundle exec rspec

data/.ruby-version

@@ -1 +1 @@
-3.3.2
+4.0.5

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# v2.2.0 2026-06-15
+- Report HTTP error details to Sentry via the structured `set_context('http_error', …)` instead of the
+  deprecated `set_extras(http_error_details: …)`. (Typhoeus is not auto-instrumented by Sentry, so the gem
+  attaches this itself.)
+- `Error#to_h` now redacts the `Authorization` header and basic-auth `userpwd` (it is sent to Sentry).
+- `json_response` now returns `nil` for an empty/204 body instead of raising `JSON::ParserError`.
+- Add an opt-in error taxonomy under `NxtHttpClient::Error`. With `config.raise_error_taxonomy = true` the client
+  raises a typed subclass for an unhandled 4xx/5xx/code-0 response instead of returning it:
+  - HTTP status: `ClientError` with `BadRequest` (400), `Unauthorized` (401), `Forbidden` (403),
+    `NotFound` (404), `UnprocessableEntity` (422), `TooManyRequests` (429); `ServerError` (5xx).
+  - Network (`return_code`-mapped code-0): `NetworkError` with `Timeout`, `ConnectionFailed`,
+    `NameResolutionError`, `TlsError`; `CertificateError` (cert verification — a sibling, not a child).
+- Retryable errors share base classes — `retry_on NxtHttpClient::Error::NetworkError, NxtHttpClient::Error::ServerError`.
+  4xx, `CertificateError` and 429 are excluded (429 retry policy is left to consumers).
+- `map_error(status, klass)` DSL to override the mapping per client (e.g. a domain `ValidationFailed` that
+  parses the body); inherited by subclasses.
+- `config.raise_error_taxonomy` defaults to `false`, so the upgrade is backwards compatible — existing behavior
+  (and `raise_response_errors`) is unchanged until you opt in. A consumer's own `on(<code>)`/`on(:error)`/
+  `on(:timed_out)` callback always takes precedence over the taxonomy.
+
 # v2.1.0 2024-06-05
 - Bump dependencies
 

data/Gemfile.lock

@@ -1,86 +1,98 @@
 PATH
   remote: .
   specs:
-    nxt_http_client (2.1.0)
-      activesupport (< 8.0)
+    nxt_http_client (2.2.0)
+      activesupport
       nxt_registry
       typhoeus
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.1.3.4)
+    activesupport (8.1.3)
       base64
       bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+      concurrent-ruby (~> 1.0, >= 1.3.1)
       connection_pool (>= 2.2.5)
       drb
       i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      mutex_m
-      tzinfo (~> 2.0)
-    addressable (2.8.6)
-      public_suffix (>= 2.0.2, < 6.0)
-    base64 (0.2.0)
-    bigdecimal (3.1.8)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    addressable (2.9.0)
+      public_suffix (>= 2.0.2, < 8.0)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
     coderay (1.1.3)
-    concurrent-ruby (1.3.1)
-    connection_pool (2.4.1)
-    crack (1.0.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    crack (1.0.1)
       bigdecimal
       rexml
-    diff-lcs (1.5.1)
-    drb (2.2.1)
-    ethon (0.16.0)
+    diff-lcs (1.6.2)
+    drb (2.2.3)
+    ethon (0.18.0)
       ffi (>= 1.15.0)
-    ffi (1.17.0)
-    ffi (1.17.0-x86_64-darwin)
-    ffi (1.17.0-x86_64-linux-gnu)
-    hashdiff (1.1.0)
-    i18n (1.14.5)
+      logger
+    ffi (1.17.4)
+    ffi (1.17.4-x86_64-darwin)
+    ffi (1.17.4-x86_64-linux-gnu)
+    hashdiff (1.2.1)
+    i18n (1.14.8)
       concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    json (2.19.8)
+    logger (1.7.0)
     method_source (1.1.0)
-    minitest (5.23.1)
-    mutex_m (0.2.0)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
     nxt_registry (0.3.10)
       activesupport
     nxt_vcr_harness (0.2.0)
       rspec (~> 3.0)
       vcr (~> 6.0)
-    pry (0.14.2)
+    prism (1.9.0)
+    pry (0.16.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (5.0.5)
-    rake (13.2.1)
-    redis (5.2.0)
+      reline (>= 0.6.0)
+    public_suffix (7.0.5)
+    rake (13.4.2)
+    redis (5.4.1)
       redis-client (>= 0.22.0)
-    redis-client (0.22.2)
+    redis-client (0.29.0)
       connection_pool
-    rexml (3.2.8)
-      strscan (>= 3.0.9)
-    rspec (3.13.0)
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rexml (3.4.4)
+    rspec (3.13.2)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.0)
+    rspec-core (3.13.6)
       rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.0)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.1)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.1)
+    rspec-support (3.13.7)
     rspec_junit_formatter (0.6.0)
       rspec-core (>= 2, < 4, != 2.12.0)
-    strscan (3.1.0)
-    timecop (0.9.9)
-    typhoeus (1.4.1)
-      ethon (>= 0.9.0)
+    securerandom (0.4.1)
+    timecop (0.9.11)
+    typhoeus (1.6.0)
+      ethon (>= 0.18.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    vcr (6.2.0)
-    webmock (3.23.1)
+    uri (1.1.1)
+    vcr (6.4.0)
+    webmock (3.26.2)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)

data/README.md

@@ -48,7 +48,7 @@ class UserServiceClient < NxtHttpClient::Client
     # Note: This error handler is set by default when you use 
     # config.raise_response_errors = true
     handler.on(:error) do |response|
-      Sentry.set_extras(http_error_details: error.to_h)
+      Sentry.set_context('http_error', error.to_h)
       raise StandardError, "I can't handle this: #{response.code}"
     end
   end
@@ -118,12 +118,16 @@ Register your default request options on the class level. Available options are:
 - `base_url=`
 - `x_request_id_proc=`
 - `json_request=`: Shorthand to set the Content-Type request header to JSON and automatically convert request bodies to JSON
-- `json_response=`: Shorthand to set the Accept request header and automatically convert success response bodies to JSON
-- `raise_response_errors=`: Makes the client raise a `NxtHttpClient::Error` for a non-success response. 
-  You can also do this manually by setting a response_handler.
+- `json_response=`: Shorthand to set the Accept request header and automatically convert success response bodies to JSON (an empty/204 body becomes `nil`)
+- `raise_response_errors=`: Makes the client raise a generic `NxtHttpClient::Error` for a non-success response.
+  Superseded by `raise_error_taxonomy` (which raises typed errors and takes precedence when both are set); kept for
+  backward compatibility.
+- `raise_error_taxonomy=`: Defaults to `false`. Opt in to raise the mapped `NxtHttpClient::Error` taxonomy
+  (`ClientError`/`ServerError`/`NetworkError` subclasses) on an unhandled 4xx/5xx/code-0 response instead of
+  returning it. See [Error taxonomy](#error-taxonomy).
 - `bearer_auth=`: Set a bearer token to be sent in the Authorization header
 - `basic_auth=`: Pass a Hash containing `:username` and `:password`, to be sent as Basic credentials in the Authorization header
-- `timeouts(total:, connect: nil)`: Configure timeouts
+- `timeout_seconds(total:, connect: nil)`: Configure timeouts
 
 ### response_handler
 
@@ -215,13 +219,84 @@ To set a timeout, use the `timeout_seconds` config method:
 configure do |config|
   config.timeout_seconds(total: 10)
   # You can also set a connect timeout
-  config.timeout_seconds(total: 10, connecttimeout: 2)
+  config.timeout_seconds(total: 10, connect: 2)
 end
 ```
 
 NxtHttpClient::Error exposes the `timed_out?` method from `Typhoeus::Response`, so you can check if an error is raised due to a timeout. 
 This is useful when setting a custom timeout value in your configuration.
 
+### Error taxonomy
+
+Set `config.raise_error_taxonomy = true` and the client raises a typed subclass of `NxtHttpClient::Error` for an
+unhandled 4xx, 5xx, or code-0 (network) response, so you no longer need to hand-roll per-status
+`on(400)`/`on(422)`/`on(5xx)`/`on(0)` handlers just to get a usable taxonomy. (3xx and other codes are returned
+as before.) It is **off by default** (the client returns the response); all classes inherit from
+`NxtHttpClient::Error`, so existing `rescue NxtHttpClient::Error` handlers keep working.
+
+**HTTP status:**
+
+| status        | class                                       | retryable? |
+|---------------|---------------------------------------------|------------|
+| 400           | `NxtHttpClient::Error::BadRequest`          | no         |
+| 401           | `NxtHttpClient::Error::Unauthorized`        | no         |
+| 403           | `NxtHttpClient::Error::Forbidden`           | no         |
+| 404           | `NxtHttpClient::Error::NotFound`            | no         |
+| 422           | `NxtHttpClient::Error::UnprocessableEntity` | no         |
+| 429           | `NxtHttpClient::Error::TooManyRequests`     | up to you  |
+| other 4xx     | `NxtHttpClient::Error::ClientError`         | no         |
+| 5xx           | `NxtHttpClient::Error::ServerError`         | yes        |
+
+**Network / code 0.** Typhoeus/libcurl surfaces network failures and timeouts as a response with HTTP **code 0**
+(no response received); the real cause lives in libcurl's `return_code`:
+
+| libcurl `return_code`                              | class                                       | retryable? |
+|----------------------------------------------------|---------------------------------------------|------------|
+| `:operation_timedout`                              | `NxtHttpClient::Error::Timeout`             | yes        |
+| `:couldnt_connect`                                 | `NxtHttpClient::Error::ConnectionFailed`    | yes        |
+| `:couldnt_resolve_host` / `:couldnt_resolve_proxy` | `NxtHttpClient::Error::NameResolutionError` | yes        |
+| `:ssl_connect_error` and other non-cert `:ssl_*`   | `NxtHttpClient::Error::TlsError`            | yes        |
+| any other code-0                                   | `NxtHttpClient::Error::NetworkError`        | yes        |
+| cert verification (`:peer_failed_verification`, …)  | `NxtHttpClient::Error::CertificateError`    | no         |
+
+#### Retrying
+
+The retryable errors share two base classes, so a job retries them in one place:
+
+```ruby
+retry_on NxtHttpClient::Error::NetworkError, NxtHttpClient::Error::ServerError
+```
+
+`ClientError` (4xx) is not retried — those are caller mistakes. `CertificateError` is a **sibling** of `NetworkError`
+(not a child), so it is excluded from `retry_on NetworkError` — a failed cert/CA verification is permanent.
+`TooManyRequests` (429) is left out of the retryable set; add your own `retry_on NxtHttpClient::Error::TooManyRequests`
+(ideally honoring `Retry-After`) if you want it.
+
+#### Precedence and opting out
+
+A consumer's own `on(<code>)` / `on(:error)` / `on(:timed_out)` callback always takes precedence; the raise only
+fires when nothing else handled the response. So you can enable the taxonomy for retries yet still handle, say, a
+404 inline with your own `on(404)`.
+
+#### Domain-typed errors
+
+Map a status to your own error class with `map_error` to get a domain error that parses the response body. It is
+inherited by subclasses and overrides the default for that status. `map_error` only takes effect when
+`raise_error_taxonomy` is enabled — it customizes the taxonomy, it does not enable raising on its own:
+
+```ruby
+class MyService::Client < NxtHttpClient::Client
+  configure { |config| config.raise_error_taxonomy = true }
+  map_error 422, MyService::Error::ValidationFailed
+end
+
+class MyService::Error::ValidationFailed < NxtHttpClient::Error
+  def default_message
+    body.dig('errors', 0, 'detail') # `body` parses JSON response bodies for you
+  end
+end
+```
+
 ### 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.

data/lib/nxt_http_client/client.rb

@@ -144,7 +144,25 @@ module NxtHttpClient
 
     def callback_or_response(response, response_handler)
       callback = response_handler.callback_for_response(response)
-      callback && instance_exec(response, &callback) || response
+      return instance_exec(response, &callback) || response if callback
+
+      return raise_mapped_error(response) if raise_mapped_error?(response)
+
+      response
+    end
+
+    # Reached only when no consumer callback matched, so a consumer on(<code>)/on(:error) keeps precedence.
+    def raise_mapped_error?(response)
+      return false unless config.raise_error_taxonomy
+
+      code = response.code.to_i
+      code.zero? || (400..599).cover?(code)
+    end
+
+    def raise_mapped_error(response)
+      error = self.class.error_class_for(response).new(response)
+      ::Sentry.set_context('http_error', error.to_h) if defined?(::Sentry)
+      raise error
     end
 
     def build_response_handler(handler, &block)
@@ -153,17 +171,20 @@ module NxtHttpClient
       if config.json_response
         response_handler.configure do |handler|
           handler.on(:success) do |response|
-            response.define_singleton_method(:body) { JSON(response.response_body) }
+            # nil for a blank/204 body — parsing "" would raise JSON::ParserError
+            response.define_singleton_method(:body) { response.response_body.presence && JSON(response.response_body) }
             response
           end
         end
       end
 
-      if config.raise_response_errors
+      # Legacy generic-error raising. Superseded by raise_error_taxonomy (typed), which takes precedence here
+      # via the callback_or_response fallback — so don't also register this shadowing on(:error) handler.
+      if config.raise_response_errors && !config.raise_error_taxonomy
         response_handler.configure do |handler|
           handler.on(:error) do |response|
             error = NxtHttpClient::Error.new(response)
-            ::Sentry.set_extras(http_error_details: error.to_h) if defined?(::Sentry)
+            ::Sentry.set_context('http_error', error.to_h) if defined?(::Sentry)
             raise error
           end
         end

data/lib/nxt_http_client/client_dsl.rb

@@ -52,6 +52,24 @@ module NxtHttpClient
       @response_handler
     end
 
+    # Override the taxonomy's error class for a status, e.g. `map_error 422, MyService::ValidationFailed`.
+    # Only takes effect when config.raise_error_taxonomy is enabled.
+    def map_error(status, error_class)
+      unless error_class.is_a?(Class) && error_class <= NxtHttpClient::Error
+        raise ArgumentError, "#{error_class.inspect} must be a subclass of NxtHttpClient::Error"
+      end
+
+      error_map[Integer(status)] = error_class
+    end
+
+    def error_map
+      @error_map ||= dup_option_from_ancestor(:@error_map) { {} }
+    end
+
+    def error_class_for(response)
+      error_map[response.code.to_i] || NxtHttpClient::Error.error_class_for(response)
+    end
+
     private
 
     def client_ancestors

data/lib/nxt_http_client/config.rb

@@ -8,7 +8,10 @@ module NxtHttpClient
     json_request: false,
     # Helper to set the Accept request header and automatically convert success response bodies to JSON
     json_response: false,
-    raise_response_errors: false,
+    raise_response_errors: false, # Legacy: raises a generic NxtHttpClient::Error. Superseded by raise_error_taxonomy.
+    # Opt in (default false) to raise the mapped NxtHttpClient::Error taxonomy on an unhandled
+    # 4xx/5xx/code-0 response instead of returning it. See README "Error taxonomy".
+    raise_error_taxonomy: false,
 
     bearer_auth: nil,
     basic_auth: nil,

data/lib/nxt_http_client/error.rb

@@ -1,5 +1,49 @@
 module NxtHttpClient
   class Error < StandardError
+    # Cert/trust failures — mapped to non-retryable CertificateError, kept out of the generic TlsError.
+    CERTIFICATE_RETURN_CODES = %i[
+      peer_failed_verification ssl_certproblem ssl_cacert_badfile ssl_issuer_error ssl_crl_badfile
+    ].freeze
+
+    REDACTED = '[REDACTED]'
+    SENSITIVE_HEADERS = %w[Authorization Proxy-Authorization].freeze
+
+    def self.from_response(response, message = nil)
+      error_class_for(response).new(response, message)
+    end
+
+    def self.error_class_for(response)
+      code = response.respond_to?(:code) ? response.code.to_i : 0
+      return network_error_class(response.respond_to?(:return_code) ? response.return_code : nil) if code.zero?
+
+      status_error_class(code)
+    end
+
+    def self.status_error_class(code)
+      case code
+      when 400 then BadRequest
+      when 401 then Unauthorized
+      when 403 then Forbidden
+      when 404 then NotFound
+      when 422 then UnprocessableEntity
+      when 429 then TooManyRequests
+      when 400..499 then ClientError
+      when 500..599 then ServerError
+      else self # 3xx etc. → base Error
+      end
+    end
+
+    def self.network_error_class(return_code)
+      case return_code
+      when :operation_timedout then Timeout
+      when :couldnt_connect then ConnectionFailed
+      when :couldnt_resolve_host, :couldnt_resolve_proxy then NameResolutionError
+      when *CERTIFICATE_RETURN_CODES then CertificateError
+      else
+        return_code.to_s.include?('ssl') ? TlsError : NetworkError
+      end
+    end
+
     def initialize(response, message = nil)
       @response = response.blank? ? Typhoeus::Response.new : response
       @id = SecureRandom.uuid
@@ -22,9 +66,9 @@ module NxtHttpClient
         id: id,
         url: url,
         response_code: response_code,
-        request_options: request_options,
+        request_options: redact_credentials(request_options),
         response_headers: response_headers,
-        request_headers: request_headers,
+        request_headers: redact_authorization(request_headers),
         body: body,
         x_request_id: x_request_id
       }
@@ -77,5 +121,46 @@ module NxtHttpClient
     def response_content_type
       response_headers['Content-Type']
     end
+
+    private
+
+    # Keep Authorization tokens / basic-auth creds out of serialized output (to_h reaches Sentry).
+    def redact_credentials(options)
+      options = options.merge('userpwd' => REDACTED) if options.key?('userpwd')
+      return options unless options['headers'].respond_to?(:key?)
+
+      options.merge('headers' => redact_authorization(options['headers']))
+    end
+
+    def redact_authorization(headers)
+      return headers unless headers.respond_to?(:keys)
+
+      # HTTP header names are case-insensitive, and HashWithIndifferentAccess does not normalize case.
+      sensitive = headers.keys.select { |key| SENSITIVE_HEADERS.any? { |name| key.to_s.casecmp?(name) } }
+      return headers if sensitive.empty?
+
+      headers.merge(sensitive.index_with { REDACTED })
+    end
+
+    public
+
+    class ClientError < self; end
+    class BadRequest < ClientError; end           # 400
+    class Unauthorized < ClientError; end          # 401
+    class Forbidden < ClientError; end             # 403
+    class NotFound < ClientError; end              # 404
+    class UnprocessableEntity < ClientError; end   # 422
+    class TooManyRequests < ClientError; end       # 429
+
+    class ServerError < self; end
+
+    class NetworkError < self; end                # code 0 (no HTTP response)
+    class Timeout < NetworkError; end             # :operation_timedout
+    class ConnectionFailed < NetworkError; end    # :couldnt_connect
+    class NameResolutionError < NetworkError; end # :couldnt_resolve_host / :couldnt_resolve_proxy
+    class TlsError < NetworkError; end            # :ssl_connect_error and other non-cert :ssl_*
+
+    # Sibling of NetworkError, not a child, so it's excluded from `retry_on NetworkError`.
+    class CertificateError < self; end
   end
 end

data/lib/nxt_http_client/version.rb

@@ -1,3 +1,3 @@
 module NxtHttpClient
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

data/nxt_http_client.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'typhoeus'
-  spec.add_dependency 'activesupport', '< 8.0'
+  spec.add_dependency 'activesupport'
   spec.add_dependency 'nxt_registry'
 
   spec.add_development_dependency 'bundler'

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: nxt_http_client
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Andreas Robecke
 - Nils Sommer
 - Raphael Kallensee
 - Luetfi Demirci
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -31,16 +30,16 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nxt_registry
   requirement: !ruby/object:Gem::Requirement
@@ -202,11 +201,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -234,7 +232,6 @@ homepage: https://github.com/nxt-insurance/nxt_http_client
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -249,8 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: NxtHttpClient is a simple DSL on top the typhoeus http gem
 test_files: []

data/.circleci/config.yml

@@ -1,20 +0,0 @@
-version: 2.1
-
-orbs:
-  ruby: circleci/ruby@2.0.1
-
-jobs:
-  build:
-    docker:
-      - image: cimg/ruby:3.3.2-node
-      - image: cimg/redis:6.0.16
-
-    working_directory: ~/repo
-
-    steps:
-      - checkout
-
-      - ruby/install-deps:
-          key: gems-v2
-          include-branch-in-cache-key: false
-      - ruby/rspec-test

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 3.3.2
-before_install: gem install bundler -v 1.17.2