calmlens 0.1.1 → 0.18.0

data/lib/calmlens/errors.rb

@@ -13,11 +13,12 @@ module CalmLens
     TRANSPORT_ERROR = 'sdk/transport-error'
     # Connecting, sending or receiving took longer than the configured timeout.
     TIMEOUT = 'sdk/timeout'
-    # A successful response could not be read (malformed JSON or too large).
+    # A successful response could not be read: malformed JSON, or not what the API returns.
     INVALID_RESPONSE = 'sdk/invalid-response'
-    # A response body was larger than the SDK reads (32 MiB for API responses).
+    # A response body was larger than the client's `max_response_bytes` (32 MiB by default).
     RESPONSE_TOO_LARGE = 'sdk/response-too-large'
-    # An error response did not carry a CalmLens error code.
+    # An error response did not carry a CalmLens error code, or the API answered with a redirect,
+    # which the SDK never follows.
     HTTP_ERROR = 'sdk/http-error'
     # A webhook signature or timestamp did not verify.
     INVALID_WEBHOOK_SIGNATURE = 'sdk/invalid-webhook-signature'
@@ -31,12 +32,13 @@ module CalmLens
   #   @return [String] a stable identifier such as `asset/not-found` or `sdk/timeout`.
   #     Compare it with {ErrorCodes} or {SdkErrorCodes}, never with the message.
   # @!attribute [r] details
-  #   @return [Hash{String => Object}] extra API details; API errors include `"network" => true`
-  #     and, when present, `"traceId"`.
+  #   @return [Hash{String => Object}, nil] the API's details, such as validation `issues`; nil when
+  #     the error has no details object.
   # @!attribute [r] status
   #   @return [Integer, nil] the HTTP status, or nil when no response was received.
   # @!attribute [r] request_id
-  #   @return [String, nil] the `X-Request-Id` response header. Include it when contacting support.
+  #   @return [String, nil] the `X-Request-Id` response header, or the error body's `requestId`.
+  #     Include it when contacting support.
   # @!attribute [r] headers
   #   @return [Hash{String => String}] response headers with lowercase names (empty without a response).
   class Error < StandardError
@@ -44,7 +46,7 @@ module CalmLens
 
     # @param code [String]
     # @param message [String, nil] defaults to the code.
-    def initialize(code, message = nil, details: {}, status: nil, headers: {}, request_id: nil)
+    def initialize(code, message = nil, details: nil, status: nil, headers: {}, request_id: nil)
       super("[calmlens] #{message || code}")
       @code = code
       @details = details
@@ -53,7 +55,8 @@ module CalmLens
       @request_id = request_id || headers['x-request-id']
     end
 
-    # @return [Float, nil] seconds to wait before retrying, from the `Retry-After` header.
+    # @return [Integer, nil] whole seconds to wait before retrying, from the `Retry-After` header
+    #   (seconds, or an HTTP date counted from now).
     def retry_after
       Error.parse_retry_after(headers['retry-after'])
     end
@@ -63,11 +66,19 @@ module CalmLens
       status == 404 || code.end_with?('/not-found')
     end
 
-    # @return [Boolean] true when repeating the same request may succeed: connection failures,
-    #   timeouts, throttling (429), 502/503/504 and `idempotency/request-in-progress`.
-    #   Repeat a write only with the same idempotency key.
+    # Codes that may succeed when the same request is repeated, whatever the status.
+    RETRYABLE_CODES = [SdkErrorCodes::TRANSPORT_ERROR, SdkErrorCodes::TIMEOUT,
+                       ErrorCodes::IDEMPOTENT_REQUEST_IN_PROGRESS].freeze
+    # HTTP statuses that may succeed when the same request is repeated.
+    RETRYABLE_STATUSES = [429, 502, 503, 504].freeze
+    private_constant :RETRYABLE_CODES, :RETRYABLE_STATUSES
+
+    # @return [Boolean] true when repeating the same request may succeed: connection failures
+    #   (`sdk/transport-error`), timeouts (`sdk/timeout`, including {Assets#wait_for_decision}),
+    #   `idempotency/request-in-progress`, throttling (429) and 502/503/504. Everything else,
+    #   including other 5xx statuses, is false. Repeat a write only with the same idempotency key.
     def retryable?
