shopify_api_retry 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6fa48159d2bd071e31e86baf44caa8c15050a0667b7ae8644883421f1187292
-  data.tar.gz: c87b2749f3ba8c6a94b210a393833622efcfa2c27e5afdda8b3c593632fc516a
+  metadata.gz: 984c779f4d3aaa7e07881169dad03f42417e85da7467a68e4301762b417e8a82
+  data.tar.gz: a85e72b9ebd882d2c9a40f394b6669303e4b02880e4f9077bb7594eef4f14257
 SHA512:
-  metadata.gz: d246a7623ae0a810c1f1051f5887f65b16e08a80c69e4574c7d72cd4286cb29d04b40d3211fdcec0b517a6f3c9ebfd3d428092ee98d80353d9a3ee713d84dd89
-  data.tar.gz: 649b825c24075f79e1fba6daee7f7952c5f8a42bfed29eae1cfd1a576cbcf49de8bc325498aa3d5bd210615259104a96505059b31f913a70b93ce46f531c49ca
+  metadata.gz: deea19e090d2189044a9d81b425428723fd49b76f5b35f0623aa0b11fd142bcd2f07f5e4001b4e790cbf087afc217067c0efcc4b2c0af16c1ff7755c36e171c2
+  data.tar.gz: fe7621c89dec61b46d7970a077e323e4fa6518acb4a8372f69c8212eaca619c673699e99e3bd32f8c8446e1ae9c57fc92de03cdd3f7d508600c0ccf6c0462a1c

data/Changes

@@ -1,3 +1,9 @@
+--------------------
+2021-05-08  v0.1.3
+--------------------
+* Add support for retrying GraphQL requests
+* Mark ShopifyAPIRetry.retry as deprecated
+
 --------------------
 2021-03-11  v0.1.2
 --------------------

data/README.md

