Add context with rate limit struct for Octokit::TooManyRequests and Octokit:: AbuseDetected errors

[jatindhankhar]

This adds the context attribute to Octokit:: Error for much smoother handling of exception like Octokit::TooManyRequests and Octokit:: AbuseDetected, so that clients consuming them can use the values specified for better retries.

Can be consumed like this

 begin
  octokit_client.get('resource')
rescue Octokit::TooManyRequests => rate_limited_error
  puts "Retry in #{rate_limited_errro.retry_in} seconds"
 # Do fancy sutff
end 

Specifically useful when using with background processors like sidekiq

class PollingWorker
  include Sidekiq::Worker

  sidekiq_retry_in do |attempt, exception|
    case exception
    when Octokit::TooManyRequests
      exception.context.resets_in
    when Octokit::AbuseDetected
      exception.context.resets_in
    end
  end

  def perform
    # Do Polling work
    poller = Octokit::Client.new
    data = poller.fetch('/resource')
  end
end
 

The idea is to have meaningful context for all types of errors depending upon the type of error.

[tarebyte]

Looking good! Just a small change request.

[jatindhankhar]

Thanks @tarebyte for merging this 😄

I have another proposition that I have been using for my personal projects and work, custom pagination for Octokit

Let me know if this also seems worth implementing, I will open relevant issues and PR.

Pagination methods

def should_fetch_more?(page_limit, page_iterated)
    page_limit.nil? || page_iterated < page_limit.to_i
  end

  def can_fetch_more?(last_response)
    last_response.rels[:next].present? && @octokit_client.rate_limit.remaining > 0
  end

  def iterate_pagination(opts = {}, result)
    page_limit = opts[:page_limit]
    page_iterated = 1
    last_response = @octokit_client.last_response
    record_limit = opts[:item_limit]
    while should_fetch_more?(page_limit, page_iterated) && can_fetch_more?(last_response)
      last_response = last_response.rels[:next].get
      if result.is_a?(Sawyer::Resource)
        result.items += result.is_a?(Array) ? last_response.data : last_response.data.items
      else
        result += result.is_a?(Array) ? last_response.data : last_response.data.items
      end

      page_iterated += 1
      return limit_result_count(result, record_limit.to_i) if record_limit && result.count >= record_limit.to_i
    end
    record_limit ? limit_result_count(result, record_limit.to_i) : result
  end

so any utility function can be passed as proc to execute

def execute(opts = {}, &block)
    iterate_pagination(opts, yield)
  end

def find_users(search_text = '', opts = {})
    execute(opts) { @octokit_client.search_users(search_text).items }
end

and can be used as

find_users("user_name", {sort: :indexed, order: :desc, page_limit: 1})

we can clean internal keys as well

 INTERNAL_OPTS_KEYS = [:page_limit, :item_limit]

def clean_opts(opts)
    opts.except(*INTERNAL_OPTS_KEYS)
 end

for methods that are parsed by octokit for equivalent parameters

[tarebyte]

@jatindhankhar mind opening another issue? It's hard to track requests at the end of a merged PR.