-      [429, 502, 503, 504].include?(status) || code == ErrorCodes::IDEMPOTENT_REQUEST_IN_PROGRESS
+      RETRYABLE_CODES.include?(code) || RETRYABLE_STATUSES.include?(status)
     end
 
     # Builds the most specific error class for a code and HTTP status.
@@ -88,9 +99,9 @@ module CalmLens
       return nil if value.nil? || value.to_s.strip.empty?
 
       text = value.to_s.strip
-      return [Float(text), 0.0].max if text.match?(/\A\d+(\.\d+)?\z/)
+      return Integer(text, 10) if text.match?(/\A\d+\z/)
 
-      [Time.httpdate(text) - Time.now, 0.0].max
+      [(Time.httpdate(text) - Time.now).ceil, 0].max
     rescue ArgumentError
       nil
     end
@@ -129,9 +140,7 @@ module CalmLens
   class ServerError < APIError; end
 
   # No complete response arrived (`sdk/transport-error`). The original exception is in `cause`.
-  class ConnectionError < Error
-    def retryable? = true
-  end
+  class ConnectionError < Error; end
 
   # Connecting, sending or receiving exceeded its timeout, or {Assets#wait_for_decision} had no
   # decision in time (`sdk/timeout`).

data/lib/calmlens/events.rb

@@ -3,44 +3,47 @@
 module CalmLens
   # The project's events feed. Reach it through {ServerClient#events}.
   class Events < Resource
-    # Lists events after a cursor, oldest first. Without `after`, returns no events and a cursor
-    # for the current time: save it, then pass each response's `cursor` as `after`.
-    # @option options [String] :after a cursor from a previous response
-    # @option options [Integer] :limit default 50
-    # @return [Hash] `{'events', 'cursor', 'hasMore'}`
+    # Lists events after a cursor, oldest first. Without `cursor`, returns no events and a
+    # `nextCursor` for the current time: save it, then pass each response's `nextCursor` as `cursor`.
+    # @option options [String] :cursor the `nextCursor` of a previous response
+    # @option options [Integer] :page_size 1 to 100, default 50
+    # @return [Hash] `{'items', 'nextCursor', 'hasMore'}`; `nextCursor` is never nil
     def list(options = {})
       call(options) { |api, request| request('GET', project('events'), query: api, request_options: request) }
     end
 
-    # Iterates pages from `after` until `hasMore` is false. Persist each page's `cursor` once its
-    # events are handled, and resume from it later.
+    # Iterates pages from `cursor` until `hasMore` is false. Persist each page's `nextCursor` once its
+    # events are handled, and resume from it later. Raises `sdk/invalid-response` (with
+    # `details['cursor']`) instead of looping when a page with more to follow repeats a cursor.
     # @yieldparam page [Hash]
     # @return [Enumerator, nil] an Enumerator when no block is given.
     def each_page(options = {})
       return enum_for(:each_page, options) unless block_given?
 
       api, request = call(options) { |*split| split }
+      sent = api.key?('cursor') ? [api['cursor']] : []
       loop do
         page = list(api.merge('request_options' => request))
-        unless page.is_a?(Hash) && page['events'].is_a?(Array) && page['cursor'].is_a?(String)
-          raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Events page has no events or cursor')
+        unless page.is_a?(Hash) && page['items'].is_a?(Array) && page['nextCursor'].is_a?(String)
+          raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Events page has no items or next cursor')
         end
 
+        new_cursor!(sent, page['nextCursor']) if page['hasMore'] == true
         yield page
         break unless page['hasMore'] == true
 
-        api = api.merge('after' => page['cursor'])
+        api = api.merge('cursor' => page['nextCursor'])
       end
       nil
     end
 
-    # Iterates the events after `after`, across pages. See {#each_page} to track the cursor.
+    # Iterates the events after `cursor`, across pages. See {#each_page} to track the cursor.
     # @yieldparam event [Hash]
     # @return [Enumerator, nil] an Enumerator when no block is given.
     def each(options = {}, &block)
       return enum_for(:each, options) unless block
 
-      each_page(options) { |page| page['events'].each(&block) }
+      each_page(options) { |page| page['items'].each(&block) }
     end
   end
 end

data/lib/calmlens/folders.rb

@@ -3,14 +3,21 @@
 module CalmLens
   # Folders organise a project's assets. Reach it through {ServerClient#folders}.
   class Folders < Resource
