didit-sdk 1.0.0

data/lib/didit/client.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "json"
+require "set"
+
+module Didit
+  # The Didit API client (docs/DESIGN.md section 6). Thread safe: create one per process
+  # and share it.
+  #
+  #   didit = Didit::Client.new                       # reads DIDIT_API_KEY
+  #   didit = Didit::Client.new(api_key: "...", organization_id: "...", application_id: "...")
+  #   session = didit.sessions.create(workflow_id: "...", vendor_data: "user-42")
+  class Client
+    include Resources::ClientMethods
+
+    DEFAULT_BASE_URL = Internal::Config::DEFAULT_BASE_URL
+    DEFAULT_ACCOUNT_BASE_URL = Internal::Config::DEFAULT_ACCOUNT_BASE_URL
+    DEFAULT_TIMEOUT = Internal::Config::DEFAULT_TIMEOUT
+    DEFAULT_MAX_RETRIES = Internal::Config::DEFAULT_MAX_RETRIES
+
+    @deprecation_lock = Mutex.new
+    @deprecation_warned = Set.new
+
+    class << self
+      # @api private
+      attr_reader :deprecation_lock, :deprecation_warned
+    end
+
+    # @param api_key [String, nil] defaults to the DIDIT_API_KEY environment variable
+    # @param organization_id [String, nil] defaults to DIDIT_ORGANIZATION_ID; needed by application-scoped methods
+    # @param application_id [String, nil] defaults to DIDIT_APPLICATION_ID; needed by application-scoped methods
+    # @param base_url [String] the verification API
+    # @param account_base_url [String] the account API (+didit.account+)
+    # @param account_token [String, nil] the Bearer token of +didit.account+ methods, from +didit.account.login+
+    # @param timeout [Numeric] seconds per attempt (connect, write and read each)
+    # @param max_retries [Integer] retries after the first attempt
+    # @param default_headers [Hash{String => String}] sent with every request
+    # @param logger [#debug, nil] receives debug lines; DIDIT_LOG=debug prints them to stderr instead
+    # @param http_client [#call, nil] returns a configured, not yet started +Net::HTTP+ for a URI
+    #   (proxies, CA bundle, ...); the SDK sets the timeouts and owns the connection
+    def initialize(api_key: nil, organization_id: nil, application_id: nil, base_url: nil,
+                   account_base_url: nil, account_token: nil, timeout: DEFAULT_TIMEOUT,
+                   max_retries: DEFAULT_MAX_RETRIES, default_headers: {}, logger: nil, http_client: nil)
+      config = Internal::Config.new(
+        api_key: api_key || ENV.fetch("DIDIT_API_KEY", nil),
+        organization_id: organization_id || ENV.fetch("DIDIT_ORGANIZATION_ID", nil),
+        application_id: application_id || ENV.fetch("DIDIT_APPLICATION_ID", nil),
+        base_url: base_url, account_base_url: account_base_url, account_token: account_token, timeout: timeout,
+        max_retries: max_retries, default_headers: default_headers, logger: logger, http_client: http_client
+      )
+      setup(config, Internal::Transport.new(http_client: config.http_client), raw: false)
+    end
+
+    # @return [String]
+    def base_url = @config.base_url
+    # @return [String]
+    def account_base_url = @config.account_base_url
+    # @return [String, nil]
+    def organization_id = @config.organization_id
+    # @return [String, nil]
+    def application_id = @config.application_id
+    # @return [Float]
+    def timeout = @config.timeout
+    # @return [Integer]
+    def max_retries = @config.max_retries
+
+    # A client with some options changed. It shares this client's connections.
+    # Passing nil clears an id or a token.
+    #
+    #   didit.with_options(timeout: 5, max_retries: 0).sessions.retrieve(id)
+    #   account = didit.with_options(account_token: login.access_token)
+    #
+    # @return [Didit::Client]
+    def with_options(api_key: OMIT, account_token: OMIT, organization_id: OMIT, application_id: OMIT, base_url: OMIT,
+                     account_base_url: OMIT, timeout: OMIT, max_retries: OMIT, default_headers: OMIT, logger: OMIT)
+      changes = {
+        api_key: api_key, account_token: account_token, organization_id: organization_id,
+        application_id: application_id, base_url: base_url, account_base_url: account_base_url, timeout: timeout,
+        max_retries: max_retries, default_headers: default_headers, logger: logger
+      }.reject { |_, value| value.equal?(OMIT) }
+      copy(@config.merge(changes), raw: @raw)
+    end
+
+    # A client whose methods return the {Didit::RawResponse} (status, headers, request id)
+    # instead of the parsed result; +#parse+ gives the result.
+    #
+    # @return [Didit::Client]
+    def with_raw_response
+      copy(@config, raw: true)
+    end
+
+    # Whether methods return {Didit::RawResponse}.
+    def raw_response?
+      @raw
+    end
+
+    # Closes the idle connections (they also close by themselves).
+    def close
+      @transport.close
+    end
+
+    def inspect
+      "#<Didit::Client base_url=#{base_url.inspect} organization_id=#{organization_id.inspect} " \
+        "application_id=#{application_id.inspect} api_key=#{@config.api_key ? "[set]" : "nil"}>"
+    end
+    alias to_s inspect
+
+    # Sends a request to any API path; the generated resource methods call this.
+    #
+    # @param http_method [Symbol] :get, :post, :put, :patch or :delete
+    # @param path [String] a path with +{name}+ placeholders filled from +path_params+
+    # @param response [Object] the type of the result: a Didit::Model subclass, +[:array, type]+,
+    #   +:binary+, a Hash of types by status, or nil for no content
+    # @param page [Object] the item type of a paginated list (returns a {Didit::Page})
+    # @return [Object] the typed result, or a {Didit::RawResponse} from {#with_raw_response}
+    def request(http_method, path, path_params: {}, query: nil, body: nil, encoding: :json, file_fields: [],
+                headers: {}, auth: :api_key, api: :verification, scope: nil, response: nil, page: nil,
+                accept: "application/json", request_options: nil, &block)
+      opts = Internal::Request.options(@config, request_options)
+      prepared = Internal::Request.prepare(
+        @config, http_method, path, opts,
+        path_params: path_params, query: query, body: body, encoding: encoding, file_fields: file_fields,
+        headers: headers, auth: auth, api: api, scope: scope, accept: accept
+      )
+      stream = response == :binary ? block : nil
+      result = Internal::Request.perform(@config, @transport, prepared, &stream)
+      parser = -> { parse(prepared, result.response, response, page) }
+      return parser.call unless @raw
+
+      raw = check_status(prepared, result.response)
+      RawResponse.new(status: raw.status, headers: raw.headers, body: raw.body,
+                      retries_taken: result.retries_taken, elapsed: result.elapsed, parser: parser)
+    end
+
+    # Fetches a page's +next+ link with the request options of the first page.
+    # @api private
+    def fetch_page(prepared, uri, item, seen)
+      next_request = prepared.dup
+      next_request.uri = uri
+      next_request.http_method = :get
+      next_request.body = nil
+      result = Internal::Request.perform(@config, @transport, next_request)
+      response = check_status(next_request, result.response)
+      Page.new(client: self, prepared: next_request, item: item, data: parse_json(next_request, response),
+               seen: seen)
+    end
+
+    # Warns once per process that a deprecated method was called (Ruby's :deprecated warning category).
+    # @api private
+    def deprecated(name, note)
+      first = Client.deprecation_lock.synchronize { Client.deprecation_warned.add?(name) }
+      Kernel.warn("Didit: #{name} is deprecated. #{note}", category: :deprecated) if first
+      nil
+    end
+
+    protected
+
+    attr_reader :config, :transport
+
+    def setup(config, transport, raw:)
+      @config = config
+      @transport = transport
+      @raw = raw
+      self
+    end
+
+    private
+
+    def copy(config, raw:)
+      same = config.http_client.equal?(@config.http_client)
+      transport = same ? @transport : Internal::Transport.new(http_client: config.http_client)
+      Client.allocate.send(:setup, config, transport, raw: raw)
+    end
+
+    def parse(prepared, response, type, page)
+      check_status(prepared, response)
+      return Page.new(client: self, prepared: prepared, item: page, data: parse_json(prepared, response)) if page
+      return response.body if type == :binary
+      return nil if type.nil?
+
+      type = type.fetch(response.status) { type.values.first } if type.is_a?(Hash)
+      return nil if response.status == 204 || response.body.nil? || response.body.empty?
+
+      Model.coerce(parse_json(prepared, response), type)
+    end
+
+    def check_status(prepared, response)
+      return response if response.status.between?(200, 299)
+
+      raise Internal::Errors.status_error(status: response.status, headers: response.headers,
+                                          raw_body: response.body, redact: prepared.redact)
+    end
+
+    def parse_json(prepared, response)
+      text = response.body.to_s.dup.force_encoding(Encoding::UTF_8)
+      begin
+        raise JSON::ParserError, "invalid UTF-8" unless text.valid_encoding?
+
+        return JSON.parse(text)
+      rescue JSON::ParserError
+        nil
+      end
+      raise APIResponseValidationError.new(
+        "Expected a JSON response from #{prepared.http_method.to_s.upcase} #{prepared.uri.path}, got " \
+        "#{response.headers["content-type"] || "no content type"}.",
+        status: response.status, headers: response.headers,
+        body: Internal::Util.redact(text.scrub, prepared.redact), request_id: Internal::Util.request_id(response.headers)
+      )
+    end
+  end
+end

