nfe-io 0.3.1 → 1.0.0

data/lib/nfe/client.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "nfe/configuration"
+require "nfe/http/net_http"
+require "nfe/http/retrying_transport"
+require "nfe/http/retry_policy"
+require "nfe/http/request"
+require "nfe/http/user_agent"
+require "nfe/error_factory"
+
+require "nfe/resources/abstract_resource"
+require "nfe/resources/service_invoices"
+require "nfe/resources/product_invoices"
+require "nfe/resources/consumer_invoices"
+require "nfe/resources/transportation_invoices"
+require "nfe/resources/inbound_product_invoices"
+require "nfe/resources/product_invoice_query"
+require "nfe/resources/consumer_invoice_query"
+require "nfe/resources/companies"
+require "nfe/resources/legal_people"
+require "nfe/resources/natural_people"
+require "nfe/resources/webhooks"
+require "nfe/resources/addresses"
+require "nfe/resources/legal_entity_lookup"
+require "nfe/resources/natural_person_lookup"
+require "nfe/resources/tax_calculation"
+require "nfe/resources/tax_codes"
+require "nfe/resources/state_taxes"
+require "nfe/resources/service_invoices_rtc"
+require "nfe/resources/product_invoices_rtc"
+
+module Nfe
+  # Primary entry point for the SDK.
+  #
+  #   client = Nfe::Client.new(api_key: "...")
+  #   client.service_invoices.create(company_id: "...", data: { ... })
+  #
+  # Resources are exposed as lazy, memoized snake_case accessors, each guarded
+  # by a +Mutex+ so a single +Client+ is safe to share across threads
+  # (Rails/Sidekiq/Puma). The class is the public surface and is NOT designed
+  # for subclassing; customization is achieved by composing
+  # {Nfe::Configuration} and the injected transport.
+  class Client
+    # The 17 core resource accessor names mapped to their resource classes.
+    RESOURCES = {
+      service_invoices: Resources::ServiceInvoices,
+      product_invoices: Resources::ProductInvoices,
+      consumer_invoices: Resources::ConsumerInvoices,
+      transportation_invoices: Resources::TransportationInvoices,
+      inbound_product_invoices: Resources::InboundProductInvoices,
+      product_invoice_query: Resources::ProductInvoiceQuery,
+      consumer_invoice_query: Resources::ConsumerInvoiceQuery,
+      companies: Resources::Companies,
+      legal_people: Resources::LegalPeople,
+      natural_people: Resources::NaturalPeople,
+      webhooks: Resources::Webhooks,
+      addresses: Resources::Addresses,
+      legal_entity_lookup: Resources::LegalEntityLookup,
+      natural_person_lookup: Resources::NaturalPersonLookup,
+      tax_calculation: Resources::TaxCalculation,
+      tax_codes: Resources::TaxCodes,
+      state_taxes: Resources::StateTaxes,
+      # RTC (Reforma Tributária) emission — paridade-plus addons, not part of
+      # the 17 canonical resources shared with the PHP/Node SDKs.
+      service_invoices_rtc: Resources::ServiceInvoicesRtc,
+      product_invoices_rtc: Resources::ProductInvoicesRtc
+    }.freeze
+
+    # @return [Nfe::Configuration] the active configuration.
+    attr_reader :configuration
+
+    # @param api_key [String, nil] the main API key (overridden by +configuration+).
+    # @param data_api_key [String, nil] the data-services API key.
+    # @param configuration [Nfe::Configuration, nil] when supplied, the other
+    #   convenience keyword arguments are ignored.
+    # @param environment [Symbol] :production (default) or :development.
+    # @param timeout [Integer] read timeout in seconds.
+    # @param max_retries [Integer] retries after the initial attempt.
+    # @param logger [#info, #warn, #error, nil]
+    # @param user_agent_suffix [String, nil]
+    def initialize(api_key: nil, data_api_key: nil, configuration: nil,
+                   environment: :production, timeout: 30, max_retries: 3,
+                   logger: nil, user_agent_suffix: nil)
+      @configuration = configuration || Configuration.new(
+        api_key: api_key,
+        data_api_key: data_api_key,
+        environment: environment,
+        timeout: timeout,
+        max_retries: max_retries,
+        logger: logger,
+        user_agent_suffix: user_agent_suffix
+      )
+      @resources = {}
+      @transports = {}
+      @resource_mutex = Mutex.new
+      @transport_mutex = Mutex.new
+    end
+
+    # Lazy, thread-safe, memoized resource accessors (each built once under a Mutex).
+    def service_invoices = resource(:service_invoices)
+    def product_invoices = resource(:product_invoices)
+    def consumer_invoices = resource(:consumer_invoices)
+    def transportation_invoices = resource(:transportation_invoices)
+    def inbound_product_invoices = resource(:inbound_product_invoices)
+    def product_invoice_query = resource(:product_invoice_query)
+    def consumer_invoice_query = resource(:consumer_invoice_query)
+    def companies = resource(:companies)
+    def legal_people = resource(:legal_people)
+    def natural_people = resource(:natural_people)
+    def webhooks = resource(:webhooks)
+    def addresses = resource(:addresses)
+    def legal_entity_lookup = resource(:legal_entity_lookup)
+    def natural_person_lookup = resource(:natural_person_lookup)
+    def tax_calculation = resource(:tax_calculation)
+    def tax_codes = resource(:tax_codes)
+    def state_taxes = resource(:state_taxes)
+    def service_invoices_rtc = resource(:service_invoices_rtc)
+    def product_invoices_rtc = resource(:product_invoices_rtc)
+
+    # Issue an arbitrary request against +family+, applying the family's host
+    # and key plus the standard authorization and User-Agent headers. This is
+    # the low-level escape hatch shared by every resource.
+    #
+    # When +request_options+ is supplied, its non-nil +api_key+, +base_url+, and
+    # +timeout+ override the family-resolved values for this single call (enabling
+    # multi-tenant per-call keys); nil fields fall back to family resolution.
+    #
+    # Raises the appropriate {Nfe::Error} subclass (via {Nfe::ErrorFactory}) on a
+    # non-2xx response (note: 202 is a success); otherwise returns the
+    # {Nfe::Http::Response}.
+    #
+    # @api private
+    def request(method, family:, path:, query: {}, body: nil, headers: {},
+                idempotency_key: nil, request_options: nil)
+      request = build_request(method, family: family, path: path, query: query,
+                                      body: body, headers: headers,
+                                      idempotency_key: idempotency_key,
+                                      request_options: request_options)
+
+      response = transport_for(family).call(request)
+      raise Nfe::ErrorFactory.from_response(response) unless response.success?
+
+      response
+    end
+
+    private
+
+    # Compose the {Nfe::Http::Request}, resolving host/key/timeout from the
+    # family (with per-call +request_options+ overrides) and applying the
+    # standard headers.
+    def build_request(method, family:, path:, query:, body:, headers:,
+                      idempotency_key:, request_options:)
+      base_url = request_options&.base_url || configuration.base_url_for(family)
+      api_key = request_options&.api_key || configuration.api_key_for(family)
+
+      Http::Request.new(
+        method: method.to_s.upcase,
+        base_url: base_url,
+        path: path,
+        headers: default_headers(api_key).merge(headers),
+        query: query,
+        body: body,
+        open_timeout: configuration.open_timeout,
+        read_timeout: request_options&.timeout || configuration.timeout,
+        idempotency_key: idempotency_key
+      )
+    end
+
+    # Standard headers applied to every outgoing request.
+    def default_headers(api_key)
+      {
+        "X-NFE-APIKEY" => api_key,
+        "User-Agent" => Http::UserAgent.build(configuration.user_agent_suffix),
+        "Accept" => "application/json"
+      }
+    end
+
+    # Memoize (under a Mutex) the resource instance for +name+.
+    def resource(name)
+      @resource_mutex.synchronize do
+        @resources[name] ||= RESOURCES.fetch(name).new(self)
+      end
+    end
+
+    # Memoize (under a Mutex) a RetryingTransport(NetHttp) per family. Families
+    # may differ in nothing transport-wise today, but memoizing per family keeps
+    # the door open for per-host tuning and matches the canonical contract.
+    def transport_for(family)
+      @transport_mutex.synchronize do
+        @transports[family] ||= build_transport
+      end
+    end
+
+    def build_transport
+      inner = Http::NetHttp.new(
+        default_open_timeout: configuration.open_timeout,
+        default_read_timeout: configuration.timeout,
+        ca_file: configuration.ca_file
+      )
+      policy = Http::RetryPolicy.new(
+        max_retries: configuration.max_retries,
+        base_delay: 1.0,
+        max_delay: 30.0,
+        jitter: 0.3
+      )
+      Http::RetryingTransport.new(inner: inner, policy: policy,
+                                  logger: configuration.logger)
+    end
+  end
+end

