x-core 1.0.0

data/lib/x/core/problem.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "errors/unsupported_format"
+
+module X
+  # A problem the API described, in a response that failed or in one that otherwise succeeded
+  #
+  # The API describes what went wrong the same way whether it refused the request, which raises an {HTTPError}
+  # whose {HTTPError#problem} is one of these, or answered it with the resources it could and named the rest as
+  # errors, which the object layer reads as the problems of a resource or a page. Code that acts on the reason
+  # rather than logging it reads the same object either way.
+  #
+  # @api public
+  class Problem
+    # The number of the format of the state Marshal writes, which every release of 1.x writes
+    #
+    # A later release of 1.x adds to the state only what an earlier one ignores, parts after those it reads and keys of a
+    # Hash it does not read, so that the state one release of 1.x writes is read by every other, earlier or later.
+    MARSHAL_FORMAT = 1
+    # The name YAML writes each part of the state under, in the order Marshal writes them
+    YAML_KEYS = %w[format attrs].freeze
+    private_constant :MARSHAL_FORMAT, :YAML_KEYS
+
+    # The raw attributes of the problem
+    # @api public
+    # @return [Hash{String => Object}] the attributes
+    # @example Get the raw attributes
+    #   problem.attrs # => {"title" => "Not Found Error", "detail" => "Could not find tweet with pinned_tweet_id: [1].", ...}
+    attr_reader :attrs
+
+    # @!method to_h
+    #   Alias for attrs, returns the raw attributes
+    #   @api public
+    #   @return [Hash{String => Object}] the attributes
+    #   @example Convert a problem to a hash
+    #     problem.to_h
+    alias_method :to_h, :attrs
+
+    # The problems a response body reports
+    #
+    # @api public
+    # @param body [Hash, nil] the parsed response body
+    # @return [Array<Problem>] the problems, empty if there are none
+    # @example Read the problems of a response
+    #   X::Problem.all_from(client.get("users/me"))
+    def self.all_from(body)
+      entries = Array(body.to_h["errors"]) #: Array[untyped]
+      entries.filter_map { |attrs| Hash.try_convert(attrs)&.then { |hash| new(hash) } }.freeze
+    end
+
+    # Initialize a problem from the attributes the API reported
+    #
+    # @api public
+    # @param attrs [Hash{String => Object}] the attributes
+    # @return [Problem] a new problem
+    # @example Build a problem
+    #   X::Problem.new({"title" => "Not Found Error"})
+    def initialize(attrs)
+      @attrs = deep_freeze(attrs)
+      freeze
+    end
+
+    # The short, general description of the problem
+    #
+    # @api public
+    # @return [String, nil] the title
+    # @example Get the title
+    #   problem.title # => "Not Found Error"
+    def title = attrs["title"]
+
+    # The description of this occurrence of the problem
+    #
+    # @api public
+    # @return [String, nil] the detail
+    # @example Get the detail
+    #   problem.detail # => "Could not find tweet with pinned_tweet_id: [1]."
+    def detail = attrs["detail"]
+
+    # The URI that identifies the kind of problem
+    #
+    # @api public
+    # @return [String, nil] the type
+    # @example Get the type
+    #   problem.type # => "https://api.x.com/2/problems/resource-not-found"
+    def type = attrs["type"]
+
+    # The kind of resource the problem concerns
+    #
+    # @api public
+    # @return [String, nil] the resource type, such as tweet or user
+    # @example Get the resource type
+    #   problem.resource_type # => "tweet"
+    def resource_type = attrs["resource_type"]
+
+    # The identifier of the resource the problem concerns
+    #
+    # It is the String the API gave, whatever the kind of resource, since the API names a user by a username as
+    # often as by an identifier, and a space, a place, or media by an identifier that is not a number; {#about?}
+    # compares it with a resource, or the identifier of one, as a String.
+    #
+    # @api public
+    # @return [String, nil] the resource identifier
+    # @example Get the resource identifier
+    #   problem.resource_id # => "1"
+    def resource_id = attrs["resource_id"]
+
+    # The request parameter the problem concerns
+    #
+    # @api public
+    # @return [String, nil] the parameter, such as ids or pinned_tweet_id
+    # @example Get the parameter
+    #   problem.parameter # => "pinned_tweet_id"
+    def parameter = attrs["parameter"]
+
+    # The value of the parameter the problem concerns
+    #
+    # It is the value the API gave, as the request sent it, so an identifier is a String, as resource_id is.
+    #
+    # @api public
+    # @return [Object, nil] the value
+    # @example Get the value
+    #   problem.value # => "1"
+    def value = attrs["value"]
+
+    # The message the API gave for a request it refused
+    #
+    # The errors of a request the API refused carry a message where the problems of a response that succeeded carry
+    # a detail, so a problem read from a failed request reads as one of either.
+    #
+    # @api public
+    # @return [String, nil] the message
+    # @example Get the message
+    #   problem.message # => "Could not authenticate you"
+    def message = attrs["message"]
+
+    # Check whether the problem is a resource that was not found
+    #
+    # @api public
+    # @return [Boolean] true for a resource-not-found problem
+    # @example Skip the posts that no longer exist
+    #   problems.reject(&:not_found?)
+    def not_found? = type.to_s.end_with?("/resource-not-found")
+
+    # Check whether the problem is an operational-disconnect of a stream
+    #
+    # X sends one before it closes a stream for its own reasons. A stream reconnects after a line that holds such problems alone, as it does after a connection that dropped.
+    #
+    # @api public
+    # @return [Boolean] true for an operational-disconnect problem
+    # @example Tell a disconnect apart from another error of a stream
+    #   error.problems.all?(&:disconnect?)
+    def disconnect? = type.to_s.end_with?("/operational-disconnect")
+
+    # Check whether the problem is the usage cap of the project, reached for the month
+    #
+    # X refuses every request of a project that has used the posts its plan allows for the month with a 429 of
+    # this problem, until the month ends, so a client neither waits for it nor sends the request again, and a stream
+    # does not reconnect after it, however its rate limits are set.
+    #
+    # @api public
+    # @return [Boolean] true for a usage-capped problem
+    # @example Tell the usage cap apart from a rate limit
+    #   wait_for_the_next_month if error.problem&.usage_capped?
+    def usage_capped? = type.to_s.end_with?("/usage-capped")
+
+    # Check whether the problem is about a resource
+    #
+    # The resource_id of a problem is the String the API gave, where the resources of x-resources hold an Integer
+    # identifier, so the identifier of the resource, or the identifier given, is compared with it as a String. A
+    # username names the user a problem names by it. A problem that names no resource is about none.
+    #
+    # @api public
+    # @param resource [#id, Integer, String] the resource, or its identifier
+    # @return [Boolean] true if the resource_id of the problem names the resource
+    # @example Check whether a problem is about a user
+    #   problem.about?(user) # => true
+    # @example Check whether a problem is about a post by its identifier
+    #   error.problems.any? { |problem| problem.about?(1_234_567_890) }
+    def about?(resource)
+      id = case resource
+      when Integer, String then resource
+      else resource.id
+      end
+      resource_id.eql?(id.to_s)
+    end
+
+    # Check whether another problem is the same problem
+    #
+    # @api public
+    # @param other [Object] the other problem
+    # @return [Boolean] true if the other problem is a Problem of the same attributes
+    # @example Check whether a response reported a problem before
+    #   seen.include?(problem)
+    def ==(other) = other.instance_of?(self.class) && attrs.eql?(other.attrs)
+    alias_method :eql?, :==
+
+    # The hash of the problem, which equal problems share
+    #
+    # @api public
+    # @return [Integer] the hash
+    # @example Count the distinct problems
+    #   problems.uniq.size
+    def hash = [self.class, attrs].hash
+
+    # The attributes, as a JSON encoder and ActiveSupport read them
+    #
+    # ActiveSupport's Object#as_json would otherwise read the instance variables, which is the same Hash under
+    # another name.
+    #
+    # @api public
+    # @return [Hash{String => Object}] the attributes
+    # @example Serialize a problem
+    #   problem.as_json # => {"title" => "Not Found Error"}
+    def as_json(*) = attrs
+
+    # The attributes as JSON
+    #
+    # @api public
+    # @param state [JSON::State, nil] the state a JSON encoder passes, which the attributes are given
+    # @return [String] the attributes as a JSON object
+    # @example Serialize a problem
+    #   problem.to_json # => "{\"title\":\"Not Found Error\"}"
+    def to_json(state = nil) = as_json.to_json(state)
+
+    # Summarize the problem for the console
+    #
+    # A problem the API described in a response that succeeded carries a detail, and one it named among the errors
+    # of a request it refused carries a message in its place, so the summary reads whichever of the two it holds.
+    #
+    # @api public
+    # @return [String] the class name, title, and detail, or message
+    # @example Inspect a problem of a response that succeeded
+    #   problem.inspect # => #<X::Problem Not Found Error: Could not find tweet with pinned_tweet_id: [1].>
+    # @example Inspect a problem of a request the API refused
+    #   problem.inspect # => #<X::Problem Could not authenticate you>
+    def inspect = "#<#{self.class} #{[title, detail || message].compact.join(": ")}>"
+
+    # The state Marshal writes
+    #
+    # What is written is plain data, led by the number of its format, so that a problem written by one release of 1.x
+    # is read by a later one: its attributes, as the API described it.
+    #
+    # @api public
+    # @return [Array(Integer, Hash{String => Object})] the number of the format, then the attributes
+    # @example Cache the problems of a response
+    #   Rails.cache.write("problems", X::Problem.all_from(body))
+    def marshal_dump = [MARSHAL_FORMAT, attrs]
+
+    # Restore a problem Marshal read, frozen as the problem that was written was
+    #
+    # @api public
+    # @param state [Array] the state Marshal wrote
+    # @return [void]
+    # @raise [UnsupportedFormat] if the state is of a format this release does not read
+    # @example Read cached problems
+    #   Marshal.load(Marshal.dump(problem)).title
+    def marshal_load(state)
+      format, attrs = state
+      raise UnsupportedFormat, "#{self.class} reads format #{MARSHAL_FORMAT} of Marshal, not #{format.inspect}" unless MARSHAL_FORMAT.eql?(format)
+
+      initialize(attrs)
+    end
+
+    # Write the state Marshal writes as YAML
+    #
+    # YAML would write the instance variables of the problem, and read them back into one that is not frozen, so it says
+    # how it is written: each part of the state Marshal writes, under its name.
+    #
+    # @api public
+    # @param coder [Psych::Coder] the coder YAML writes the problem with
+    # @return [void]
+    # @example Write a problem as YAML
+    #   YAML.dump(problem)
+    def encode_with(coder) = YAML_KEYS.zip(marshal_dump) { |key, value| coder[key] = value }
+
+    # Restore a problem YAML read, frozen, as Marshal restores one
+    #
+    # @api public
+    # @param coder [Psych::Coder] the coder YAML read the problem with
+    # @return [void]
+    # @raise [UnsupportedFormat] if the state is of a format this release does not read
+    # @example Read a problem written as YAML
+    #   YAML.unsafe_load(YAML.dump(problem)).title
+    def init_with(coder) = marshal_load(coder.map.values_at(*YAML_KEYS))
+
+    private
+
+    # Copy the attributes with String keys, and freeze them and what they hold
+    # @api private
+    # @param value [Object] the value
+    # @return [Object] the frozen copy
+    def deep_freeze(value)
+      case value
+      when Hash then value.transform_keys(&:to_s).transform_values { |element| deep_freeze(element) }.freeze
+      when Array then value.map { |element| deep_freeze(element) }.freeze
+      when String then value.dup.freeze
+      else value
+      end
+    end
+  end
+end