-    # @return [Array<Hash>] every folder in the project.
+    # Lists one page of child folders, sorted by name unless `ordering` says otherwise.
+    # @option options [String] :parent_id list this folder's children; omit for the project root
+    # @option options [String] :cursor the previous page's `nextCursor`
+    # @option options [Integer] :page_size 1 to 100, default 50
+    # @option options [Array<Hash>] :ordering one `{field: 'name' | 'createdAt', direction: 'asc' | 'desc'}`
+    # @option options [String] :search only children whose name contains it
+    # @return [Hash] a cursor page (items, nextCursor, hasMore, pageSize, ordering) with ancestors.
     def list(options = {})
-      call(options) do |_api, request|
-        response = request('GET', project('folders'), request_options: request)
-        folders = response.is_a?(Hash) ? response['folders'] : nil
-        raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Folder list has no folders') unless folders.is_a?(Array)
+      call(options) do |api, request|
+        response = request('GET', project('folders'), query: api, request_options: request)
+        valid = response.is_a?(Hash) && response['items'].is_a?(Array) && response['ancestors'].is_a?(Array) &&
+                [true, false].include?(response['hasMore'])
+        raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Invalid folder page') unless valid
 
-        folders
+        response
       end
     end
 

data/lib/calmlens/hash_lists.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module CalmLens
+  # Hash lists hold perceptual hashes of images. Image uploads are compared with every list in the
+  # project: a `flag` list reports matches, a `block` list also blocks close matches. Reach it through
+  # {ServerClient#hash_lists}.
+  class HashLists < Resource
+    # Lists one page of the project's hash lists, newest first.
+    # @option options [String] :cursor the previous page's `nextCursor`
+    # @option options [Integer] :page_size 1 to 100, default 50
+    # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
+    def list(options = {})
+      call(options) do |api, request|
+        response = request('GET', project('hash-lists'), query: api, request_options: request)
+        valid = response.is_a?(Hash) && response['items'].is_a?(Array)
+        raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Invalid hash list page') unless valid
+
+        response
+      end
+    end
+
+    # @option options [String] :hash_list_id
+    # @return [Hash] the hash list
+    def retrieve(options)
+      call(options) { |api, request| request('GET', list_path(api), request_options: request) }
+    end
+
+    # @option options [String] :name
+    # @option options [String] :action `flag` or `block`
+    # @option options [String, nil] :description
+    # @return [Hash] the hash list
+    def create(options)
+      call(options) { |api, request| request('POST', project('hash-lists'), body: api, request_options: request) }
+    end
+
+    # Renames a list or changes what its matches do. The new action applies to later uploads.
+    # @option options [String] :hash_list_id
+    # @option options [String] :name
+    # @option options [String, nil] :description
+    # @option options [String] :action `flag` or `block`
+    # @return [Hash] the hash list
+    def update(options)
+      call(options) do |api, request|
+        request('PATCH', list_path(api), body: without(api, 'hashListId'), request_options: request)
+      end
+    end
+
+    # Deletes the list and every entry in it. Later uploads are no longer compared with it.
+    # @option options [String] :hash_list_id
+    # @return [nil]
+    def delete(options)
+      call(options) do |api, request|
+        request('DELETE', list_path(api), request_options: request)
+        nil
+      end
+    end
+
+    # Lists one page of a list's entries, newest first.
+    # @option options [String] :hash_list_id
+    # @option options [String] :cursor the previous page's `nextCursor`
+    # @option options [Integer] :page_size 1 to 100, default 50
+    # @return [Hash] a cursor page: items, nextCursor, hasMore, pageSize and ordering.
+    def list_entries(options)
+      call(options) do |api, request|
+        request('GET', "#{list_path(api)}/entries", query: without(api, 'hashListId'), request_options: request)
+      end
+    end
+
+    # Adds a PDQ hash, or an image asset's hash; a hash already in the list returns its entry.
+    # @option options [String] :hash_list_id
+    # @option options [String] :hash 64 hexadecimal characters; send this or `asset_id`
+    # @option options [Integer] :quality
+    # @option options [String] :asset_id an image asset whose hash to add
+    # @option options [String] :label
+    # @return [Hash] the entry
+    def add_entry(options)
+      call(options) do |api, request|
+        request('POST', "#{list_path(api)}/entries", body: without(api, 'hashListId'), request_options: request)
+      end
+    end
+
+    # @option options [String] :entry_id
+    # @return [nil]
+    def remove_entry(options)
+      call(options) do |api, request|
+        request('DELETE', "/hash-list-entries/#{Internal.segment(api['entryId'])}", request_options: request)
+        nil
+      end
+    end
+
+    private
+
+    def list_path(api) = "/hash-lists/#{Internal.segment(api['hashListId'])}"
+  end
+end

