orb-billing 0.1.0.pre.alpha.33

data/lib/orb/resources/top_level.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Orb
+  module Resources
+    class TopLevel
+      # This endpoint allows you to test your connection to the Orb API and check the
+      #   validity of your API key, passed in the Authorization header. This is
+      #   particularly useful for checking that your environment is set up properly, and
+      #   is a great choice for connectors and integrations.
+      #
+      #   This API does not have any side-effects or return any Orb resources.
+      #
+      # @overload ping(request_options: {})
+      #
+      # @param request_options [Orb::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Orb::Models::TopLevelPingResponse]
+      #
+      # @see Orb::Models::TopLevelPingParams
+      def ping(params = {})
+        @client.request(
+          method: :get,
+          path: "ping",
+          model: Orb::Models::TopLevelPingResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Orb::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/orb/transport/base_client.rb

@@ -0,0 +1,459 @@
+# frozen_string_literal: true
+
+module Orb
+  module Transport
+    # @api private
+    #
+    # @abstract
+    class BaseClient
+      # from whatwg fetch spec
+      MAX_REDIRECTS = 20
+
+      # rubocop:disable Style/MutableConstant
+      PLATFORM_HEADERS =
+        {
+          "x-stainless-arch" => Orb::Util.arch,
+          "x-stainless-lang" => "ruby",
+          "x-stainless-os" => Orb::Util.os,
+          "x-stainless-package-version" => Orb::VERSION,
+          "x-stainless-runtime" => ::RUBY_ENGINE,
+          "x-stainless-runtime-version" => ::RUBY_ENGINE_VERSION
+        }
+      # rubocop:enable Style/MutableConstant
+
+      class << self
+        # @api private
+        #
+        # @param req [Hash{Symbol=>Object}]
+        #
+        # @raise [ArgumentError]
+        def validate!(req)
+          keys = [:method, :path, :query, :headers, :body, :unwrap, :page, :stream, :model, :options]
+          case req
+          in Hash
+            req.each_key do |k|
+              unless keys.include?(k)
+                raise ArgumentError.new("Request `req` keys must be one of #{keys}, got #{k.inspect}")
+              end
+            end
+          else
+            raise ArgumentError.new("Request `req` must be a Hash or RequestOptions, got #{req.inspect}")
+          end
+        end
+
+        # @api private
+        #
+        # @param status [Integer]
+        # @param headers [Hash{String=>String}, Net::HTTPHeader]
+        #
+        # @return [Boolean]
+        def should_retry?(status, headers:)
+          coerced = Orb::Util.coerce_boolean(headers["x-should-retry"])
+          case [coerced, status]
+          in [true | false, _]
+            coerced
+          in [_, 408 | 409 | 429 | (500..)]
+            # retry on:
+            # 408: timeouts
+            # 409: locks
+            # 429: rate limits
+            # 500+: unknown errors
+            true
+          else
+            false
+          end
+        end
+
+        # @api private
+        #
+        # @param request [Hash{Symbol=>Object}] .
+        #
+        #   @option request [Symbol] :method
+        #
+        #   @option request [URI::Generic] :url
+        #
+        #   @option request [Hash{String=>String}] :headers
+        #
+        #   @option request [Object] :body
+        #
+        #   @option request [Integer] :max_retries
+        #
+        #   @option request [Float] :timeout
+        #
+        # @param status [Integer]
+        #
+        # @param response_headers [Hash{String=>String}, Net::HTTPHeader]
+        #
+        # @return [Hash{Symbol=>Object}]
+        def follow_redirect(request, status:, response_headers:)
+          method, url, headers = request.fetch_values(:method, :url, :headers)
+          location =
+            Kernel.then do
+              URI.join(url, response_headers["location"])
+            rescue ArgumentError
+              message = "Server responded with status #{status} but no valid location header."
+              raise Orb::Errors::APIConnectionError.new(url: url, message: message)
+            end
+
+          request = {**request, url: location}
+
+          case [url.scheme, location.scheme]
+          in ["https", "http"]
+            message = "Tried to redirect to a insecure URL"
+            raise Orb::Errors::APIConnectionError.new(url: url, message: message)
+          else
+            nil
+          end
+
+          # from whatwg fetch spec
+          case [status, method]
+          in [301 | 302, :post] | [303, _]
+            drop = %w[content-encoding content-language content-length content-location content-type]
+            request = {
+              **request,
+              method: method == :head ? :head : :get,
+              headers: headers.except(*drop),
+              body: nil
+            }
+          else
+          end
+
+          # from undici
+          if Orb::Util.uri_origin(url) != Orb::Util.uri_origin(location)
+            drop = %w[authorization cookie host proxy-authorization]
+            request = {**request, headers: request.fetch(:headers).except(*drop)}
+          end
+
+          request
+        end
+
+        # @api private
+        #
+        # @param status [Integer, Orb::Errors::APIConnectionError]
+        # @param stream [Enumerable, nil]
+        def reap_connection!(status, stream:)
+          case status
+          in (..199) | (300..499)
+            stream&.each { next }
+          in Orb::Errors::APIConnectionError | (500..)
+            Orb::Util.close_fused!(stream)
+          else
+          end
+        end
+      end
+
+      # @api private
+      # @return [Orb::Transport::PooledNetRequester]
+      attr_accessor :requester
+
+      # @api private
+      #
+      # @param base_url [String]
+      # @param timeout [Float]
+      # @param max_retries [Integer]
+      # @param initial_retry_delay [Float]
+      # @param max_retry_delay [Float]
+      # @param headers [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}]
+      # @param idempotency_header [String, nil]
+      def initialize(
+        base_url:,
+        timeout: 0.0,
+        max_retries: 0,
+        initial_retry_delay: 0.0,
+        max_retry_delay: 0.0,
+        headers: {},
+        idempotency_header: nil
+      )
+        @requester = Orb::Transport::PooledNetRequester.new
+        @headers = Orb::Util.normalized_headers(
+          self.class::PLATFORM_HEADERS,
+          {
+            "accept" => "application/json",
+            "content-type" => "application/json"
+          },
+          headers
+        )
+        @base_url = Orb::Util.parse_uri(base_url)
+        @idempotency_header = idempotency_header&.to_s&.downcase
+        @max_retries = max_retries
+        @timeout = timeout
+        @initial_retry_delay = initial_retry_delay
+        @max_retry_delay = max_retry_delay
+      end
+
+      # @api private
+      #
+      # @return [Hash{String=>String}]
+      private def auth_headers = {}
+
+      # @api private
+      #
+      # @return [String]
+      private def generate_idempotency_key = "stainless-ruby-retry-#{SecureRandom.uuid}"
+
+      # @api private
+      #
+      # @param req [Hash{Symbol=>Object}] .
+      #
+      #   @option req [Symbol] :method
+      #
+      #   @option req [String, Array<String>] :path
+      #
+      #   @option req [Hash{String=>Array<String>, String, nil}, nil] :query
+      #
+      #   @option req [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}, nil] :headers
+      #
+      #   @option req [Object, nil] :body
+      #
+      #   @option req [Symbol, nil] :unwrap
+      #
+      #   @option req [Class, nil] :page
+      #
+      #   @option req [Class, nil] :stream
+      #
+      #   @option req [Orb::Type::Converter, Class, nil] :model
+      #
+      # @param opts [Hash{Symbol=>Object}] .
+      #
+      #   @option opts [String, nil] :idempotency_key
+      #
+      #   @option opts [Hash{String=>Array<String>, String, nil}, nil] :extra_query
+      #
+      #   @option opts [Hash{String=>String, nil}, nil] :extra_headers
+      #
+      #   @option opts [Object, nil] :extra_body
+      #
+      #   @option opts [Integer, nil] :max_retries
+      #
+      #   @option opts [Float, nil] :timeout
+      #
+      # @return [Hash{Symbol=>Object}]
+      private def build_request(req, opts)
+        method, uninterpolated_path = req.fetch_values(:method, :path)
+
+        path = Orb::Util.interpolate_path(uninterpolated_path)
+
+        query = Orb::Util.deep_merge(req[:query].to_h, opts[:extra_query].to_h)
+
+        headers = Orb::Util.normalized_headers(
+          @headers,
+          auth_headers,
+          req[:headers].to_h,
+          opts[:extra_headers].to_h
+        )
+
+        if @idempotency_header &&
+           !headers.key?(@idempotency_header) &&
+           !Net::HTTP::IDEMPOTENT_METHODS_.include?(method.to_s.upcase)
+          headers[@idempotency_header] = opts.fetch(:idempotency_key) { generate_idempotency_key }
+        end
+
+        unless headers.key?("x-stainless-retry-count")
+          headers["x-stainless-retry-count"] = "0"
+        end
+
+        timeout = opts.fetch(:timeout, @timeout).to_f.clamp((0..))
+        unless headers.key?("x-stainless-timeout") || timeout.zero?
+          headers["x-stainless-timeout"] = timeout.to_s
+        end
+
+        headers.reject! { |_, v| v.to_s.empty? }
+
+        body =
+          case method
+          in :get | :head | :options | :trace
+            nil
+          else
+            Orb::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
+          end
+
+        headers, encoded = Orb::Util.encode_content(headers, body)
+        {
+          method: method,
+          url: Orb::Util.join_parsed_uri(@base_url, {**req, path: path, query: query}),
+          headers: headers,
+          body: encoded,
+          max_retries: opts.fetch(:max_retries, @max_retries),
+          timeout: timeout
+        }
+      end
+
+      # @api private
+      #
+      # @param headers [Hash{String=>String}]
+      # @param retry_count [Integer]
+      #
+      # @return [Float]
+      private def retry_delay(headers, retry_count:)
+        # Non-standard extension
+        span = Float(headers["retry-after-ms"], exception: false)&.then { _1 / 1000 }
+        return span if span
+
+        retry_header = headers["retry-after"]
+        return span if (span = Float(retry_header, exception: false))
+
+        span = retry_header&.then do
+          Time.httpdate(_1) - Time.now
+        rescue ArgumentError
+          nil
+        end
+        return span if span
+
+        scale = retry_count**2
+        jitter = 1 - (0.25 * rand)
+        (@initial_retry_delay * scale * jitter).clamp(0, @max_retry_delay)
+      end
+
+      # @api private
+      #
+      # @param request [Hash{Symbol=>Object}] .
+      #
+      #   @option request [Symbol] :method
+      #
+      #   @option request [URI::Generic] :url
+      #
+      #   @option request [Hash{String=>String}] :headers
+      #
+      #   @option request [Object] :body
+      #
+      #   @option request [Integer] :max_retries
+      #
+      #   @option request [Float] :timeout
+      #
+      # @param redirect_count [Integer]
+      #
+      # @param retry_count [Integer]
+      #
+      # @param send_retry_header [Boolean]
+      #
+      # @raise [Orb::Errors::APIError]
+      # @return [Array(Integer, Net::HTTPResponse, Enumerable)]
+      private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout)
+        input = {**request.except(:timeout), deadline: Orb::Util.monotonic_secs + timeout}
+
+        if send_retry_header
+          headers["x-stainless-retry-count"] = retry_count.to_s
+        end
+
+        begin
+          status, response, stream = @requester.execute(input)
+        rescue Orb::APIConnectionError => e
+          status = e
+        end
+
+        case status
+        in ..299
+          [status, response, stream]
+        in 300..399 if redirect_count >= self.class::MAX_REDIRECTS
+          self.class.reap_connection!(status, stream: stream)
+
+          message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects."
+          raise Orb::Errors::APIConnectionError.new(url: url, message: message)
+        in 300..399
+          self.class.reap_connection!(status, stream: stream)
+
+          request = self.class.follow_redirect(request, status: status, response_headers: response)
+          send_request(
+            request,
+            redirect_count: redirect_count + 1,
+            retry_count: retry_count,
+            send_retry_header: send_retry_header
+          )
+        in Orb::APIConnectionError if retry_count >= max_retries
+          raise status
+        in (400..) if retry_count >= max_retries || !self.class.should_retry?(status, headers: response)
+          decoded = Kernel.then do
+            Orb::Util.decode_content(response, stream: stream, suppress_error: true)
+          ensure
+            self.class.reap_connection!(status, stream: stream)
+          end
+
+          raise Orb::Errors::APIStatusError.for(
+            url: url,
+            status: status,
+            body: decoded,
+            request: nil,
+            response: response
+          )
+        in (400..) | Orb::Errors::APIConnectionError
+          self.class.reap_connection!(status, stream: stream)
+
+          delay = retry_delay(response, retry_count: retry_count)
+          sleep(delay)
+
+          send_request(
+            request,
+            redirect_count: redirect_count,
+            retry_count: retry_count + 1,
+            send_retry_header: send_retry_header
+          )
+        end
+      end
+
+      # Execute the request specified by `req`. This is the method that all resource
+      #   methods call into.
+      #
+      # @param req [Hash{Symbol=>Object}] .
+      #
+      #   @option req [Symbol] :method
+      #
+      #   @option req [String, Array<String>] :path
+      #
+      #   @option req [Hash{String=>Array<String>, String, nil}, nil] :query
+      #
+      #   @option req [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}, nil] :headers
+      #
+      #   @option req [Object, nil] :body
+      #
+      #   @option req [Symbol, nil] :unwrap
+      #
+      #   @option req [Class, nil] :page
+      #
+      #   @option req [Class, nil] :stream
+      #
+      #   @option req [Orb::Type::Converter, Class, nil] :model
+      #
+      #   @option req [Orb::RequestOptions, Hash{Symbol=>Object}, nil] :options
+      #
+      # @raise [Orb::Errors::APIError]
+      # @return [Object]
+      def request(req)
+        self.class.validate!(req)
+        model = req.fetch(:model) { Orb::Unknown }
+        opts = req[:options].to_h
+        Orb::RequestOptions.validate!(opts)
+        request = build_request(req.except(:options), opts)
+        url = request.fetch(:url)
+
+        # Don't send the current retry count in the headers if the caller modified the header defaults.
+        send_retry_header = request.fetch(:headers)["x-stainless-retry-count"] == "0"
+        status, response, stream = send_request(
+          request,
+          redirect_count: 0,
+          retry_count: 0,
+          send_retry_header: send_retry_header
+        )
+
+        decoded = Orb::Util.decode_content(response, stream: stream)
+        case req
+        in { stream: Class => st }
+          st.new(model: model, url: url, status: status, response: response, stream: decoded)
+        in { page: Class => page }
+          page.new(client: self, req: req, headers: response, page_data: decoded)
+        else
+          unwrapped = Orb::Util.dig(decoded, req[:unwrap])
+          Orb::Type::Converter.coerce(model, unwrapped)
+        end
+      end
+
+      # @return [String]
+      def inspect
+        # rubocop:disable Layout/LineLength
+        base_url = Orb::Util.unparse_uri(@base_url)
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} base_url=#{base_url} max_retries=#{@max_retries} timeout=#{@timeout}>"
+        # rubocop:enable Layout/LineLength
+      end
+    end
+  end
+end

