gruf 2.4.2 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bef9466a137b8d52bc76a4d24c65fef26b0701cff21eefb2ae9811e020dd619c
-  data.tar.gz: f3209bfefd0e3a7fe7ee03b6bcc7a417974593b924966521346d095d87de6d5d
+  metadata.gz: a2452f173e2987612fde71b5e170874f52718e5a7f820658378c7a98e54f5b1f
+  data.tar.gz: bcbb20ab199f78fadd1926d1314fe881fccda9413f149ebb8ad1e4daeba259f8
 SHA512:
-  metadata.gz: 906fa455028407ea0ac54dceeb89c54b032ddf9e1090e85d14dabf8496aad91b22d19056fdf8e84d9836399518198ed7afffa50c1cc69ac9d8a4e5a43e53f40b
-  data.tar.gz: c3ec65443321ff6ac00b839bf3b6a9fed748e5f7ab2ec73ffd4476d1b4b7590ccd2d865ac4f5c6703a59c5ae89746b2964f58ee43e56c62a3df62e8bddae9271
+  metadata.gz: d9ae08c458006784a089c1390000870febe48a01e8e6be85673e343639ec8283410c76fa6110981916f1333bc3e49c499d845cb03551cf1ea42cab8b5455c2c1
+  data.tar.gz: 26833397af9630db7a6c3d0429ddcaaf63d84e076e8d6691719b2210b8f7523b3a89169e2826ad2f66d67dd64e313a31f87da423d5f4580c4b7ac6fc26fc54d7

data/CHANGELOG.md

@@ -2,6 +2,14 @@ Changelog for the gruf gem. This includes internal history before the gem was ma
 
 ### Pending release
 
+### 2.5.0
+
+- Client exceptions raised now contain mapped subclasses, such as `Gruf::Client::Errors::InvalidArgument`
+- Client exceptions will also now catch StandardError and GRPC::Core errors, and handle them as Internal errors
+- Added SynchronizedClient which prevents multiple calls to the same endpoint with the same params at
+  a given time. This is useful for mitigating thundering herds. To skip this behavior for certain endpoints,
+  pass the `options[:unsynchronized_methods]` param with a list of method names (as symbols).
+
 ### 2.4.2
 
 - Added error handling for GRPC::Core::CallError, a low-level error in the grpc library that does not inherit

data/README.md

@@ -48,7 +48,7 @@ Gruf.configure do |c|
 end
 ```
 
-If you don't explicitly set `default_client_host`, you will need to pass it into the client options, like so:
+If you don't explicitly set `default_client_host`, you will need to pass it into the options, like so:
 
 ```ruby
 client = ::Gruf::Client.new(service: ::Demo::ThingService, options: {hostname: 'grpc.service.com:9003'})
@@ -72,10 +72,46 @@ end
 
 Note this returns a response object. The response object can provide `trailing_metadata` as well as a `execution_time`.
 
+### SynchronizedClient
+
+SynchronizedClient wraps Client with some additional behavior to help prevent generating spikes
+of redundant requests. If multiple calls to the same endpoint with the same parameters are made,
+the first one will be executed and the following ones will block, waiting for the first result.
+
+```ruby
+require 'gruf'
+require 'thwait'
+
+id = args[:id].to_i.presence || 1
+client = ::Gruf::SynchronizedClient.new(service: ::Demo::ThingService)
+thread1 = Thread.new { client.call(:GetMyThing, id: id) }
+thread2 = Thread.new { client.call(:GetMyThing, id: id) }
+ThreadsWait.all_waits(thread1, thread2)
+```
+
+In the above example, thread1 will make the rpc call, thread2 will block until the call is complete, and then
+will get the same value without making a second rpc call.
+
+You can also skip this behavior for certain methods if desired.
+
+```ruby
+require 'gruf'
+require 'thwait'
+
+id = args[:id].to_i.presence || 1
+client = ::Gruf::SynchronizedClient.new(service: ::Demo::ThingService, options: { unsynchronized_methods: [:GetMyThing] })
+thread1 = Thread.new { client.call(:GetMyThing, id: id) }
+thread2 = Thread.new { client.call(:GetMyThing, id: id) }
+ThreadsWait.all_waits(thread1, thread2)
+```
+
+In the above example, thread1 and thread2 will make rpc calls in parallel, in the same way as if you had used
+`Gruf::Client`.
+
 ### Client Interceptors
 
 Gruf comes with an assistance class for client interceptors that you can use - or you can use the native gRPC core