data/lib/calmlens/internal.rb

@@ -8,8 +8,10 @@ module CalmLens
   # @api private
   module Internal
     # Per-call settings accepted under the `request_options:` option of any method.
-    REQUEST_OPTIONS = %i[idempotency_key timeout open_timeout max_retries].freeze
-    IDEMPOTENCY_KEY = /\A[\x21-\x7e]{1,255}\z/
+    REQUEST_OPTIONS = %i[idempotency_key timeout open_timeout upload_timeout max_retries max_response_bytes].freeze
+    # A key the API can receive as a header value; the API checks the rest (1 to 255 printable
+    # ASCII characters without a space at either end) and answers `idempotency/invalid-key`.
+    IDEMPOTENCY_KEY = /\A[^\r\n\0]+\z/
     HEADER_VALUE = /\A[^\r\n\0]*\z/
 
     module_function
@@ -58,16 +60,19 @@ module CalmLens
     def check_request_options(request)
       key = request[:idempotency_key]
       if !key.nil? && !(key.is_a?(String) && key.match?(IDEMPOTENCY_KEY))
-        raise invalid('idempotency_key must be 1 to 255 printable ASCII characters')
+        raise invalid('idempotency_key must be a non-empty String without line breaks')
       end
 
-      %i[timeout open_timeout].each do |name|
+      %i[timeout open_timeout upload_timeout].each do |name|
         next if request[name].nil? || positive?(request[name])
 
         raise invalid("#{name} must be a positive number of seconds")
       end
       retries = request[:max_retries]
       raise invalid('max_retries must be a non-negative Integer') unless retries.nil? || (retries.is_a?(Integer) && retries >= 0)
+
+      limit = request[:max_response_bytes]
+      raise invalid('max_response_bytes must be a positive Integer') unless limit.nil? || (limit.is_a?(Integer) && limit.positive?)
     end
 
     def positive?(value)
@@ -88,11 +93,12 @@ module CalmLens
       raise invalid('Identifier is required') if text.empty?
       raise invalid('Identifier cannot be "." or ".."') if %w[. ..].include?(text)
 