data/lib/didit/errors.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Didit
+  # Base class of every error the SDK raises (docs/DESIGN.md section 7).
+  class DiditError < StandardError
+  end
+
+  # The client is missing something it needs (an API key, an account token, the
+  # organization or application id, a webhook secret) or an argument is invalid.
+  # Raised before any request is sent.
+  class ConfigurationError < DiditError
+  end
+
+  # No response arrived: the connection failed or broke.
+  class APIConnectionError < DiditError
+    # @return [String, nil] the HTTP method of the request
+    attr_reader :http_method
+    # @return [String, nil] the request URL without its query string
+    attr_reader :url
+
+    def initialize(message = "Connection error.", http_method: nil, url: nil)
+      super(message)
+      @http_method = http_method
+      @url = url
+    end
+  end
+
+  # The request timed out before a response arrived.
+  class APITimeoutError < APIConnectionError
+    def initialize(message = "Request timed out.", http_method: nil, url: nil)
+      super
+    end
+  end
+
+  # Shared readers of the errors that carry an HTTP response.
+  module ResponseDetails
+    # @return [Integer] the HTTP status code
+    attr_reader :status
+    # @return [Hash{String => String}] response headers, names in lower case
+    attr_reader :headers
+    # @return [Object, nil] the parsed JSON body, else the text, else nil
+    attr_reader :body
+    # @return [String, nil] the request id the API returned, if any
+    attr_reader :request_id
+
+    # @return [Integer] alias of {#status}
+    def status_code
+      status
+    end
+  end
+
+  # A successful response could not be read as the documented content (for
+  # example HTML where JSON was expected, or a pagination link that loops).
+  class APIResponseValidationError < DiditError
+    include ResponseDetails
+
+    def initialize(message, status:, headers: {}, body: nil, request_id: nil)
+      super(message)
+      @status = status
+      @headers = headers
+      @body = body
+      @request_id = request_id
+    end
+  end
+
+  # The API answered with a non-2xx status.
+  class APIStatusError < DiditError
+    include ResponseDetails
+
+    def initialize(message, status:, headers: {}, body: nil, request_id: nil)
+      super(request_id ? "#{message} (request id #{request_id})" : message)
+      @status = status
+      @headers = headers
+      @body = body
+      @request_id = request_id
+    end
+  end
+
+  # HTTP 400.
+  class BadRequestError < APIStatusError
+  end
+
+  # HTTP 401.
+  class AuthenticationError < APIStatusError
+  end
+
+  # HTTP 403.
+  class PermissionDeniedError < APIStatusError
+  end
+
+  # HTTP 404.
+  class NotFoundError < APIStatusError
+  end
+
+  # HTTP 409.
+  class ConflictError < APIStatusError
+  end
+
+  # HTTP 422.
+  class UnprocessableEntityError < APIStatusError
+  end
+
+  # HTTP 429.
+  class RateLimitError < APIStatusError
+  end
+
+  # HTTP 5xx.
+  class InternalServerError < APIStatusError
+  end
+
+  # A webhook delivery failed verification (docs/DESIGN.md section 9.3).
+  #
+  # {#reason} is machine readable: +:missing_signature+, +:invalid_signature+,
+  # +:missing_timestamp+, +:timestamp_mismatch+, +:timestamp_out_of_tolerance+
+  # or +:invalid_payload+.
+  class WebhookVerificationError < DiditError
+    REASONS = %i[
+      missing_signature invalid_signature missing_timestamp
+      timestamp_mismatch timestamp_out_of_tolerance invalid_payload
+    ].freeze
+
+    # @return [Symbol]
+    attr_reader :reason
+
+    def initialize(reason, message)
+      super(message)
+      @reason = reason
+    end
+  end
+
+  # An Authentication access token or ID token failed verification: do not trust
+  # any of its claims (docs/DESIGN.md section 10). The message never contains the token.
+  #
+  # {#reason} is machine readable: +:malformed+, +:unsupported_algorithm+,
+  # +:invalid_type+, +:unknown_key+, +:invalid_signature+, +:invalid_issuer+,
+  # +:invalid_audience+, +:expired+, +:not_yet_valid+, +:invalid_issued_at+,
+  # +:invalid_nonce+ or +:missing_claim+.
+  class TokenVerificationError < DiditError
+    REASONS = %i[
+      malformed unsupported_algorithm invalid_type unknown_key invalid_signature
+      invalid_issuer invalid_audience expired not_yet_valid invalid_issued_at
+      invalid_nonce missing_claim
+    ].freeze
+
+    # @return [Symbol]
+    attr_reader :reason
+
+    def initialize(reason, message)
+      super(message)
+      @reason = reason
+    end
+  end
+end