data/lib/nfe/configuration.rb

@@ -1,8 +1,209 @@
-class Configuration
-  attr_accessor :url, :user_agent
+# frozen_string_literal: true
 
-  def initialize
-    @url = "https://api.nfe.io"
-    @user_agent = "NFe.io Ruby Client v#{Nfe::VERSION}"
+module Nfe
+  # Central configuration for the SDK and the single source of truth for the
+  # multi-base-URL host map. No resource hard-codes a URL: resources declare an
+  # +api_family+ and obtain their host via {#base_url_for}.
+  #
+  # == Two-key model
+  # The SDK uses two API keys. The "data" families ({#api_key_for} maps
+  # +:addresses+, +:legal_entity+, +:natural_person+ and +:nfe_query+ to it)
+  # use +data_api_key+ when present, falling back to +api_key+. Every other
+  # family uses +api_key+. Either key may be supplied explicitly or via the
+  # +NFE_API_KEY+ / +NFE_DATA_API_KEY+ environment variables (explicit wins).
+  #
+  # == Environment (reserved for future use)
+  # +environment:+ (+:production+ / +:development+) is currently a reserved,
+  # no-op parameter: it is validated but does NOT change endpoints, keys, or
+  # behavior. Production vs. test (homologação) is determined by the account
+  # configuration at https://app.nfe.io (server-side) — not by the SDK or the
+  # API key — and there is no "sandbox URL". Full +environment:+ support is
+  # planned for a future release.
+  #
+  # == TLS trust
+  # +ca_file+ (and optionally +ca_path+) is the ONLY override of the TLS trust
+  # store and can only ADD/replace a CA bundle used to verify the peer. There is
+  # deliberately NO public API to disable peer verification (no +VERIFY_NONE+,
+  # no +insecure_ssl+). The upstream +insecureSsl+ attribute is a server-side
+  # property of a webhook delivery target, not the SDK's outbound TLS config.
+  class Configuration
+    # Host per NFE.io product family, keyed by the canonical (hyphenated)
+    # family symbol. The +/v1+ for the +:main+ family is supplied by each
+    # resource's +api_version+, not baked into the host. The +:addresses+
+    # family is the documented exception where +/v2+ is part of the host.
+    HOSTS = {
+      main: "https://api.nfe.io",
+      addresses: "https://address.api.nfe.io/v2",
+      "nfe-query": "https://nfe.api.nfe.io",
+      "legal-entity": "https://legalentity.api.nfe.io",
+      "natural-person": "https://naturalperson.api.nfe.io",
+      cte: "https://api.nfse.io"
+    }.freeze
+
+    # Maps family aliases (the snake_case names resources declare) to a
+    # canonical family key in {HOSTS}. Keys here are already hyphen-normalized.
+    FAMILY_ALIASES = {
+      companies: :main,
+      "service-invoices": :main,
+      "legal-people": :main,
+      "natural-people": :main,
+      webhooks: :main,
+      transportation: :cte,
+      "transportation-invoices": :cte,
+      "inbound-product": :cte,
+      "inbound-product-invoices": :cte,
+      "product-invoices": :cte,
+      "consumer-invoices": :cte,
+      "tax-calculation": :cte,
+      "tax-codes": :cte,
+      "state-taxes": :cte,
+      "product-invoice-query": :"nfe-query",
+      "consumer-invoice-query": :"nfe-query"
+    }.freeze
+
+    # Canonical families whose key resolves from +data_api_key+ first. Only the
+    # four dedicated-host data-lookup families belong here. +:cte+ (api.nfse.io —
+    # NF-e/NFC-e/CT-e emission + tax-rules/tax-codes/state-taxes) intentionally
+    # uses the main +api_key+ and is NOT a data family: in this SDK emission is a
+    # core capability, not a data-lookup. This is a deliberate divergence from the
+    # Node SDK (which routes api.nfse.io through the data-key fallback chain) —
+    # do not add +:cte+ here without revisiting that contract.
+    DATA_FAMILIES = %i[addresses legal-entity natural-person nfe-query].freeze
+
+    # Accepted +environment:+ values. Reserved for future use — both currently
+    # share the same endpoints and key resolution (see the class doc).
+    VALID_ENVIRONMENTS = %i[production development].freeze
+
+    DEFAULT_TIMEOUT = 30
+    DEFAULT_OPEN_TIMEOUT = 10
+    DEFAULT_MAX_RETRIES = 3
+
+    attr_reader :api_key, :data_api_key, :environment, :timeout, :open_timeout,
+                :max_retries, :logger, :user_agent_suffix, :base_url_overrides,
+                :ca_file, :ca_path, :proxy
+
+    # @param api_key [String, nil] main key; falls back to +NFE_API_KEY+.
+    # @param data_api_key [String, nil] data-services key; falls back to
+    #   +NFE_DATA_API_KEY+.
+    # @param environment [Symbol] +:production+ (default) or +:development+.
+    #   Reserved for future use — validated but currently has no effect on
+    #   endpoints/keys (prod vs. test is set in the account at app.nfe.io).
+    # @param timeout [Integer] read timeout in seconds (must be positive).
+    # @param open_timeout [Integer] connect timeout in seconds (must be positive).
+    # @param max_retries [Integer] retry budget (non-negative).
+    # @param logger [Object, nil] optional logger.
+    # @param user_agent_suffix [String, nil] appended to the SDK User-Agent.
+    # @param base_url_overrides [Hash{Symbol=>String}] per-family escape hatch.
+    # @param ca_file [String, nil] path to a CA bundle to ADD to the trust store.
+    # @param ca_path [String, nil] directory of CA certs to ADD to the trust store.
+    # @param proxy [String, URI, nil] passed through to +Net::HTTP+.
+    # @raise [Nfe::ConfigurationError] on invalid values.
+    def initialize(api_key: nil, data_api_key: nil, environment: :production,
+                   timeout: DEFAULT_TIMEOUT, open_timeout: DEFAULT_OPEN_TIMEOUT,
+                   max_retries: DEFAULT_MAX_RETRIES, logger: nil,
+                   user_agent_suffix: nil, base_url_overrides: {},
+                   ca_file: nil, ca_path: nil, proxy: nil)
+      @api_key = resolve_key(api_key, "NFE_API_KEY")
+      @data_api_key = resolve_key(data_api_key, "NFE_DATA_API_KEY")
+      @environment = environment
+      @timeout = timeout
+      @open_timeout = open_timeout
+      @max_retries = max_retries
+      @logger = logger
+      @user_agent_suffix = user_agent_suffix
+      @base_url_overrides = base_url_overrides || {}
+      @ca_file = ca_file
+      @ca_path = ca_path
+      @proxy = proxy
+
+      validate!
+    end
+
+    # Returns the base host for a product +family+. A per-family override (from
+    # +base_url_overrides+) wins; an unknown family falls back to the +:main+
+    # host as a safe default.
+    #
+    # @param family [Symbol, String] family or alias (snake_case accepted).
+    # @return [String]
+    def base_url_for(family)
+      canonical = canonical_family(family)
+      override = @base_url_overrides[canonical] || @base_url_overrides[family.to_sym]
+      override || HOSTS[canonical] || HOSTS.fetch(:main)
+    end
+
+    # Resolves the API key for a +family+ under the two-key model. Data families
+    # prefer +data_api_key+ and fall back to +api_key+; all other families use
+    # +api_key+.
+    #
+    # @param family [Symbol, String] family or alias (snake_case accepted).
+    # @return [String] the resolved key.
+    # @raise [Nfe::ConfigurationError] when no key resolves for the family.
+    def api_key_for(family)
+      canonical = canonical_family(family)
+      key = if DATA_FAMILIES.include?(canonical)
+              @data_api_key || @api_key
+            else
+              @api_key
+            end
+      return key unless key.nil? || key.empty?
+
+      raise Nfe::ConfigurationError,
+            "Nenhuma chave de API configurada para a família \"#{canonical}\". " \
+            "Informe api_key (ou data_api_key para famílias de dados)."
+    end
+
+    private
+
+    # Applies the ENV fallback: an explicit, non-empty argument always wins;
+    # otherwise the environment variable (when present) is adopted.
+    def resolve_key(explicit, env_name)
+      return explicit unless explicit.nil? || explicit.to_s.empty?
+
+      env_value = ENV.fetch(env_name, nil)
+      return env_value unless env_value.nil? || env_value.empty?
+
+      explicit
+    end
+
+    def validate!
+      unless VALID_ENVIRONMENTS.include?(@environment)
+        raise Nfe::ConfigurationError,
+              "environment inválido: #{@environment.inspect}. " \
+              "Use :production ou :development."
+      end
+
+      if blank?(@api_key) && blank?(@data_api_key)
+        raise Nfe::ConfigurationError,
+              "É necessário informar uma api_key (ou data_api_key). " \
+              "Defina o argumento ou a variável de ambiente NFE_API_KEY/NFE_DATA_API_KEY."
+      end
+
+      validate_positive!(:timeout, @timeout)
+      validate_positive!(:open_timeout, @open_timeout)
+
+      return unless !@max_retries.is_a?(Integer) || @max_retries.negative?
+
+      raise Nfe::ConfigurationError,
+            "max_retries deve ser um inteiro não negativo, recebido #{@max_retries.inspect}."
+    end
+
+    def validate_positive!(name, value)
+      return if value.is_a?(Numeric) && value.positive?
+
+      raise Nfe::ConfigurationError,
+            "#{name} deve ser um número positivo, recebido #{value.inspect}."
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.empty?
+    end
+
+    # Normalizes a family/alias into its canonical (hyphenated) family symbol.
+    def canonical_family(family)
+      normalized = family.to_s.tr("_", "-").to_sym
+      return normalized if HOSTS.key?(normalized)
+
+      FAMILY_ALIASES.fetch(normalized, normalized)
+    end
   end