-      URI.encode_www_form_component(text).gsub('+', '%20')
+      # Like JavaScript's encodeURIComponent.
+      text.encode(Encoding::UTF_8).b.gsub(/[^A-Za-z0-9\-_.!~*'()]/n) { |byte| format('%%%02X', byte.ord) }
     end
 
-    # Splits an absolute URL into its parsed origin and its raw request target. URI rejects the
-    # literal brackets CDN transform selectors keep, so only the origin is parsed.
+    # Splits an absolute URL into its parsed origin and its raw request target. Only the origin is
+    # parsed, so the request target is sent exactly as the SDK built it.
     # @return [Array(URI::Generic, String)]
     def split_url(url)
       match = %r{\A([A-Za-z][A-Za-z0-9+.-]*://[^/?#]*)([^#]*)}.match(url.to_s)

data/lib/calmlens/moderation_context.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CalmLens
+  # Earlier posts in a conversation, sent with an upload as `context: { items: [{ text:, author_id: }] }`
+  # (oldest first) so CalmLens can tell who the content addresses and what it refers to. CalmLens
+  # moderates only the uploaded content; it uses the most recent {USED_ITEMS} posts that fit in
+  # {USED_CHARACTERS} characters, and the SDK sends only those.
+  module ModerationContext
+    # The most recent earlier posts CalmLens uses.
+    USED_ITEMS = 5
+    # The most characters of earlier posts CalmLens uses, counted as Unicode code points.
+    USED_CHARACTERS = 2_000
+
+    module_function
+
+    # The earlier posts CalmLens uses: the most recent ones, newest first, while at most
+    # {USED_ITEMS} posts and {USED_CHARACTERS} characters allow, returned oldest first. The newest
+    # post is always kept, so the API can reject one that is too long.
+    # @param items [Array<Hash>] posts oldest first, each with `text` and optionally `author_id`
+    #   (Symbol or String keys, snake_case or camelCase).
+    # @return [Array<Hash>] the kept posts as `{'text' => String, 'authorId' => String}`, without
+    #   `authorId` when a post has none.
+    # @raise [InvalidArgumentError] when `items` is not an Array of posts with String text.
+    def select_items(items)
+      raise Internal.invalid('context.items must be an array of earlier posts') unless items.is_a?(Array)
+
+      selected = []
+      characters = 0
+      items.reverse_each do |item|
+        break if selected.size == USED_ITEMS
+
+        post = post(item)
+        length = post['text'].length
+        break if !selected.empty? && characters + length > USED_CHARACTERS
+
+        selected.unshift(post)
+        characters += length
+      end
+      selected
+    end
+
+    # One post as the API takes it.
+    def post(item)
+      fields = item.is_a?(Hash) ? Internal.normalize(item) : nil
+      text = fields&.fetch('text', nil)
+      raise Internal.invalid('Each earlier post needs its text as a String') unless text.is_a?(String)
+
+      author = fields['authorId']
+      raise Internal.invalid("An earlier post's author_id must be a String") unless author.nil? || author.is_a?(String)
+
+      author.nil? ? { 'text' => text } : { 'text' => text, 'authorId' => author }
+    end
+    private_class_method :post
+  end
+end

data/lib/calmlens/resource.rb

@@ -30,22 +30,39 @@ module CalmLens
 
     def without(options, *keys) = options.except(*keys)
 
-    # Fetches numbered pages lazily, from `start` until `hasMore` is false.
+    # Fetches cursor pages lazily, from `start`, until a page has no next cursor, says there is no
+    # more or is empty. A page with more to follow that hands back a cursor this iteration already
+    # sent raises `sdk/invalid-response` rather than repeating pages forever.
     def pages(start, &fetch)
       Enumerator.new do |out|
-        index = start
+        cursor = start
+        sent = []
         loop do
-          page = fetch.call(index)
+          page = fetch.call(cursor)
           items = page.is_a?(Hash) ? page['items'] : nil
           raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE, 'Page has no items') unless items.is_a?(Array)
 
+          following = page['nextCursor']
+          more = following.is_a?(String) && !following.empty? && page['hasMore'] == true && !items.empty?
+          new_cursor!(sent, following) if more
           out << page
-          break unless page['hasMore'] == true && !items.empty?
+          break unless more
 
-          index = page['nextCursor']
-          break unless index
+          cursor = following
         end
       end
     end
+
+    # Records a cursor an iteration sends, raising `sdk/invalid-response` (with `details['cursor']`)
+    # when a page with more to follow hands back one it already sent, which would repeat pages forever.
+    def new_cursor!(sent, cursor)
+      if sent.include?(cursor)
+        raise InvalidResponseError.new(SdkErrorCodes::INVALID_RESPONSE,
+                                       'The API returned a cursor it had already returned, with more pages to follow',
+                                       details: { 'cursor' => cursor })
+      end
+
+      sent << cursor
+    end
   end
 end

data/lib/calmlens/server_client.rb

@@ -9,16 +9,31 @@ module CalmLens
   # @example
   #   client = CalmLens::ServerClient.new(api_key: ENV.fetch('CALMLENS_API_KEY'),
   #                                 project_id: ENV.fetch('CALMLENS_PROJECT_ID'))
-  #   asset = client.text.moderate(text: 'Hello world')
+  #   asset = client.text.classify(text: 'Hello world')
   #   client.close
   class ServerClient
     DEFAULT_BASE_URL = 'https://api.calmlens.com/v1'
     DEFAULT_CDN_BASE_URL = 'https://cdn.calmlens.com/v1'
+    # Seconds allowed for each socket read or write.
+    DEFAULT_TIMEOUT = 120
+    DEFAULT_OPEN_TIMEOUT = 10
+    DEFAULT_MAX_RETRIES = 2
+    # Seconds before the first retry; later retries wait twice as long each time, up to RETRY_MAX_DELAY.
+    DEFAULT_RETRY_BASE_DELAY = 0.5
+    RETRY_MAX_DELAY = 8
+    # A `Retry-After` longer than this many seconds is returned to the caller instead of waited out.
+    RETRY_AFTER_MAX = 60
+    # The largest response body read, in bytes (32 MiB).
+    DEFAULT_MAX_RESPONSE_BYTES = 32 * 1024 * 1024
+    # The most lens definitions {#ensure_lenses} sends in one request.
+    ENSURE_LENSES_MAX_PER_REQUEST = 100
 
     # @return [Assets]
     attr_reader :assets
     # @return [Folders]
     attr_reader :folders
+    # @return [HashLists]
+    attr_reader :hash_lists
     # @return [Text]
     attr_reader :text
     # @return [UploadTokens]
@@ -36,6 +51,11 @@ module CalmLens
     #   moderation decision. It is not a deadline for a whole transfer, so large uploads and downloads
     #   are not cut off. Override per call with `request_options: {timeout:}`.
     # @param open_timeout [Numeric] seconds allowed to open a connection.
+    # @param upload_timeout [Numeric, nil] seconds allowed for each attempt of a binary upload (file
+    #   content or a multipart part) as a whole. Uploads have no such deadline unless you set one; text
+    #   content follows `timeout` like other requests.
+    # @param max_response_bytes [Integer] the largest response body read; a larger one fails with
+    #   `sdk/response-too-large`, before it is read when its `Content-Length` says so.
     # @param max_retries [Integer] retries of requests that are safe to repeat: GET/HEAD, and uploads,
     #   which carry an `Idempotency-Key`. Connection failures, timeouts, 429, 502, 503, 504 and
     #   `idempotency/request-in-progress` are retried with jittered exponential backoff, honouring
@@ -45,17 +65,22 @@ module CalmLens
     # @param transport [#call, nil] a custom {Transport}; defaults to {Transport::NetHTTP}.
     # @raise [ConfigurationError] `sdk/invalid-config` for a missing or malformed setting.
     def initialize(api_key:, project_id:, base_url: DEFAULT_BASE_URL, cdn_base_url: DEFAULT_CDN_BASE_URL,
-                   timeout: 120, open_timeout: 10, max_retries: 2, retry_base_delay: 0.5, transport: nil)
+                   timeout: DEFAULT_TIMEOUT, open_timeout: DEFAULT_OPEN_TIMEOUT, upload_timeout: nil,
+                   max_retries: DEFAULT_MAX_RETRIES, retry_base_delay: DEFAULT_RETRY_BASE_DELAY,
+                   max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES, transport: nil)
       check_config(api_key, project_id, timeout, open_timeout, max_retries, retry_base_delay, transport)
+      check_limits(upload_timeout, max_response_bytes)
       @project_id = project_id
       @base_url = ServerClient.check_url(base_url, 'base_url')
       @cdn_base_url = ServerClient.check_url(cdn_base_url, 'cdn_base_url')
       @session = Session.new(api_key: api_key, project_id: project_id, base_url: @base_url,
                              cdn_base_url: @cdn_base_url, timeout: timeout, open_timeout: open_timeout,
                              max_retries: max_retries, retry_base_delay: retry_base_delay,
+                             max_response_bytes: max_response_bytes, upload_timeout: upload_timeout,
                              transport: transport || Transport::NetHTTP.new)
       @assets = Assets.new(@session)
       @folders = Folders.new(@session)
+      @hash_lists = HashLists.new(@session)
       @text = Text.new(@session, @assets)
       @upload_tokens = UploadTokens.new(@session, api_key)
       @events = Events.new(@session)
@@ -110,6 +135,15 @@ module CalmLens
 
     private
 
+    def check_limits(upload_timeout, max_response_bytes)
+      unless upload_timeout.nil? || Internal.positive?(upload_timeout)
+        raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'upload_timeout must be nil or a positive number of seconds')
+      end
+      return if max_response_bytes.is_a?(Integer) && max_response_bytes.positive?
+
+      raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'max_response_bytes must be a positive Integer')
+    end
+
     def check_config(api_key, project_id, timeout, open_timeout, max_retries, retry_base_delay, transport)
       unless api_key.is_a?(String) && !api_key.empty? && api_key.match?(/\A[\x21-\x7e]+\z/)
         raise ConfigurationError.new(SdkErrorCodes::INVALID_CONFIG, 'api_key must be a non-empty printable ASCII String')