data/lib/didit/file_part.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Didit
+  # A file to upload (docs/DESIGN.md section 8), with an optional file name and content type.
+  #
+  # Upload arguments accept a +Pathname+ (read from disk), an +IO+ such as +File+ or
+  # +StringIO+ (read once), a +String+ holding the file's bytes, or a FilePart:
+  #
+  #   didit.id_verification.verify(front_image: Pathname("passport.jpg"))
+  #   didit.id_verification.verify(front_image: File.open("passport.jpg", "rb"))
+  #   didit.id_verification.verify(front_image: Didit::FilePart.new(bytes, filename: "front.png"))
+  class FilePart
+    # File types by extension. A fixed table, so uploads do not depend on the host's MIME database.
+    CONTENT_TYPES = {
+      ".bmp" => "image/bmp", ".csv" => "text/csv", ".gif" => "image/gif", ".heic" => "image/heic",
+      ".heif" => "image/heif", ".jpeg" => "image/jpeg", ".jpg" => "image/jpeg", ".json" => "application/json",
+      ".mov" => "video/quicktime", ".mp4" => "video/mp4", ".pdf" => "application/pdf", ".png" => "image/png",
+      ".tif" => "image/tiff", ".tiff" => "image/tiff", ".txt" => "text/plain", ".webm" => "video/webm",
+      ".webp" => "image/webp", ".zip" => "application/zip"
+    }.freeze
+    DEFAULT_CONTENT_TYPE = "application/octet-stream"
+
+    # @return [String, Pathname, IO]
+    attr_reader :content
+    # @return [String, nil]
+    attr_reader :filename
+
+    # @param content [String, Pathname, IO] the bytes, a path to read, or an IO to read
+    # @param filename [String, nil] defaults to the path's base name
+    # @param content_type [String, nil] defaults to a type guessed from the file name
+    def initialize(content, filename: nil, content_type: nil)
+      unless content.is_a?(String) || content.is_a?(Pathname) || content.respond_to?(:read)
+        raise ConfigurationError, "A file must be a Pathname, an IO or a String of bytes, got #{content.class}."
+      end
+
+      @content = content
+      @filename = filename || FilePart.default_filename(content)
+      @content_type = content_type
+    end
+
+    # A FilePart for a path on disk.
+    def self.from_path(path, filename: nil, content_type: nil)
+      new(Pathname(path), filename: filename, content_type: content_type)
+    end
+
+    # Wraps an upload argument; +field+ names the file when nothing else does.
+    # @api private
+    def self.wrap(value, field)
+      part = value.is_a?(FilePart) ? value : new(value)
+      part.filename ? part : new(part.content, filename: field, content_type: part.content_type)
+    end
+
+    # @api private
+    def self.default_filename(content)
+      path = if content.is_a?(Pathname)
+               content
+             elsif content.respond_to?(:path) && content.path
+               content.path
+             end
+      path ? File.basename(path.to_s) : nil
+    end
+
+    # @return [String]
+    def content_type
+      @content_type || CONTENT_TYPES.fetch(File.extname(filename.to_s).downcase, DEFAULT_CONTENT_TYPE)
+    end
+
+    # The file's bytes (an IO is read once, from its current position).
+    # @return [String]
+    def read
+      data = case content
+             when Pathname then File.binread(content.to_s)
+             when String then content
+             else content.read
+             end
+      data.to_s.b
+    end
+
+    def inspect
+      "#<Didit::FilePart filename=#{filename.inspect} content_type=#{content_type.inspect}>"
+    end
+  end
+end