-end
+end

data/lib/nfe/date_normalizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Nfe
+  # Normalizes date inputs to the canonical +YYYY-MM-DD+ string the lookup APIs
+  # expect. Accepts either an already-formatted ISO date string or a Ruby
+  # date/time object, and raises {Nfe::InvalidRequestError} (Portuguese-language
+  # message) on any malformed, out-of-range, or unsupported input.
+  module DateNormalizer
+    ISO_DATE = /\A\d{4}-\d{2}-\d{2}\z/
+
+    module_function
+
+    # @param input [String, Date, Time, DateTime]
+    # @return [String] the date formatted as +YYYY-MM-DD+.
+    # @raise [Nfe::InvalidRequestError] on bad format, out-of-range, or type.
+    def to_iso_date(input)
+      case input
+      when String then from_string(input)
+      when Date, Time, DateTime then input.strftime("%Y-%m-%d")
+      else
+        raise Nfe::InvalidRequestError, "data inválida: tipo não suportado (#{input.class})"
+      end
+    end
+
+    # @api private
+    def from_string(value)
+      raise Nfe::InvalidRequestError, "data inválida: use o formato YYYY-MM-DD" unless ISO_DATE.match?(value)
+
+      Date.iso8601(value).strftime("%Y-%m-%d")
+    rescue ArgumentError
+      raise Nfe::InvalidRequestError, "data inválida: #{value.inspect} está fora do intervalo válido"
+    end
+  end
+end

