4me-sdk 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5709d9ce126fa6349fdff96ab4a2dd1c80b8653a
-  data.tar.gz: 56ea4d39c7dce6e5c0578f0eb5ab1bbeb154622d
+  metadata.gz: 2fb299375b12d3219de2b62186c08d386ab35c15
+  data.tar.gz: fec7a3b7d9f0da1bc33845aeb80a909941911428
 SHA512:
-  metadata.gz: 754794a8253b590ddfd4064d2d96e9bae96597ab89c0169c6ebdb7fc8db4dd9035e7a0770be6f6644cff362a9f0dc5e061cb3992e15e6502556921bbdd997c5a
-  data.tar.gz: 80eaad3b45968a8ca3e1ce3afa4a6750c74105ba188122e1bcaf800ea87c64ab63c88893d70ee32793bf8bc19b22a38f5cec830935c153a03ccb978c83fb1607
+  metadata.gz: b32a2e7eec8c40b1889ab72555586370bce6080fbff9ea74bc3bd3e7d63709fe456b73b8250a35c7a7f59f30c4755e1a9c1fd79f513372bd611a27965e513330
+  data.tar.gz: a8bc3da3ef888716c14d9fe44c75b22c797e4732e52314b6c1efb76c5401661877e1613d311ad675cb400a6755fce0de0f53e9799566f15cab5c4699a3b7e48a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    4me-sdk (1.1.5)
+    4me-sdk (1.1.6)
       activesupport (>= 4.2)
       gem_config (>= 0.3)
       mime-types (>= 3.0)

data/README.md