data/lib/didit/internal/config.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Didit
+  module Internal
+    # The resolved, immutable options of a Didit::Client (docs/DESIGN.md section 6).
+    # @api private
+    class Config
+      DEFAULT_BASE_URL = "https://verification.didit.me"
+      DEFAULT_ACCOUNT_BASE_URL = "https://apx.didit.me/auth/v2"
+      DEFAULT_TIMEOUT = 60.0
+      DEFAULT_MAX_RETRIES = 2
+      FIELDS = %i[
+        api_key account_token organization_id application_id base_url account_base_url timeout max_retries
+        default_headers logger http_client
+      ].freeze
+
+      attr_reader(*FIELDS)
+
+      def initialize(**options)
+        unknown = options.keys - FIELDS
+        raise ConfigurationError, "Unknown client options #{unknown.map(&:inspect).join(", ")}." unless unknown.empty?
+
+        @api_key, @account_token, @organization_id, @application_id =
+          options.values_at(:api_key, :account_token, :organization_id, :application_id).map { |v| present(v) }
+        @base_url = Config.check_url(:base_url, options[:base_url] || DEFAULT_BASE_URL)
+        @account_base_url = Config.check_url(:account_base_url, options[:account_base_url] || DEFAULT_ACCOUNT_BASE_URL)
+        @timeout = Config.check_timeout(options.fetch(:timeout, DEFAULT_TIMEOUT))
+        @max_retries = Config.check_max_retries(options.fetch(:max_retries, DEFAULT_MAX_RETRIES))
+        @default_headers = check_headers(options[:default_headers] || {})
+        @logger = options[:logger]
+        @http_client = check_http_client(options[:http_client])
+        freeze
+      end
+
+      # A copy with +changes+ applied; a nil value clears an id or token.
+      def merge(changes)
+        Config.new(**FIELDS.to_h { |f| [f, public_send(f)] }, **changes)
+      end
+
+      def self.check_url(name, url)
+        uri = URI(url.to_s)
+        unless %w[http https].include?(uri.scheme) && uri.host && !uri.host.empty? && uri.query.nil? &&
+               uri.fragment.nil? && uri.userinfo.nil?
+          raise ConfigurationError, "#{name} must be an absolute http(s) URL without query or credentials, " \
+                                    "got #{url.to_s.inspect}."
+        end
+
+        uri.to_s.sub(%r{/+\z}, "")
+      rescue URI::InvalidURIError
+        raise ConfigurationError, "#{name} must be an absolute http(s) URL, got #{url.to_s.inspect}."
+      end
+
+      def self.check_timeout(value)
+        unless value.is_a?(Numeric) && value.positive? && value.finite?
+          raise ConfigurationError, "timeout must be a positive number of seconds, got #{value.inspect}."
+        end
+
+        (_ = value).to_f
+      end
+
+      def self.check_max_retries(value)
+        unless value.is_a?(Integer) && !value.negative?
+          raise ConfigurationError, "max_retries must be an Integer of 0 or more, got #{value.inspect}."
+        end
+
+        value
+      end
+
+      private
+
+      def present(value)
+        return nil if value.nil?
+
+        text = value.to_s.strip
+        text.empty? ? nil : text
+      end
+
+      def check_headers(headers)
+        raise ConfigurationError, "default_headers must be a Hash." unless headers.is_a?(Hash)
+
+        headers.to_h { |k, v| [k.to_s, v&.to_s] }.freeze
+      end
+
+      def check_http_client(value)
+        return nil if value.nil?
+        return value if value.respond_to?(:call)
+
+        raise ConfigurationError, "http_client must respond to call(uri) and return a Net::HTTP."
+      end
+    end
+  end
+end