data/lib/nfe/error_factory.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Nfe
+  # Translates HTTP responses and network exceptions into the typed
+  # {Nfe::Error} hierarchy.
+  #
+  # The transport returns 4xx/5xx as {Nfe::Http::Response} objects (never
+  # raising); the resource layer feeds those to {.from_response} to obtain the
+  # right error class. Network failures the transport raised are normalized via
+  # {.from_network_error}.
+  #
+  # The extracted message echoes server-controlled input, so it is capped to a
+  # bounded length and stripped of control characters before reaching the
+  # error — an attacker-controlled body must not flood logs or inject terminal
+  # escape sequences.
+  module ErrorFactory
+    # Maximum length of a message extracted from a response body.
+    MAX_MESSAGE_LENGTH = 500
+
+    # Body keys searched (in order) for a human-readable message.
+    MESSAGE_KEYS = %w[message error detail details].freeze
+
+    # Body keys searched (in order) for a machine-readable error code.
+    ERROR_CODE_KEYS = %w[code errorCode error_code].freeze
+
+    # ASCII control characters (C0 range plus DEL) scrubbed from messages.
+    CONTROL_CHARS = /[\x00-\x1f\x7f]/
+
+    module_function
+
+    # Build the appropriate {Nfe::Error} subclass for an HTTP response.
+    #
+    # @param response [Nfe::Http::Response] status:, #header(name), body:
+    # @return [Nfe::Error]
+    def from_response(response)
+      status = response.status
+      parsed = parse_body(response.body)
+
+      message = extract_message(parsed) || "API request failed with HTTP #{status}"
+      error_code = extract_error_code(parsed)
+      request_id = response.header("x-request-id") || response.header("x-correlation-id")
+
+      kwargs = {
+        status_code: status,
+        request_id: request_id,
+        error_code: error_code,
+        response_body: response.body,
+        response_headers: response.headers
+      }
+
+      klass = error_class_for(status)
+      if klass == RateLimitError
+        RateLimitError.new(message, retry_after: extract_retry_after(response), **kwargs)
+      else
+        klass.new(message, **kwargs)
+      end
+    end
+
+    # Normalize a network exception raised by the transport.
+    #
+    # @param exception [Exception]
+    # @return [Nfe::ApiConnectionError]
+    def from_network_error(exception)
+      klass = timeout?(exception) ? TimeoutError : ApiConnectionError
+      error = klass.new(exception.message)
+      # Preserve the original exception as cause for debugging.
+      begin
+        raise error, error.message, cause: exception
+      rescue klass => e
+        e
+      end
+    end
+
+    # @api private
+    def error_class_for(status)
+      case status
+      when 401 then AuthenticationError
+      when 403 then AuthorizationError
+      when 404 then NotFoundError
+      when 409 then ConflictError
+      when 429 then RateLimitError
+      when 400..499 then InvalidRequestError
+      when 500..599 then ServerError
+      else
+        status >= 500 ? ServerError : InvalidRequestError
+      end
+    end
+
+    # @api private
+    def parse_body(body)
+      return nil if body.nil? || body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # @api private
+    def extract_message(parsed)
+      return nil unless parsed.is_a?(Hash)
+
+      raw = message_from_keys(parsed) || message_from_errors(parsed["errors"])
+      sanitize_message(raw)
+    end
+
+    # @api private
+    def message_from_keys(parsed)
+      MESSAGE_KEYS.each do |key|
+        value = parsed[key]
+        return value if value.is_a?(String) && !value.empty?
+      end
+      nil
+    end
+
+    # @api private
+    def message_from_errors(errors)
+      case errors
+      when String
+        errors
+      when Array
+        first = errors[0]
+        first.is_a?(Hash) ? first["message"] : first
+      end
+    end
+
+    # @api private
+    def sanitize_message(raw)
+      return nil if raw.nil?
+
+      # Scrub ASCII control characters (incl. ESC) so an attacker-controlled
+      # body cannot inject terminal escape sequences, then cap the length.
+      text = raw.to_s.gsub(CONTROL_CHARS, " ").strip
+      return nil if text.empty?
+
+      text.length > MAX_MESSAGE_LENGTH ? "#{text[0, MAX_MESSAGE_LENGTH]}..." : text
+    end
+
+    # @api private
+    def extract_error_code(parsed)
+      return nil unless parsed.is_a?(Hash)
+
+      ERROR_CODE_KEYS.each do |key|
+        value = parsed[key]
+        return value.to_s if value.is_a?(String) || value.is_a?(Integer)
+      end
+      nil
+    end
+
+    # @api private
+    def extract_retry_after(response)
+      value = response.header("retry-after")
+      return nil if value.nil?
+
+      Integer(value, 10)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    # @api private
+    def timeout?(exception)
+      timeout_class_names = %w[Net::OpenTimeout Net::ReadTimeout Timeout::Error]
+      ancestor_names = exception.class.ancestors.map(&:to_s)
+      timeout_class_names.intersect?(ancestor_names)
+    end
+  end
+end