Handle rate limits (#354)

* Retry on RateLimitError after reset time

* Make feature optional

* Adding limit to number of retries after 429

* Minor change to retries limit variable

* Corrected minor grammer error

* Setting rate limit flag in init

* Adding bundle updates to travis file

* Adding bundle command to address travis failing issue

Author: choran

.travis.yml

@@ -1,5 +1,9 @@
 language: ruby
 sudo: false
+before_install:
+  - gem install bundler
+  - gem update --system
+  - gem --version
 rvm:
   - 2.1.0
   - 2.2.0

Gemfile

@@ -1,5 +1,6 @@
 source "http://rubygems.org"
 
+gem 'webmock'
 gemspec
 
 group :development, :test do

README.md

@@ -440,6 +440,12 @@ intercom.rate_limit_details
 #=> {:limit=>180, :remaining=>179, :reset_at=>2014-10-07 14:58:00 +0100}
 ```
 
+You can handle the rate limits yourself but a simple option is to use the handle_rate_limit flag.
+This will automatically catch the 429 rate limit exceeded error and wait until the reset time to retry.
+
+```
+intercom = Intercom::Client.new(token: ENV['AT'], handle_rate_limit: true)
+```
 
 ### Pull Requests
 

lib/intercom/client.rb

@@ -2,7 +2,7 @@ module Intercom
   class MisconfiguredClientError < StandardError; end
   class Client
     include Options
-    attr_reader :base_url, :rate_limit_details, :username_part, :password_part
+    attr_reader :base_url, :rate_limit_details, :username_part, :password_part, :handle_rate_limit
 
     class << self
       def set_base_url(base_url)
@@ -14,7 +14,7 @@ def set_base_url(base_url)
       end
     end
 
-    def initialize(app_id: 'my_app_id', api_key: 'my_api_key', token: nil, base_url:'https://api.intercom.io')
+    def initialize(app_id: 'my_app_id', api_key: 'my_api_key', token: nil, base_url:'https://api.intercom.io', handle_rate_limit: false)
       if token
         @username_part = token
         @password_part = ""
@@ -26,6 +26,7 @@ def initialize(app_id: 'my_app_id', api_key: 'my_api_key', token: nil, base_url:
 
       @base_url = base_url
       @rate_limit_details = {}
+      @handle_rate_limit = handle_rate_limit
     end
 
     def admins
@@ -108,6 +109,7 @@ def validate_credentials!
     end
 
     def execute_request(request)
+      request.handle_rate_limit = handle_rate_limit
       request.execute(@base_url, username: @username_part, secret: @password_part)
     ensure
       @rate_limit_details = request.rate_limit_details

lib/intercom/request.rb

@@ -3,11 +3,12 @@
 
 module Intercom
   class Request
-    attr_accessor :path, :net_http_method, :rate_limit_details
+    attr_accessor :path, :net_http_method, :rate_limit_details, :handle_rate_limit
 
     def initialize(path, net_http_method)
       self.path = path
       self.net_http_method = net_http_method
+      self.handle_rate_limit = false
     end
 
     def set_common_headers(method, base_uri)
@@ -58,6 +59,7 @@ def client(uri)
     end
 
     def execute(target_base_url=nil, username:, secret: nil)
+      retries = 3
       base_uri = URI.parse(target_base_url)
       set_common_headers(net_http_method, base_uri)
       set_basic_auth(net_http_method, username, secret)
@@ -70,6 +72,13 @@ def execute(target_base_url=nil, username:, secret: nil)
             parsed_body = parse_body(decoded_body, response)
             raise_errors_on_failure(response)
             parsed_body
+          rescue Intercom::RateLimitExceeded => e
+            if @handle_rate_limit
+              sleep (@rate_limit_details[:reset_at] - Time.now.utc).ceil
+              retry unless (retries -=1).zero?
+            else
+              raise e
+            end
           rescue Timeout::Error
             raise Intercom::ServiceUnavailableError.new('Service Unavailable [request timed out]')
           end

spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'intercom'
 require 'minitest/autorun'
 require 'mocha/setup'
+require 'webmock'
+include WebMock::API
 
 def test_user(email="[email protected]")
   {

spec/unit/intercom/request_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'ostruct'
 
+WebMock.enable!
+
 describe 'Intercom::Request' do
   it 'raises an error when a html error page rendered' do
     response = OpenStruct.new(:code => 500)
@@ -14,9 +16,50 @@
     proc {req.parse_body('<html>somethjing</html>', response)}.must_raise(Intercom::RateLimitExceeded)
   end
 
+  describe 'Intercom::Client' do
+    let (:client) { Intercom::Client.new(token: 'foo', handle_rate_limit: true) }
+    let (:uri) {"https://api.intercom.io/users"}
+
+    it 'should have handle_rate_limit set' do
+       client.handle_rate_limit.must_equal(true)
+    end
+
+    it 'should call sleep for rate limit error three times' do
+      # Use webmock to mock the HTTP request
+      stub_request(:any, uri).\
+      to_return(status: [429, "Too Many Requests"], headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 })
+      req = Intercom::Request.get(uri, "")
+      req.handle_rate_limit=true
+      req.expects(:sleep).times(3).with(any_parameters)
+      req.execute(target_base_url=uri, username: "ted", secret: "")
+    end
+
+    it 'should not call sleep for rate limit error' do
+      # Use webmock to mock the HTTP request
+      stub_request(:any, uri).\
+      to_return(status: [200, "OK"], headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 })
+      req = Intercom::Request.get(uri, "")
+      req.handle_rate_limit=true
+      req.expects(:sleep).never.with(any_parameters)
+      req.execute(target_base_url=uri, username: "ted", secret: "")
+    end
+
+    it 'should call sleep for rate limit error just once' do
+      # Use webmock to mock the HTTP request
+      stub_request(:any, uri).\
+      to_return(status: [429, "Too Many Requests"], headers: { 'X-RateLimit-Reset' => Time.now.utc + 10 }).\
+      then.to_return(status: [200, "OK"])
+      req = Intercom::Request.get(uri, "")
+      req.handle_rate_limit=true
+      req.expects(:sleep).with(any_parameters)
+      req.execute(target_base_url=uri, username: "ted", secret: "")
+    end
+
+  end
+
   it 'parse_body returns nil if decoded_body is nil' do
     response = OpenStruct.new(:code => 500)
     req = Intercom::Request.new('path/', 'GET')
-    req.parse_body(nil, response).must_equal(nil)
+    assert_nil(req.parse_body(nil, response))
   end
 end