data/lib/didit/internal/errors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Didit
+  module Internal
+    # Builds {Didit::APIStatusError} subclasses from responses.
+    # @api private
+    module Errors
+      STATUS_ERRORS = {
+        400 => BadRequestError,
+        401 => AuthenticationError,
+        403 => PermissionDeniedError,
+        404 => NotFoundError,
+        409 => ConflictError,
+        422 => UnprocessableEntityError,
+        429 => RateLimitError
+      }.freeze
+      DETAIL_KEYS = %w[detail message error error_description].freeze
+
+      module_function
+
+      # @param status [Integer]
+      # @param headers [Hash{String => String}] names in lower case
+      # @param raw_body [String, nil]
+      # @param redact [Array<String, nil>] secrets to replace with "[redacted]" in the message and body
+      # @return [Didit::APIStatusError]
+      def status_error(status:, headers:, raw_body:, redact: [])
+        body = Util.redact(parse_body(raw_body), redact)
+        message = Util.redact(message_for(status, body), redact)
+        klass = STATUS_ERRORS.fetch(status) { status >= 500 ? InternalServerError : APIStatusError }
+        klass.new(message, status: status, headers: headers, body: body, request_id: Util.request_id(headers))
+      end
+
+      # The parsed JSON body, else the text, else nil.
+      def parse_body(raw_body)
+        return nil if raw_body.nil? || raw_body.empty?
+
+        text = raw_body.dup.force_encoding(Encoding::UTF_8)
+        text = text.scrub unless text.valid_encoding?
+        JSON.parse(text)
+      rescue JSON::ParserError
+        text
+      end
+
+      def message_for(status, body)
+        detail = detail_of(body)
+        detail ? "HTTP #{status}: #{detail}" : "HTTP #{status}"
+      end
+
+      def detail_of(body)
+        case body
+        when Hash then hash_detail(body)
+        when Array then body.join("; ") if !body.empty? && body.all?(String)
+        when String
+          text = body.strip
+          text unless text.empty? || text.length > 500
+        end
+      end
+
+      def hash_detail(body)
+        error = body["error"]
+        description = body["error_description"]
+        # OAuth 2.0 errors (RFC 6749 section 5.2): the code and what it means.
+        return "#{error}: #{description}" if present?(error) && present?(description)
+
+        DETAIL_KEYS.each { |key| return body[key] if present?(body[key]) }
+        parts = body.first(5).filter_map do |key, value|
+          if value.is_a?(Array) && value.first.is_a?(String)
+            "#{key}: #{value.first}"
+          elsif value.is_a?(String)
+            "#{key}: #{value}"
+          end
+        end
+        parts.join("; ") unless parts.empty?
+      end
+
+      def present?(value)
+        value.is_a?(String) && !value.empty?
+      end
+    end
+  end
+end