data/lib/x/core/proxy_setting.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module X
+  module Core
+    # The proxy URL a connection, or the internals of a client, was built with, included into each
+    #
+    # A proxy URL can hold the user and password of the proxy, so neither reveals it to a caller, as a client reveals
+    # none of its secrets. The reader is private, and a copy of a client, which opens its connections with the proxy
+    # of the client it copies, calls it on the internals of that client with __send__.
+    #
+    # @api private
+    module ProxySetting
+      private
+
+      # The proxy URL, as it was given
+      # @api private
+      # @return [String, URI::Generic, nil] the proxy URL, or nil to take the proxy the environment names
+      def proxy_url = @proxy_url
+    end
+    private_constant :ProxySetting
+  end
+end

data/lib/x/core/rate_limit.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module X
+  # Represents rate limit information from an API response
+  # @api public
+  class RateLimit
+    # Rate limit type identifier
+    RATE_LIMIT_TYPE = "rate-limit"
+    # App limit type identifier
+    APP_LIMIT_TYPE = "app-limit-24hour"
+    # User limit type identifier
+    USER_LIMIT_TYPE = "user-limit-24hour"
+    # All supported rate limit types
+    TYPES = [RATE_LIMIT_TYPE, APP_LIMIT_TYPE, USER_LIMIT_TYPE].freeze
+    # The fields of a rate limit, each of which a response reports in a header of its own
+    FIELDS = %w[limit remaining reset].freeze
+    private_constant :FIELDS
+    # The value of a header of a rate limit, which counts requests, or the seconds since the epoch, in base 10
+    COUNT = /\A\d+\z/
+    private_constant :COUNT
+
+    # The type of rate limit
+    # @api public
+    # @return [String] the type of rate limit
+    # @example Get the rate limit type
+    #   rate_limit.type # => "rate-limit"
+    attr_reader :type
+
+    # Every rate limit a response reports in full, in the order of TYPES
+    #
+    # Internal to x-core: it takes the Net::HTTP response of a request, so that it can change within 1.x, as that
+    # response may, and is private, so X::Response#rate_limits and X::TooManyRequests#rate_limits, which read the
+    # same limits, call it with __send__.
+    #
+    # @api private
+    # @param http_response [Net::HTTPResponse] the HTTP response
+    # @return [Array<RateLimit>] the 15-minute limit, and the 24-hour app and user limits, when reported
+    # @example Read every limit a response reports
+    #   X::RateLimit.__send__(:all_from, http_response)
+    def self.all_from(http_response) = TYPES.filter_map { |type| new(type:, http_response:) if reported?(type, http_response) }
+
+    # Check whether a response has the limit, remaining, and reset of a rate limit
+    #
+    # Each is a count in base 10, and a limit whose header holds anything else, such as a proxy that mangled it, is
+    # not reported, rather than read as another number or raise once it is read, which would raise from a refusal
+    # in place of the TooManyRequests the refusal is.
+    #
+    # Internal to x-core: it takes the Net::HTTP response of a request, so that it can change within 1.x, as that
+    # response may.
+    #
+    # @api private
+    # @param type [String] the type of rate limit
+    # @param http_response [Net::HTTPResponse] the HTTP response
+    # @return [Boolean] true if the response has every header of the rate limit, each a count in base 10
+    # @example Check for the 15-minute rate limit
+    #   X::RateLimit.__send__(:reported?, "rate-limit", response)
+    def self.reported?(type, http_response) = FIELDS.all? { |field| http_response["x-#{type}-#{field}"].to_s.match?(COUNT) }
+    private_class_method :all_from, :reported?, :new
+
+    # Initialize a new RateLimit
+    #
+    # Internal to x-core: it takes the Net::HTTP response of a request, so that it can change within 1.x, as that
+    # response may, and new is private, so that only all_from builds one, as X::Response#rate_limits and
+    # X::TooManyRequests#rate_limits read them.
+    #
+    # @api private
+    # @param type [String] the type of rate limit
+    # @param http_response [Net::HTTPResponse] the HTTP response containing rate limit headers
+    # @return [RateLimit] a new instance
+    # @example Create a rate limit instance
+    #   rate_limit = X::RateLimit.__send__(:new, type: "rate-limit", http_response: response)
+    def initialize(type:, http_response:)
+      @type = type
+      @http_response = http_response
+    end
+
+    # Get the rate limit maximum
+    #
+    # @api public
+    # @return [Integer] the maximum number of requests allowed
+    # @example Get the rate limit
+    #   rate_limit.limit
+    def limit = field("limit")
+
+    # Get the remaining requests
+    #
+    # @api public
+    # @return [Integer] the number of requests remaining
+    # @example Get the remaining requests
+    #   rate_limit.remaining
+    def remaining = field("remaining")
+
+    # Check whether the limit has no requests left
+    #
+    # @api public
+    # @return [Boolean] true if no requests remain in the window
+    # @example Wait for a limit that is used up
+    #   sleep rate_limit.reset_in if rate_limit.exhausted?
+    def exhausted? = remaining.zero?
+
+    # Get the time when the rate limit resets
+    #
+    # @api public
+    # @return [Time] the time when the rate limit resets
+    # @example Get the reset time
+    #   rate_limit.reset_at
+    def reset_at = Time.at(field("reset"))
+
+    # Get the seconds until the rate limit resets
+    #
+    # @api public
+    # @return [Integer] the seconds until the rate limit resets
+    # @example Get the reset time in seconds
+    #   rate_limit.reset_in
+    def reset_in
+      [(reset_at - Time.now).ceil, 0].max
+    end
+
+    private
+
+    # The response the limit was read from, as the client received it
+    #
+    # Internal to x-core: the limit reads its headers from it, so that a limit promises nothing of Net::HTTP.
+    # {#limit}, {#remaining}, and {#reset_at} are the headers it reports, and X::Response#http_response and
+    # X::HTTPError#http_response are the response itself.
+    #
+    # @api private
+    # @return [Net::HTTPResponse] the HTTP response the rate limit headers came with
+    attr_reader :http_response
+
+    # Read a field of the rate limit from its header, in base 10
+    # @api private
+    # @param name [String] the name of the field: limit, remaining, or reset
+    # @return [Integer] the value of the field
+    def field(name) = Integer(http_response.fetch("x-#{type}-#{name}"), 10)
+  end
+end