data/lib/orb/transport/pooled_net_requester.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Orb
+  module Transport
+    # @api private
+    class PooledNetRequester
+      # from the golang stdlib
+      #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+      KEEP_ALIVE_TIMEOUT = 30
+
+      class << self
+        # @api private
+        #
+        # @param url [URI::Generic]
+        #
+        # @return [Net::HTTP]
+        def connect(url)
+          port =
+            case [url.port, url.scheme]
+            in [Integer, _]
+              url.port
+            in [nil, "http" | "ws"]
+              Net::HTTP.http_default_port
+            in [nil, "https" | "wss"]
+              Net::HTTP.https_default_port
+            end
+
+          Net::HTTP.new(url.host, port).tap do
+            _1.use_ssl = %w[https wss].include?(url.scheme)
+            _1.max_retries = 0
+          end
+        end
+
+        # @api private
+        #
+        # @param conn [Net::HTTP]
+        # @param deadline [Float]
+        def calibrate_socket_timeout(conn, deadline)
+          timeout = deadline - Orb::Util.monotonic_secs
+          conn.open_timeout = conn.read_timeout = conn.write_timeout = conn.continue_timeout = timeout
+        end
+
+        # @api private
+        #
+        # @param request [Hash{Symbol=>Object}] .
+        #
+        #   @option request [Symbol] :method
+        #
+        #   @option request [URI::Generic] :url
+        #
+        #   @option request [Hash{String=>String}] :headers
+        #
+        # @param blk [Proc]
+        #
+        # @yieldparam [String]
+        # @return [Net::HTTPGenericRequest]
+        def build_request(request, &blk)
+          method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
+          req = Net::HTTPGenericRequest.new(
+            method.to_s.upcase,
+            !body.nil?,
+            method != :head,
+            url.to_s
+          )
+
+          headers.each { req[_1] = _2 }
+
+          case body
+          in nil
+            nil
+          in String
+            req["content-length"] ||= body.bytesize.to_s unless req["transfer-encoding"]
+            req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk)
+          in StringIO
+            req["content-length"] ||= body.size.to_s unless req["transfer-encoding"]
+            req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk)
+          in IO | Enumerator
+            req["transfer-encoding"] ||= "chunked" unless req["content-length"]
+            req.body_stream = Orb::Util::ReadIOAdapter.new(body, &blk)
+          end
+
+          req
+        end
+      end
+
+      # @api private
+      #
+      # @param url [URI::Generic]
+      # @param deadline [Float]
+      # @param blk [Proc]
+      #
+      # @raise [Timeout::Error]
+      # @yieldparam [Net::HTTP]
+      private def with_pool(url, deadline:, &blk)
+        origin = Orb::Util.uri_origin(url)
+        timeout = deadline - Orb::Util.monotonic_secs
+        pool =
+          @mutex.synchronize do
+            @pools[origin] ||= ConnectionPool.new(size: @size) do
+              self.class.connect(url)
+            end
+          end
+
+        pool.with(timeout: timeout, &blk)
+      end
+
+      # @api private
+      #
+      # @param request [Hash{Symbol=>Object}] .
+      #
+      #   @option request [Symbol] :method
+      #
+      #   @option request [URI::Generic] :url
+      #
+      #   @option request [Hash{String=>String}] :headers
+      #
+      #   @option request [Object] :body
+      #
+      #   @option request [Float] :deadline
+      #
+      # @return [Array(Integer, Net::HTTPResponse, Enumerable)]
+      def execute(request)
+        url, deadline = request.fetch_values(:url, :deadline)
+
+        eof = false
+        finished = false
+        enum = Enumerator.new do |y|
+          with_pool(url, deadline: deadline) do |conn|
+            next if finished
+
+            req = self.class.build_request(request) do
+              self.class.calibrate_socket_timeout(conn, deadline)
+            end
+
+            self.class.calibrate_socket_timeout(conn, deadline)
+            unless conn.started?
+              conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
+              conn.start
+            end
+
+            self.class.calibrate_socket_timeout(conn, deadline)
+            conn.request(req) do |rsp|
+              y << [conn, req, rsp]
+              break if finished
+
+              rsp.read_body do |bytes|
+                y << bytes
+                break if finished
+
+                self.class.calibrate_socket_timeout(conn, deadline)
+              end
+              eof = true
+            end
+          end
+        rescue Timeout::Error
+          raise Orb::Errors::APITimeoutError
+        end
+
+        conn, _, response = enum.next
+        body = Orb::Util.fused_enum(enum, external: true) do
+          finished = true
+          tap do
+            enum.next
+          rescue StopIteration
+            nil
+          end
+          conn.finish if !eof && conn&.started?
+        end
+        [Integer(response.code), response, (response.body = body)]
+      end
+
+      # @api private
+      #
+      # @param size [Integer]
+      def initialize(size: Etc.nprocessors)
+        @mutex = Mutex.new
+        @size = size
+        @pools = {}
+      end
+    end
+  end
+end