data/lib/didit/internal/log.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Didit
+  module Internal
+    # Debug logging (docs/DESIGN.md section 6): method, path, status, duration and request
+    # id, never bodies, headers or query strings.
+    # @api private
+    module Log
+      module_function
+
+      def response(config, prepared, response, elapsed)
+        return unless enabled?(config)
+
+        request_id = Util.request_id(response.headers) || "-"
+        write(config, format("%<method>s %<path>s -> %<status>d in %<ms>.0f ms (request id %<id>s)",
+                             method: prepared.http_method.to_s.upcase, path: prepared.uri.path,
+                             status: response.status, ms: elapsed * 1000, id: request_id))
+      end
+
+      def retry(config, prepared, reason, delay, retries_left)
+        return unless enabled?(config)
+
+        write(config, format("%<method>s %<path>s: %<reason>s; retrying in %<delay>.2f s (%<left>d retries left)",
+                             method: prepared.http_method.to_s.upcase, path: prepared.uri.path, reason: reason,
+                             delay: delay, left: retries_left))
+      end
+
+      def enabled?(config)
+        !config.logger.nil? || Util.debug_from_env?
+      end
+
+      def write(config, message)
+        if config.logger
+          config.logger.debug("didit") { message }
+        else
+          $stderr.puts("[didit] #{message}") # rubocop:disable Style/StderrPuts
+        end
+      end
+    end
+  end
+end