data/lib/x/core/rate_limit_handler.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative "errors/too_many_requests"
+require_relative "setting_validator"
+
+module X
+  module Core
+    # Retries requests the API refuses for a rate limit, waiting until the limit resets
+    #
+    # Internal to x-core: Client retries with it, and takes max_rate_limit_retries and max_rate_limit_wait.
+    #
+    # @api private
+    class RateLimitHandler
+      # Default maximum number of retries, which retries nothing
+      DEFAULT_MAX_RETRIES = 0
+      # Default maximum number of seconds to wait for a rate limit to reset, the length of a 15-minute window
+      DEFAULT_MAX_WAIT = 900
+      # Seconds to wait before the first retry of a request refused without a Retry-After header or a reset time,
+      # doubled for each retry after
+      UNREPORTED_RESET_WAIT = 60
+      # The most seconds added at random to a wait, which keep apart the requests one reset releases
+      RESET_JITTER = 5
+      # The fiber-local key of the retries counted across the attempts of the request being sent
+      RETRIES = :x_core_rate_limit_retries
+      # The fiber-local key of the retries Client#with_retries hands down to the request it sends again
+      HANDED = :x_core_rate_limit_retries_handed
+
+      # The maximum number of times to retry a request refused for a rate limit
+      # @api private
+      # @return [Integer] the maximum number of retries
+      # @example Get or set the maximum retries
+      #   handler.max_rate_limit_retries = 3
+      attr_reader :max_rate_limit_retries
+
+      # The maximum number of seconds to wait for a rate limit to reset before retrying
+      # @api private
+      # @return [Integer, Float] the maximum wait in seconds
+      # @example Get or set the maximum wait
+      #   handler.max_rate_limit_wait = 60
+      attr_reader :max_rate_limit_wait
+
+      # Initialize a new rate limit handler
+      #
+      # @api private
+      # @param max_rate_limit_retries [Integer] the maximum number of times to retry a request refused for a rate limit
+      # @param max_rate_limit_wait [Integer, Float] the maximum number of seconds to wait for a rate limit to reset
+      # @return [RateLimitHandler] a new instance
+      # @raise [ArgumentError] if the maximum number of retries is not an Integer of at least 0, or the maximum wait
+      #   is not a number of seconds of at least 0
+      # @example Create a rate limit handler
+      #   handler = X::Core::RateLimitHandler.new(max_rate_limit_retries: 3)
+      def initialize(max_rate_limit_retries: DEFAULT_MAX_RETRIES, max_rate_limit_wait: DEFAULT_MAX_WAIT)
+        @max_rate_limit_retries = SettingValidator.count!(:max_rate_limit_retries, max_rate_limit_retries)
+        @max_rate_limit_wait = SettingValidator.seconds!(:max_rate_limit_wait, max_rate_limit_wait)
+      end
+
+      # Run a request, running it again after a rate limit resets
+      #
+      # A request is retried while retries remain and the wait the response asks for is within the maximum wait;
+      # otherwise the error is raised, as it is for the usage cap of the project, which lasts until the month ends. A response that asks for neither a wait nor a reset time waits a minute
+      # before the first retry, doubling the wait for each retry after, as X recommends. The block must build its
+      # request anew each time, so that each attempt is signed afresh.
+      #
+      # Every request of an app shares the app's limits, and so the time they reset, so a few seconds are added at
+      # random to each wait, to keep the requests one reset releases from being sent again in one burst.
+      #
+      # @api private
+      # @yield runs the request
+      # @return [Object] what the block returns
+      # @raise [TooManyRequests] if the request is refused once more than the retries allow, or for too long a wait
+      # @example Retry a request
+      #   handler.handle { client.get("users/me") }
+      def handle
+        retries = 0
+        begin
+          yield
+        rescue TooManyRequests => e
+          retries = counted(retries)
+          sleep wait_before_retry(e, retries)
+          retry
+        end
+      end
+
+      # Count the retries of each attempt of a request as retries of one request
+      #
+      # A request that another handler sends again, after a server error, is rate limited anew on each attempt, so its
+      # retries are counted across the attempts, rather than from nothing on each, so that max_rate_limit_retries
+      # bounds the retries of the request. The count is the request's own: a request a callback of it sends, such as
+      # on_response or save_tokens, counts afresh, and leaves the count of the request as it was. A request that
+      # Client#with_retries sends again counts on from the retries its earlier attempts took.
+      #
+      # @api private
+      # @yield runs the attempts of the request
+      # @return [Object] what the block returns
+      # @example Count the rate limits of a request across its attempts
+      #   handler.counting { retry_handler.handle(idempotent: true) { handler.handle { request } } }
+      def counting
+        previous = Thread.current[RETRIES]
+        handed = Thread.current[HANDED] #: Integer?
+        Thread.current[HANDED] = nil
+        Thread.current[RETRIES] = handed || 0
+        begin
+          yield
+        ensure
+          Thread.current[HANDED] = Thread.current.fetch(RETRIES) if handed
+          Thread.current[RETRIES] = previous
+        end
+      end
+
+      # Hand the retries of a request down across the attempts with_retries sends
+      #
+      # It is what Client#with_retries counts with, so that the request it wraps counts on from the retries its earlier
+      # attempts took.
+      #
+      # @api private
+      # @yield runs the attempts of the request
+      # @return [Object] what the block returns
+      # @example Count the rate limits of a request across the attempts with_retries sends
+      #   handler.handing_down { retry_handler.handle(idempotent: true) { client.post(...) } }
+      def handing_down
+        previous = Thread.current[HANDED]
+        begin
+          Thread.current[HANDED] = 0
+          yield
+        ensure
+          Thread.current[HANDED] = previous
+        end
+      end
+
+      private
+
+      # The number of a retry, counted across the attempts of a request that are counted
+      # @api private
+      # @param retries [Integer] the retries counted by the attempt alone
+      # @return [Integer] the number of the retry
+      def counted(retries)
+        shared = Thread.current[RETRIES] #: Integer?
+        return retries + 1 unless shared
+
+        Thread.current[RETRIES] = shared + 1
+      end
+
+      # The seconds to wait before a retry, raising the error if it may not retry
+      #
+      # The random share is added to the wait rather than taken off it, since a request sent before the limit
+      # resets is refused again, and so it is not counted against the maximum wait, which is the longest reset a
+      # request waits for.
+      #
+      # @api private
+      # @param error [TooManyRequests] the error the request raised
+      # @param retries [Integer] the number of the retry, counting from one
+      # @return [Float] the seconds the response asks the request to wait, and a random share of RESET_JITTER
+      # @raise [TooManyRequests] the error being rescued, if no retries remain, the wait is too long, or the project
+      #   has reached its usage cap
+      def wait_before_retry(error, retries)
+        raise if retries > max_rate_limit_retries || error.problem&.usage_capped?
+
+        wait = error.retry_after || UNREPORTED_RESET_WAIT << (retries - 1)
+        raise if wait > max_rate_limit_wait
+
+        wait + (rand * RESET_JITTER)
+      end
+    end
+    private_constant :RateLimitHandler
+  end
+end