@@ -2,8 +2,8 @@
 
 ![CI](https://github.com/ScreenStaring/shopify_api_retry/workflows/CI/badge.svg)
 
-Simple Ruby module to retry a [Shopify API request](https://github.com/Shopify/shopify_api) if rate limited (HTTP 429) or other errors
-occur.
+Simple Ruby module to retry a [`ShopifyAPI` request](https://github.com/Shopify/shopify_api) if rate-limited or other errors
+occur. Works with the REST and GraphQL APIs.
 
 ## Installation
 
@@ -21,7 +21,9 @@ gem install shopify_api_retry
 
 ## Usage
 
-By default requests are retried when a Shopify rate limit error is returned. The retry happens once after waiting for
+### REST API
+
+By default requests are retried when a Shopify rate limit error (HTTP 429) is returned. The retry happens once after waiting for
 [the seconds given by the HTTP `Retry-After` header](https://shopify.dev/concepts/about-apis/rate-limits):
 ```rb
 require "shopify_api_retry" # requires "shopify_api" for you
@@ -35,7 +37,7 @@ You can override this:
 ShopifyAPIRetry.retry(:wait => 3, :tries => 5) { customer.update_attribute(:tags, "foo")  }
 ```
 This will try the request 5 times, waiting 3 seconds between each attempt. If a retry fails after the given number
-of `:tries` the original error will be raised.
+of `:tries` the last error will be raised.
 
 You can also retry requests when other errors occur:
 ```rb
@@ -52,7 +54,58 @@ ShopifyAPIRetry.retry SocketError => { :wait => 1, :tries => 5 } do
 end
 ```
 
-Global defaults can be set as well:
+You can also set [global defaults](#global-defaults).
+
+### GraphQL API
+
+By default a retry attempt is made when your [GraphQL request is rate-limited](https://shopify.dev/concepts/about-apis/rate-limits#graphql-admin-api-rate-limits).
+In order to calculate the proper amount of time to wait before retrying you must set the `X-GraphQL-Cost-Include-Fields` header
+(_maybe this library should do this?_):
+
+```rb
+require "shopify_api_retry" # requires "shopify_api" for you
+
+ShopifyAPI::Base.headers["X-GraphQL-Cost-Include-Fields"] = "true"
+```
+
+Once this is set run your queries and mutations and rate-limited requests will be retried.
+The retry happens once, calculating the wait time from the API's cost data:
+```rb
+result = ShopifyAPIRetry::GraphQL.retry { ShopifyAPI::GraphQL.client.query(YOUR_QUERY) }
+p result.data.whatever
+```
+
+To calculate the retry time **the query's return value must be returned by the block**.
+
+You can override the retry times:
+```rb
+result = ShopifyAPIRetry::GraphQL.retry(:wait => 4, :tries => 4) do
+  ShopifyAPI::GraphQL.client.query(YOUR_QUERY)
+end
+p result.data.whatever
+```
+
+Like retry attempts made with the REST API you can specify errors to retry but, due to the GraphQL specification, these must not
+be HTTP status codes and are only relevant to network connection-related errors:
+
+```rb
+result = ShopifyAPIRetry::GraphQL.retry SocketError => { :wait => 1, :tries => 5 } do
+  ShopifyAPI::GraphQL.client.query(YOUR_QUERY)
+end
+```
+
+To give wait and try times for specifically for rate limit errors, use the key `:graphql`:
+```rb
+result = ShopifyAPIRetry::GraphQL.retry :graphql => { :wait => 10, :tries => 5 } do
+  ShopifyAPI::GraphQL.client.query(YOUR_QUERY)
+end
+```
+
+Note that specifying a `:wait` via `:graphql` or without an error key will skip calculating the retry based on the API
+response's cost data.
+
+### Global Defaults
+
 ```rb
 ShopifyAPIRetry.configure do |config|
   config.default_wait  = 2.5
@@ -63,8 +116,6 @@ ShopifyAPIRetry.configure do |config|
 
   config.on SocketError, :tries => 2, :wait => 1
 end
-
-ShopifyAPIRetry.retry { customer.update_attribute(:tags, "foo")  }
 ```
 
 ## License

data/lib/shopify_api_retry.rb

@@ -3,12 +3,9 @@
 require "shopify_api"
 
 module ShopifyAPIRetry
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 
-  HTTP_RETRY_AFTER = "Retry-After"
-  HTTP_RETRY_STATUS = "429"
-
-  class Config
+  class Config                  # :nodoc:
     attr_writer :default_wait
     attr_writer :default_tries
 
@@ -40,8 +37,38 @@ module ShopifyAPIRetry
       @default_tries = nil
     end
 
+    def merge(userconfig)
+      config = to_h
+      return config unless userconfig
+
+      if userconfig.is_a?(Integer)
+        warn "#{self.class}: using an Integer for the retry time is deprecated and will be removed, use :wait => #{userconfig} instead"
+        userconfig = { :wait => userconfig }
+      elsif !userconfig.is_a?(Hash)
+        raise ArgumentError, "config must be a Hash"
+      end
+
+      userconfig.each do |k, v|
+        if v.is_a?(Hash)
+          config[k.to_s] = v.dup
+        else
+          config["graphql"][k] = config[REST::HTTP_RETRY_STATUS][k] = v
+        end
+      end
+
+      config.values.each do |cfg|
+        raise ArgumentError, "seconds to wait must be >= 0" if cfg[:wait] && cfg[:wait] < 0
+      end
+
+      config
+    end
+
     def to_h
-      settings = { HTTP_RETRY_STATUS => { :tries => default_tries, :wait => default_wait } }
+      settings = {
+        "graphql" => { :tries => default_tries, :wait => default_wait },
+        REST::HTTP_RETRY_STATUS => { :tries => default_tries, :wait => default_wait }
+      }
+
       @settings.each_with_object(settings) { |(k, v), o| o[k.to_s] = v.dup }
     end
   end
@@ -58,75 +85,123 @@ module ShopifyAPIRetry
     @config
   end
 
-  #
-  # Execute the provided block. If an HTTP 429 response is returned try
-  # it again. If any errors are provided try them according to their wait/return spec.
-  #
-  # If no spec is provided the value of the HTTP header <code>Retry-After</code>
-  # is waited for before retrying. If it's not given (it always is) +2+ is used.
-  #
-  # If retry fails the original error is raised.
-  #
-  # Returns the value of the block.
-  #
-  def retry(cfg = nil)
-    raise ArgumentError, "block required" unless block_given?
-
-    attempts = build_config(cfg)
-
-    begin
-      result = yield
-    rescue => e
-      handler = attempts[e.class.name]
-      raise if handler.nil? && (!e.is_a?(ActiveResource::ConnectionError) || !e.response.respond_to?(:code))
-
-      handler ||= attempts[e.response.code] || attempts["#{e.response.code[0]}XX"]
-      handler[:wait] ||= e.response[HTTP_RETRY_AFTER] || config.default_wait if e.response.code == HTTP_RETRY_STATUS
+  class Request                 # :nodoc:
+    def self.retry(cfg = nil, &block)
+      new(cfg).retry(&block)
+    end
+
+    def initialize(cfg = nil)
+      @handlers = ShopifyAPIRetry.config.merge(cfg)
+    end
+
+    def retry(&block)
+      raise ArgumentError, "block required" unless block_given?
 
+      begin
+        result = request(&block)
+      rescue => e
+        handler = find_handler(e)
+        raise unless handler && snooze(handler)
+
+        retry
+      end
+
+      result
+    end
+
+    protected
+
+    attr_reader :handlers
+
+    def request
+      yield
+    end
+
+    def find_handler(error)
+      @handlers[error.class.name]
+    end
+
+    def snooze(handler)
       handler[:attempts] ||= 1
-      raise if handler[:attempts] == handler[:tries]
+      return false if handler[:attempts] == handler[:tries]
 
-      snooze = handler[:wait].to_i
+      snooze = handler[:wait].to_f
       waited = sleep snooze
-      snooze -= waited
-      # Worth looping?
+      snooze = snooze - waited
+      # sleep returns the rounded time slept but sometimes it's rounded up, others it's down
+      # given this, we may sleep for more than requested
       sleep snooze if snooze > 0
 
       handler[:attempts] += 1
 
-      retry
+      true
     end
-
-    result
   end
 
-  module_function :retry
+  class REST < Request
+    HTTP_RETRY_AFTER = "Retry-After"
+    HTTP_RETRY_STATUS = "429"
+
+    protected
 
-  def self.build_config(userconfig)
-    config = ShopifyAPIRetry.config.to_h
-    return config unless userconfig
+    def find_handler(error)
+      handler = super
+      return handler if handler || (!error.is_a?(ActiveResource::ConnectionError) || !error.response.respond_to?(:code))
 
-    if userconfig.is_a?(Integer)
-      userconfig = { :wait => config }
-      warn "passing an Integer to retry is deprecated and will be removed, use :wait => #{config} instead"
-    elsif !userconfig.is_a?(Hash)
-      raise ArgumentError, "config must be a Hash"
+      handler = handlers[error.response.code] || handlers["#{error.response.code[0]}XX"]
+      handler[:wait] ||= error.response[HTTP_RETRY_AFTER] || config.default_wait if error.response.code == HTTP_RETRY_STATUS
+
+      handler
     end
+  end
 
-    userconfig.each do |k, v|
-      if v.is_a?(Hash)
-        config[k.to_s] = v.dup
-      else
-        config[HTTP_RETRY_STATUS][k] = v
+  class GraphQL < Request
+    CONVERSION_WARNING = "#{name}.retry: skipping retry, cannot convert GraphQL response to a Hash: %s. " \
+                         "To retry requests your block's return value must be a Hash or something that can be converted via #to_h"
+    protected
+
+    def request
+      loop do
+        data = og_data = yield
+
+        # Shopify's client does not return a Hash but
+        # technically we work with any Hash response
+        unless data.is_a?(Hash)
+          unless data.respond_to?(:to_h)
+            warn CONVERSION_WARNING % "respond_to?(:to_h) is false"
+            return og_data
+          end
+
+          begin
+            data = data.to_h
+          rescue TypeError, ArgumentError => e
+            warn CONVERSION_WARNING % e.message
+            return og_data
+          end
+        end
+
+        cost = data.dig("extensions", "cost")
+        # If this is nil then the X-GraphQL-Cost-Include-Fields header was not set
+        # If actualQueryCost is present then the query was not rate limited
+        return og_data if cost.nil? || cost["actualQueryCost"]
+
+        handler = handlers["graphql"]
+        handler[:wait] ||= sleep_time(cost)
+
+        return og_data unless snooze(handler)
       end
     end
 
-    config.values.each do |cfg|
-      raise ArgumentError, "seconds to wait must be >= 0" if cfg[:wait] && cfg[:wait] < 0
+    def sleep_time(cost)
+      status = cost["throttleStatus"]
+      (cost["requestedQueryCost"] - status["currentlyAvailable"]) / status["restoreRate"]# + 0.33
     end
+  end
 
-    config
+  def retry(cfg = nil, &block)
+    warn "#{name}.retry has been deprecated, use ShopifyAPIRetry::REST.retry or ShopifyAPIRetry::GraphQL.retry"
+    REST.new(cfg).retry(&block)
   end
 
-  private_class_method :build_config
+  module_function :retry
 end

data/shopify_api_retry.gemspec

@@ -1,11 +1,10 @@
 Gem::Specification.new do |spec|
   spec.name          = "shopify_api_retry"
-  spec.version       = "0.1.2"
+  spec.version       = "0.1.3"
   spec.authors       = ["Skye Shaw"]
   spec.email         = ["skye.shaw@gmail.com"]
 
-  spec.summary       = %q{Retry a ShopifyAPI request if an HTTP 429 (too many requests) is returned}
-  spec.description   = %q{Simple module to retry a ShopifyAPI request if an HTTP 429 (too many requests) is returned. No monkey patching.}
+  spec.summary       = %q{Retry a ShopifyAPI request if if rate-limited or other errors occur. Works with the REST and GraphQL APIs.}
   spec.homepage      = "https://github.com/ScreenStaring/shopify_api_retry"
   spec.license       = "MIT"
 
@@ -18,6 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 2.3"
   spec.add_dependency "shopify_api", ">= 4.0"
 
   spec.add_development_dependency "minitest", "~> 5.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify_api_retry
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Skye Shaw
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2021-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shopify_api
@@ -66,8 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.0'
-description: Simple module to retry a ShopifyAPI request if an HTTP 429 (too many
-  requests) is returned. No monkey patching.
+description: 
 email:
 - skye.shaw@gmail.com
 executables: []
@@ -96,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -107,5 +106,6 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: Retry a ShopifyAPI request if an HTTP 429 (too many requests) is returned
+summary: Retry a ShopifyAPI request if if rate-limited or other errors occur. Works
+  with the REST and GraphQL APIs.
 test_files: []