@@ -37,13 +37,14 @@ All options available:
 * _api_token_:      (**required**) The [4me API token](http://developer.4me.com/v1/#api-tokens)
 * _account_:        Specify a [different account](http://developer.4me.com/v1/#multiple-accounts) to work with
 * _source_:         The [source](http://developer.4me.com/v1/general/source/) used when creating new records
-* _max_retry_time_: maximum nr of seconds to wait for server to respond (default = 5400 = 1.5 hours)<br/>
+* _max_retry_time_: maximum nr of seconds to retry a request on a failed response (default = 300 = 5 minutes)<br/>
   The sleep time between retries starts at 2 seconds and doubles after each retry, i.e.
-  2, 6, 18, 54, 162, 486, 1458, 4374, 13122, ... seconds.<br/>
+  2, 6, 18, 54, 162, 486, 1458, ... seconds.<br/>
   Set to 0 to prevent retries.
 * _read_timeout_:   [HTTP read timeout](http://ruby-doc.org/stdlib-2.0.0/libdoc/net/http/rdoc/Net/HTTP.html#method-i-read_timeout-3D) in seconds (default = 25)
-* _block_at_rate_limit_: Set to `true` to block the request until the [rate limit](http://developer.4me.com/v1/#rate-limiting) is lifted, default: `false`<br/>
-  The `Retry-After` header is used to compute when the retry should be performed. If that moment is later than the _max_retry_time_ the request will not be blocked and the throttled response is returned. 
+* _block_at_rate_limit_: Set to `true` to block the request until the [rate limit](http://developer.4me.com/v1/#rate-limiting) is lifted, default: `true`<br/>
+  The `Retry-After` header is used to compute when the retry should be performed. If that moment is later than the _max_throttle_time_ the request will not be blocked and the throttled response is returned. 
+* _max_throttle_time_: maximum nr of seconds to retry a request on a rate limiter (default = 3660 = 1 hour and 1 minute)<br/>
 * _proxy_host_:     Define in case HTTP traffic needs to go through a proxy
 * _proxy_port_:     Port of the proxy, defaults to 8080
 * _proxy_user_:     Proxy user
@@ -305,10 +306,17 @@ Note that blocking for the export to finish is recommended as you will get direc
 
 ### Blocking
 
-By default all actions on the 4me SDK Client will block until the 4me API is accessible, see the _max_retry_time_ option in the [configuration](#configuration). This is especially helpfull for flaky internet connections.
+When the currently used API token hits the [4me rate limiter](http://developer.4me.com/v1/#rate-limiting) a HTTP 429 response is returned that specifies after how many seconds the rate limit will be lifted.
 
-By setting the _block_at_rate_limit_ to `true` in the [configuration](#configuration) all actions will also block in case the [rate limit](http://developer.4me.com/v1/#rate-limiting) is reached. The action is retried every 5 minutes until the [rate limit](http://developer.4me.com/v1/#rate-limiting) is lifted again, which might take up to 1 hour.
+If that time lies within the _max_throttle_time_ the 4me SDK Client will wait and retry the action, if not, the throttled response will be returned. You can verify if a response was throttled using:
+```
+response = client.get('me')
+puts response.throttled?
+```
+
+By setting the _block_at_rate_limit_ to `false` in the [configuration](#configuration) the 4me SDK Client will never wait when a rate limit is hit.
 
+Note that 4me has different rate limiters. If the intention is to only wait when the short-burst (max 20 requests in 2 seconds) rate limiter is hit, you could set the _max_throttle_time_ to e.g. 5 seconds.
 
 ### Translations
 

data/lib/sdk4me.rb

@@ -14,10 +14,10 @@ module Sdk4me
     has :account, classes: String
     has :source, classes: String
 
-    has :max_retry_time, classes: Integer, default: 5400
+    has :max_retry_time, classes: Integer, default: 300
     has :read_timeout, classes: Integer, default: 25
-    has :block_at_rate_limit, classes: [TrueClass, FalseClass], default: false
-
+    has :block_at_rate_limit, classes: [TrueClass, FalseClass], default: true
+    has :max_throttle_time, classes: Integer, default: 3660
     has :proxy_host, classes: String
     has :proxy_port, classes: Integer, default: 8080
     has :proxy_user, classes: String

data/lib/sdk4me/client.rb

@@ -300,16 +300,16 @@ module Sdk4me
   module SendWithRateLimitBlock
     # Wraps the _send method with retries when the server does not respond, see +initialize+ option +:rate_limit_block+
     def _send(request, domain = @domain, port = @port, ssl = @ssl)
-      return super(request, domain, port, ssl) unless option(:block_at_rate_limit)
-      now = Time.now
+      return super(request, domain, port, ssl) unless option(:block_at_rate_limit) && option(:max_throttle_time) > 0
+      now = nil
       timed_out = false
-      # respect the max_retry_time with fallback to max 1 hour and 1 minute wait time
-      max_retry_time = option(:max_retry_time) > 0 ? option(:max_retry_time) : 3660
       begin
         _response = super(request, domain, port, ssl)
+        now ||= Time.now
         if _response.throttled?
+          # if no Retry-After is not provided, the 4me server is very busy, wait 5 minutes
           retry_after = _response.retry_after == 0 ? 300 : [_response.retry_after, 2].max
-          if (Time.now - now + retry_after) < max_retry_time
+          if (Time.now - now + retry_after) < option(:max_throttle_time)
             @logger.warn { "Request throttled, trying again in #{retry_after} seconds: #{_response.message}" }
             sleep(retry_after)
           else
@@ -328,12 +328,12 @@ module Sdk4me
       return super(request, domain, port, ssl) unless option(:max_retry_time) > 0
       retries = 0
       sleep_time = 1
-      now = Time.now
+      now = nil
       timed_out = false
       begin
         _response = super(request, domain, port, ssl)
-        # throttling is handled separately
-        if !_response.success? && !_response.throttled?
+        now ||= Time.now
+        if _response.failure?
           sleep_time *= 2
           if (Time.now - now + sleep_time) < option(:max_retry_time)
             @logger.warn { "Request failed, retry ##{retries += 1} in #{sleep_time} seconds: #{_response.message}" }
@@ -342,7 +342,7 @@ module Sdk4me
             timed_out = true
           end
         end
-      end while !_response.success? && !_response.throttled? && !timed_out
+      end while _response.failure? && !timed_out
       _response
     end
   end

data/lib/sdk4me/client/response.rb

@@ -59,6 +59,11 @@ module Sdk4me
     end
     alias_method :success?, :valid?
 
+    # +true+ in case of a HTTP 5xx error
+    def failure?
+      !success? && (@response.code.to_s.blank? || @response.code.to_s =~ /5\d\d/)
+    end
+
     # retrieve a value from the resource
     # if the JSON value is an Array a array with the value for each resource will be given
     # @param keys: a single key or a key-path separated by comma

data/lib/sdk4me/client/version.rb

@@ -1,5 +1,5 @@
 module Sdk4me
   class Client
-    VERSION = '1.1.5'
+    VERSION = '1.1.6'
   end
 end

data/spec/lib/sdk4me/client_spec.rb

@@ -528,7 +528,7 @@ describe Sdk4me::Client do
       expect_log('Sending GET request to api.4me.com:443/v1/me', :debug )
       expect_log(%(Response:\n{\n  "name": "my name"\n}), :debug )
 
-      client = Sdk4me::Client.new(api_token: 'secret', block_at_rate_limit: true)
+      client = Sdk4me::Client.new(api_token: 'secret', block_at_rate_limit: true, max_retry_time: 500)
       allow(client).to receive(:sleep)
       response = client.get('me')
       expect(stub).to have_been_requested.times(2)

data/spec/lib/sdk4me/response_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Sdk4me::Response do
   before(:each) do
-    @client = Sdk4me::Client.new(api_token: 'secret', max_retry_time: -1)
+    @client = Sdk4me::Client.new(api_token: 'secret', max_retry_time: -1, block_at_rate_limit: false)
     @person_hash = {
         addresses:[],
         contacts:[ {id: 1365, label: 'work', telephone: '7139872946'} ],
@@ -22,7 +22,6 @@ describe Sdk4me::Response do
     stub_request(:get, 'https://api.4me.com/v1/me').with(basic_auth: ['secret', 'x']).to_return(body: @person_hash.to_json)
     @response_hash = @client.get('me')
 
-    @client = Sdk4me::Client.new(api_token: 'secret', max_retry_time: -1)
     @people_array = [
         {id: 562, name: 'John', organization: { id: 20, name: 'SDK4ME Institute'}, site: {id: 14, name: 'IT Training Facility'} },
         {id: 560, name: 'Lucas', organization: { id: 20, name: 'SDK4ME Institute', office: { name: 'The Office'}}, site: {id: 14, name: 'IT Training Facility'} },

data/spec/lib/sdk4me_spec.rb

@@ -4,15 +4,15 @@ describe Sdk4me do
   it "should define a default configuration" do
     conf = Sdk4me.configuration.current
 
-    expect(conf.keys.sort).to eq([:account, :api_token, :api_version, :block_at_rate_limit, :ca_file, :host, :logger, :max_retry_time, :proxy_host, :proxy_password, :proxy_port, :proxy_user, :read_timeout, :source])
+    expect(conf.keys.sort).to eq([:account, :api_token, :api_version, :block_at_rate_limit, :ca_file, :host, :logger, :max_retry_time, :max_throttle_time, :proxy_host, :proxy_password, :proxy_port, :proxy_user, :read_timeout, :source])
 
     expect(conf[:logger].class).to eq(::Logger)
     expect(conf[:host]).to eq('https://api.4me.com')
     expect(conf[:api_version]).to eq('v1')
 
-    expect(conf[:max_retry_time]).to eq(5400)
+    expect(conf[:max_retry_time]).to eq(300)
     expect(conf[:read_timeout]).to eq(25)
-    expect(conf[:block_at_rate_limit]).to be_falsey
+    expect(conf[:block_at_rate_limit]).to be_truthy
 
     expect(conf[:proxy_port]).to eq(8080)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: 4me-sdk
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors:
 - 4me
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2019-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gem_config