-interceptors. Either way, you pass them into the client_options when creating a client:
+interceptors. Either way, you pass them into the `client_options` when creating a client:
 
 ```ruby
 class MyInterceptor < Gruf::Interceptors::ClientInterceptor
@@ -487,7 +523,7 @@ gruf that you can use today:
 
 * [gruf-zipkin](https://github.com/bigcommerce/gruf-zipkin) - Provides a [Zipkin](https://zipkin.io)
 integration
-* [gruf-lightstep](https://github.com/bigcommerce/gruf-lightstep) - Provides a seamless 
+* [gruf-lightstep](https://github.com/bigcommerce/gruf-lightstep) - Provides a seamless
 [LightStep](https://lightstep.com) integration
 * [gruf-circuit-breaker](https://github.com/bigcommerce/gruf-circuit-breaker) - Circuit breaker
 support for services

data/gruf.gemspec

@@ -39,5 +39,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'grpc', '~> 1.10'
   spec.add_runtime_dependency 'grpc-tools', '~> 1.10'
   spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'concurrent-ruby'
   spec.add_runtime_dependency 'slop', '~> 4.6'
 end

data/lib/gruf.rb

@@ -32,6 +32,7 @@ require_relative 'gruf/timer'
 require_relative 'gruf/response'
 require_relative 'gruf/error'
 require_relative 'gruf/client'
+require_relative 'gruf/synchronized_client'
 require_relative 'gruf/instrumentable_grpc_server'
 require_relative 'gruf/server'
 

data/lib/gruf/client.rb

@@ -13,6 +13,9 @@
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
+require_relative 'client/error'
+require_relative 'client/error_factory'
+
 module Gruf
   ##
   # Abstracts out the calling interface for interacting with gRPC clients. Streamlines calling and provides
@@ -33,25 +36,6 @@ module Gruf
   class Client < SimpleDelegator
     include Gruf::Loggable
 
-    ##
-    # Represents an error that was returned from the server's trailing metadata. Used as a custom exception object
-    # that is instead raised in the case of the service returning serialized error data, as opposed to the normal
-    # GRPC::BadStatus error
-    #
-    class Error < StandardError
-      # @return [Object] error The deserialized error
-      attr_reader :error
-
-      ##
-      # Initialize the client error
-      #
-      # @param [Object] error The deserialized error
-      #
-      def initialize(error)
-        @error = error
-      end
-    end
-
     # @return [Class] The base, friendly name of the service being requested
     attr_reader :base_klass
     # @return [Class] The class name of the gRPC service being requested
@@ -74,6 +58,7 @@ module Gruf
       @opts = options || {}
       @opts[:password] = options.fetch(:password, '').to_s
       @opts[:hostname] = options.fetch(:hostname, Gruf.default_client_host)
+      @error_factory = Gruf::Client::ErrorFactory.new
       client = "#{service}::Stub".constantize.new(@opts[:hostname], build_ssl_credentials, client_options)
       super(client)
     end
@@ -98,16 +83,11 @@ module Gruf
 
       raise NotImplementedError, "The method #{request_method} has not been implemented in this service." unless call_sig
 
-      resp = execute(call_sig, req, md, opts, &block)
+      resp, operation = execute(call_sig, req, md, opts, &block)
+
+      raise @error_factory.from_exception(resp.result) unless resp.success?
 
-      Gruf::Response.new(resp.result, resp.time)
-    rescue GRPC::BadStatus => e
-      emk = Gruf.error_metadata_key.to_s
-      raise Gruf::Client::Error, error_deserializer_class.new(e.metadata[emk]).deserialize if e.respond_to?(:metadata) && e.metadata.key?(emk)
-      raise # passthrough
-    rescue StandardError => e
-      Gruf.logger.error e.message
-      raise
+      Gruf::Response.new(operation: operation, message: resp.result, execution_time: resp.time)
     end
 
     ##
@@ -137,13 +117,17 @@ module Gruf
     # @param [Object] req (Optional) The protobuf request message to send
     # @param [Hash] metadata (Optional) A hash of metadata key/values that are transported with the client request
     # @param [Hash] opts (Optional) A hash of options to send to the gRPC request_response method
+    # @return [Array<Gruf::Timer::Result, GRPC::ActiveCall::Operation>]
     #
     def execute(call_sig, req, metadata, opts = {}, &block)
-      Timer.time do
+      operation = nil
+      result = Gruf::Timer.time do
         opts[:return_op] = true
         opts[:metadata] = metadata
-        send(call_sig, req, opts, &block)
+        operation = send(call_sig, req, opts, &block)
+        operation.execute
       end
+      [result, operation]
     end
 
     ##

data/lib/gruf/client/error.rb

@@ -0,0 +1,64 @@
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module Gruf
+  class Client < SimpleDelegator
+    ##
+    # Represents an error that was returned from the server's trailing metadata. Used as a custom exception object
+    # that is instead raised in the case of the service returning serialized error data, as opposed to the normal
+    # GRPC::BadStatus error
+    #
+    class Error < StandardError
+      # @return [Object] error The deserialized error
+      attr_reader :error
+
+      ##
+      # Initialize the client error
+      #
+      # @param [Object] error The deserialized error
+      #
+      def initialize(error)
+        @error = error
+      end
+    end
+
+    ##
+    # See https://github.com/grpc/grpc-go/blob/master/codes/codes.go for a detailed summary of each error type
+    #
+    module Errors
+      class Base < Gruf::Client::Error; end
+      class Error < Base; end
+      class Validation < Base; end
+
+      class Ok < Base; end
+
+      class InvalidArgument < Validation; end
+      class NotFound < Validation; end
+      class AlreadyExists < Validation; end
+      class OutOfRange < Validation; end
+
+      class Cancelled < Error; end
+      class DataLoss < Error; end
+      class DeadlineExceeded < Error; end
+      class FailedPrecondition < Error; end
+      class Internal < Error; end
+      class PermissionDenied < Error; end
+      class Unauthenticated < Error; end
+      class Unavailable < Error; end
+      class Unimplemented < Error; end
+      class Unknown < Error; end
+    end
+  end
+end

data/lib/gruf/client/error_factory.rb

@@ -0,0 +1,99 @@
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module Gruf
+  class Client < SimpleDelegator
+    ##
+    # Translates exceptions into Gruf::Client::Errors
+    #
+    class ErrorFactory
+      ##
+      # @param [Class] default_class
+      # @param [Class] deserializer_class
+      # @param [String|Symbol] metadata_key
+      #
+      def initialize(
+        default_class: nil,
+        deserializer_class: nil,
+        metadata_key: nil
+      )
+        @default_class = default_class || Gruf::Client::Errors::Internal
+        @metadata_key = (metadata_key || Gruf.error_metadata_key).to_s
+        default_serializer = if Gruf.error_serializer
+                               Gruf.error_serializer.is_a?(Class) ? Gruf.error_serializer : Gruf.error_serializer.to_s.constantize
+                             else
+                               Gruf::Serializers::Errors::Json
+                             end
+        @deserializer_class = deserializer_class || default_serializer
+      end
+
+      ##
+      # Determine the proper error class to raise given the incoming exception. This will attempt to coalesce the
+      # exception object into the appropriate Gruf::Client::Errors subclass, or fallback to the default class if none
+      # is found (or it is a StandardError or higher-level error). It will leave alone Signals instead of attempting to
+      # coalesce them.
+      #
+      # @param [Exception] exception
+      # @return [Gruf::Client::Errors::Base|SignalException]
+      #
+      def from_exception(exception)
+        # passthrough on Signals, we don't want to mess with these
+        return exception if exception.is_a?(SignalException)
+
+        exception_class = determine_class(exception)
+        if exception.is_a?(GRPC::BadStatus)
+          # if it's a GRPC::BadStatus code, let's check for any trailing error metadata and decode it
+          exception_class.new(deserialize(exception))
+        else
+          # otherwise, let's just capture the error and build the wrapper class
+          exception_class.new(exception)
+        end
+      end
+
+      private
+
+      ##
+      # Deserialize any trailing metadata error payload from the exception
+      #
+      # @param [Gruf::Client::Errors::Base]
+      # @return [String]
+      #
+      def deserialize(exception)
+        if exception.respond_to?(:metadata)
+          key = exception.metadata.key?(@metadata_key.to_s) ? @metadata_key.to_s : @metadata_key.to_sym
+          return @deserializer_class.new(exception.metadata[key]).deserialize if exception.metadata.key?(key)
+        end
+
+        exception
+      end
+
+      ##
+      # @param [Exception] exception
+      # @return [Gruf::Client::Errors::Base]
+      #
+      def determine_class(exception)
+        error_class = Gruf::Client::Errors.const_get(exception.class.name.demodulize)
+
+        # Ruby module inheritance will have StandardError, ScriptError, etc still get to this point
+        # So we need to explicitly check for ancestry here
+        return @default_class unless error_class.ancestors.include?(Gruf::Client::Errors::Base)
+
+        error_class
+      rescue NameError => _
+        @default_class
+      end
+    end
+  end
+end

data/lib/gruf/configuration.rb

@@ -40,6 +40,7 @@ module Gruf
       use_exception_message: true,
       internal_error_message: 'Internal Server Error',
       event_listener_proc: nil,
+      synchronized_client_internal_cache_expiry: 60,
       rpc_server_options: {
         pool_size: GRPC::RpcServer::DEFAULT_POOL_SIZE,
         max_waiting_requests: GRPC::RpcServer::DEFAULT_MAX_WAITING_REQUESTS,

data/lib/gruf/interceptors/instrumentation/request_logging/interceptor.rb

@@ -78,7 +78,7 @@ module Gruf
             end
 
             payload = {}
-            if !request.client_streamer?
+            if !request.client_streamer? && !request.bidi_streamer?
               payload[:params] = sanitize(request.message.to_h) if options.fetch(:log_parameters, false)
               payload[:message] = message(request, result)
               payload[:status] = status(result.message, result.successful?)
@@ -87,6 +87,7 @@ module Gruf
               payload[:message] = ''
               payload[:status] = GRPC::Core::StatusCodes::OK
             end
+
             payload[:service] = request.service_key
             payload[:method] = request.method_key
             payload[:action] = request.method_key

data/lib/gruf/response.rb

@@ -35,11 +35,12 @@ module Gruf
     # Initialize a response object with the given gRPC operation
     #
     # @param [GRPC::ActiveCall::Operation] operation The given operation for the current call
+    # @param [StdClass] message
     # @param [Float] execution_time The amount of time that the response took to occur
     #
-    def initialize(operation, execution_time = nil)
+    def initialize(operation:, message:, execution_time: nil)
       @operation = operation
-      @message = operation.execute
+      @message = message
       @metadata = operation.metadata
       @trailing_metadata = operation.trailing_metadata
       @deadline = operation.deadline

data/lib/gruf/synchronized_client.rb

@@ -0,0 +1,93 @@
+# Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+require 'concurrent'
+
+module Gruf
+  ##
+  # Ensures that we only have one active call to a given endpoint with a given set of params. This can be useful
+  # to mitigate thundering herds.
+  #
+  class SynchronizedClient < Gruf::Client
+    attr_reader :unsynchronized_methods
+
+    ##
+    # Initialize the client and setup the stub
+    #
+    # @param [Module] service The namespace of the client Stub that is desired to load
+    # @param [Hash] options A hash of options for the client
+    # @option options [Array] :unsynchronized_methods A list of methods (as symbols) that should be excluded from synchronization
+    # @option options [Integer] :internal_cache_expiry The length of time to keep results around for other threads to fetch (in seconds)
+    # @param [Hash] client_options A hash of options to pass to the gRPC client stub
+    #
+    def initialize(service:, options: {}, client_options: {})
+      @unsynchronized_methods = options.delete(:unsynchronized_methods) { [] }
+      @expiry = options.delete(:internal_cache_expiry) { Gruf.synchronized_client_internal_cache_expiry }
+      @locks = Concurrent::Map.new
+      @results = Concurrent::Map.new
+      super
+    end
+
+    ##
+    # Call the client's method with given params. If another call is already active for the same endpoint and the same
+    # params, block until the active call is complete. When unblocked, callers will get a copy of the original result.
+    #
+    # @param [String|Symbol] request_method The method that is being requested on the service
+    # @param [Hash] params (Optional) A hash of parameters that will be inserted into the gRPC request message that is required
+    # for the given above call
+    # @param [Hash] metadata (Optional) A hash of metadata key/values that are transported with the client request
+    # @param [Hash] opts (Optional) A hash of options to send to the gRPC request_response method
+    # @return [Gruf::Response] The response from the server
+    # @raise [Gruf::Client::Error|GRPC::BadStatus] If an error occurs, an exception will be raised according to the
+    # error type that was returned
+    #
+    def call(request_method, params = {}, metadata = {}, opts = {}, &block)
+      # Allow for bypassing extra behavior for selected methods
+      return super if unsynchronized_methods.include?(request_method.to_sym)
+
+      # Generate a unique key based on the method and params
+      key = "#{request_method}.#{params.hash}"
+
+      # Create a lock for this call if we haven't seen it already, then acquire it
+      lock = @locks.compute_if_absent(key) { Mutex.new }
+      lock.synchronize do
+        # Return value from results cache if it exists. This occurs for callers that were
+        # waiting on the lock while the first caller was making the actual grpc call.
+        response = @results.get(lock)
+        if response
+          Gruf.logger.debug "Returning cached result for #{key}:#{lock.inspect}"
+          next response
+        end
+
+        # Make the grpc call and record response for other callers that are blocked
+        # on the same lock
+        response = super
+        @results.put(lock, response)
+
+        # Schedule a task to come in later and clean out result to prevent memory bloat
+        Concurrent::ScheduledTask.new(@expiry, args: [@results, lock]) { |h, k| h.delete(k) }.execute
+
+        # Remove the lock from the map. The next caller to come through with the
+        # same params will create a new lock and start the process over again.
+        # Anyone who was waiting on this call will be using a local reference
+        # to the same lock as us, and will fetch the result from the cache.
+        @locks.delete(key)
+
+        # Return response
+        response
+      end
+    end
+  end
+end

data/lib/gruf/timer.rb

@@ -50,7 +50,7 @@ module Gruf
       # @return [Boolean] Whether or not this result was a success
       #
       def success?
-        !result.is_a?(GRPC::BadStatus)
+        !result.is_a?(GRPC::BadStatus) && !result.is_a?(StandardError) && !result.is_a?(GRPC::Core::CallError)
       end
     end
 
@@ -65,7 +65,7 @@ module Gruf
       start_time = Time.now
       begin
         result = yield
-      rescue GRPC::BadStatus => e
+      rescue GRPC::BadStatus, StandardError, GRPC::Core::CallError => e
         result = e
       end
       end_time = Time.now

data/lib/gruf/version.rb

@@ -14,5 +14,5 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 module Gruf
-  VERSION = '2.4.2'.freeze
+  VERSION = '2.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gruf
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.5.0
 platform: ruby
 authors:
 - Shaun McCormick
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-07 00:00:00.000000000 Z
+date: 2018-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +138,8 @@ files:
 - lib/gruf.rb
 - lib/gruf/cli/executor.rb
 - lib/gruf/client.rb
+- lib/gruf/client/error.rb
+- lib/gruf/client/error_factory.rb
 - lib/gruf/configuration.rb
 - lib/gruf/controllers/base.rb
 - lib/gruf/controllers/request.rb
@@ -154,6 +170,7 @@ files:
 - lib/gruf/serializers/errors/base.rb
 - lib/gruf/serializers/errors/json.rb
 - lib/gruf/server.rb
+- lib/gruf/synchronized_client.rb
 - lib/gruf/timer.rb
 - lib/gruf/version.rb
 homepage: https://github.com/bigcommerce/gruf