rester 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a17ecdff2d900cdad60ccd5404afca94cfda269f
-  data.tar.gz: efa02cdbfef4743e9c0538896d769cb33c979a51
+  metadata.gz: 9bb523b9b23530a59e8bc2a8fc8463324739b59d
+  data.tar.gz: 26d4a6f4cd0de0417b470357488c0ed941e8f8a8
 SHA512:
-  metadata.gz: 38c3311be4b40526035536d31cbbd1e682911e51cd54dcd53e1789aa356c44ef4ef38ff4bdf9b7012735c0d79d844a324eeedd7418706985ddabb756b7546bb5
-  data.tar.gz: 60f377dc74da842bf80696998657ce61549db1a7f7cb86f0d38967cd35a4311ae6d9d5d1d8c565956b56dcf0a82305cbac9d64044aabf9910569621cc42225df
+  metadata.gz: 9456f4f73aa5e8516e3731a273954a254735de21025dcdac36e70209e922f1ce4ee335b865a32efb4c01e6225ddfbd4161c3d89cc85096bd02521b09c6c5b3eb
+  data.tar.gz: 1ad4848eb57cd9770a6c9185c4b9f136111083a258ec9bff59addd160801e6e2865c02623ddbae1b4fb6bebe5152080b3566389cf5d3497d2ec1d51406936713

data/lib/rester/client/adapters/adapter.rb

@@ -11,7 +11,7 @@ module Rester
 
       attr_reader :timeout
 
-      def initialize(service=nil, opts={})
+      def initialize(service = nil, opts = {})
         @timeout = opts[:timeout]
         connect(service) if service
       end
@@ -19,7 +19,7 @@ module Rester
       ##
       # Returns the headers defined for this Adapter. Optionally, you may also
       # define additional headers you'd like to add/override.
-      def headers(new_headers={})
+      def headers(new_headers = {})
         (@headers ||= {}).merge!(new_headers)
       end
 
@@ -37,7 +37,7 @@ module Rester
       end
 
       ##
-      # Sends an HTTP request to the service.
+      # Sends a request (using one of the subclass adapters) to the service.
       #
       # `params` should be a hash if specified.
       def request(verb, path, params = nil)

data/lib/rester/client/adapters/http_adapter.rb

@@ -38,7 +38,12 @@ module Rester
       private
 
       def _prepare_response(response)
-        [response.code.to_i, response.body]
+        # We want to format the header keys in the way we would expect it in our
+        # client: X-Rester-Header-Key.
+        #
+        # http://ruby-doc.org/stdlib-2.1.1/libdoc/net/http/rdoc/Net/HTTPHeader.html
+        headers = {}.tap { |h| response.each_capitalized { |k,v| h[k] = v } }
+        [response.code.to_i, headers, response.body]
       end
 
       def _require_connection

data/lib/rester/client/adapters/local_adapter.rb

@@ -37,11 +37,13 @@ module Rester
 
         response = Timeout::timeout(timeout) do
           service.call(
-            'REQUEST_METHOD' => verb.to_s.upcase,
-            'PATH_INFO'      => path,
-            'CONTENT_TYPE'   => 'application/x-www-form-urlencoded',
-            'QUERY_STRING'   => query,
-            'rack.input'     => StringIO.new(body)
+            _headers_to_http_format(opts[:headers]).merge(
+              'REQUEST_METHOD' => verb.to_s.upcase,
+              'PATH_INFO'      => path,
+              'CONTENT_TYPE'   => 'application/x-www-form-urlencoded',
+              'QUERY_STRING'   => query,
+              'rack.input'     => StringIO.new(body)
+            )
           )
         end
 
@@ -52,11 +54,19 @@ module Rester
 
         [
           response.first, # The status code
+          {
+            'X-Rester-Producer-Name' => service.service_name,
+          },              # The header
           body            # The response body.
         ]
       rescue Timeout::Error
         fail Errors::TimeoutError
       end
+
+
+      def _headers_to_http_format(headers={})
+        Hash[headers.map { |k,v| ["HTTP_#{k.to_s.upcase.gsub('-', '_')}", v] }]
+      end
     end # LocalAdapter
   end # Client::Adapters
 end # Rester

data/lib/rester/client/adapters/stub_adapter.rb

@@ -30,7 +30,15 @@ module Rester
         !!stub
       end
 
+      def producer
+        stub['producer']
+      end
+
       def request!(verb, path, encoded_data)
+        if verb == :get && path == '/ping'
+          return [200, { 'X-Rester-Producer-Name' => producer }, '']
+        end
+
         params = Rack::Utils.parse_nested_query(encoded_data)
         _request(verb.to_s.upcase, path, params)
       end
@@ -45,7 +53,11 @@ module Rester
 
       def _request(verb, path, params)
         spec = _process_request(path, verb, params)
-        [spec['response_code'], spec['response'].to_json]
+        [
+          spec['response_code'],
+          { 'X-Rester-Producer-Name' => producer },
+          spec['response'].to_json
+        ]
       end
 
       def _process_request(path, verb, params)

data/lib/rester/client/middleware/base.rb

@@ -0,0 +1,15 @@
+module Rester
+  module Client::Middleware
+    class Base
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        app.call(env)
+      end
+    end # Base
+  end # Client::Middleware
+end # Rester

data/lib/rester/client/middleware/request_handler.rb

@@ -0,0 +1,14 @@
+module Rester
+  module Client::Middleware
+    class RequestHandler < Base
+      def call(env)
+        Rester.begin_request
+        Rester.correlation_id = SecureRandom.uuid
+        Rester.request_info[:consumer_name] = Rester.service_name
+        super
+      ensure
+        Rester.end_request
+      end
+    end # RequestHandlers
+  end # Client::Middleware
+end # Rester

data/lib/rester/client/middleware.rb

@@ -0,0 +1,8 @@
+module Rester
+  class Client
+    module Middleware
+      autoload(:Base,           'rester/client/middleware/base')
+      autoload(:RequestHandler, 'rester/client/middleware/request_handler')
+    end
+  end
+end

data/lib/rester/client.rb

@@ -4,9 +4,10 @@ require 'logger'
 
 module Rester
   class Client
-    autoload(:Adapters, 'rester/client/adapters')
-    autoload(:Resource, 'rester/client/resource')
-    autoload(:Response, 'rester/client/response')
+    autoload(:Adapters,   'rester/client/adapters')
+    autoload(:Resource,   'rester/client/resource')
+    autoload(:Response,   'rester/client/response')
+    autoload(:Middleware, 'rester/client/middleware')
 
     attr_reader :adapter
     attr_reader :version
@@ -19,22 +20,45 @@ module Rester
       self.version = params[:version]
       @error_threshold = (params[:error_threshold] || 3).to_i
       @retry_period = (params[:retry_period] || 1).to_f
-      @logger = params[:logger] || Logger.new(STDOUT)
+      self.logger = params[:logger]
+      @_breaker_enabled = params.fetch(:circuit_breaker_enabled,
+        ENV['RACK_ENV'] != 'test' && ENV['RAILS_ENV'] != 'test'
+      )
 
       @_resource = Resource.new(self)
-      _init_request_breaker
-    end
+      _init_requester
 
-    def connect(*args)
-      adapter.connect(*args)
+      # Send a test ping request to the service so we can store the producer's
+      # name for future request logs
+      fail Errors::ConnectionError unless connected?
     end
 
     def connected?
-      adapter.connected? && adapter.get('/ping').first == 200
+      adapter.connected? && @_requester.call(:get, '/ping', {}).successful?
+    rescue
+      false
+    end
+
+    def circuit_breaker_enabled?
+      !!@_breaker_enabled
+    end
+
+    def logger=(logger)
+      logger = Utils::LoggerWrapper.new(logger) if logger
+      @logger = logger
+    end
+
+    def logger
+      @logger || Rester.logger
+    end
+
+    def name
+      @_producer_name
     end
 
     def request(verb, path, params={})
-      @_request_breaker.call(verb, path, params)
+      path = _path_with_version(path)
+      @_requester.call(verb, path, params)
     rescue Utils::CircuitBreaker::CircuitOpenError
       # Translate this error so it's easier handle for clients.
       # Also, at some point we may want to extract CircuitBreaker into its own
@@ -77,31 +101,55 @@ module Rester
     #
     # When the circuit is opened or closed, a message is sent to the logger for
     # the client.
-    def _init_request_breaker
-      @_request_breaker = Utils::CircuitBreaker.new(
-        threshold: error_threshold, retry_period: retry_period
-      ) { |*args| _request(*args) }
-
-      @_request_breaker.on_open do
-        logger.error("circuit opened")
-      end
+    def _init_requester
+      if circuit_breaker_enabled?
+        @_requester = Utils::CircuitBreaker.new(
+          threshold: error_threshold, retry_period: retry_period
+        ) { |*args| _request(*args) }
+
+        @_requester.on_open do
+          logger.error("circuit opened for #{name}")
+        end
 
-      @_request_breaker.on_close do
-        logger.info("circuit closed")
+        @_requester.on_close do
+          logger.info("circuit closed for #{name}")
+        end
+      else
+        @_requester = proc { |*args| _request(*args) }
       end
     end
 
+    ##
+    # Add a correlation ID to the header and send the request to the adapter
     def _request(verb, path, params)
-      path = _path_with_version(path)
-      _process_response(path, *adapter.request(verb, path, params))
+      Rester.request_info[:producer_name] = name
+      Rester.request_info[:path] = path
+      Rester.request_info[:verb] = verb
+      logger.info('sending request')
+
+      _set_default_headers
+      start_time = Time.now.to_f
+      response = adapter.request(verb, path, params)
+      _process_response(start_time, verb, path, *response)
+    end
+
+    def _set_default_headers
+      adapter.headers(
+        'X-Rester-Correlation-ID' => Rester.correlation_id,
+        'X-Rester-Consumer-Name' => Rester.service_name,
+        'X-Rester-Producer-Name' => name
+      )
     end
 
     def _path_with_version(path)
       Utils.join_paths("/v#{version}", path)
     end
 
-    def _process_response(path, status, body)
+    def _process_response(start_time, verb, path, status, headers, body)
+      elapsed_ms = (Time.now.to_f - start_time) * 1000
       response = Response.new(status, _parse_json(body))
+      @_producer_name = headers['X-Rester-Producer-Name']
+      logger.info("received status #{status} after %0.3fms" % elapsed_ms)
 
       unless [200, 201, 400].include?(status)
         case status

data/lib/rester/errors.rb

@@ -23,11 +23,17 @@ module Rester
     # Client Errors
     class ClientError < Error; end
     class CircuitOpenError < ClientError; end
+    class ConnectionError < ClientError; end
 
     #############
     # Stub Errors
     class StubError < Error; end
 
+    #############
+    # RSpec Errors
+    class RSpecError < Error; end
+    class TestError < RSpecError; end
+
     #############
     # Http Errors
     class HttpError < Error; end

data/lib/rester/rspec.rb

@@ -17,7 +17,7 @@ RSpec::Matchers.define :include_stub_response do |stub|
     end
   }
 
-  failure_message { |actual| failure }
+  failure_message { failure }
 end
 
 RSpec.configure do |config|
@@ -31,7 +31,7 @@ RSpec.configure do |config|
       raise "invalid service to test"
     end
 
-    @rester_adapter = Rester::Client::Adapters::LocalAdapter.new(klass, {})
+    @rester_adapter = Rester::Client::Adapters::LocalAdapter.new(klass)
 
     _validate_test_coverage(ex)
   end
@@ -40,7 +40,7 @@ RSpec.configure do |config|
     _setup_example(ex) unless ex.pending?
   end
 
-  config.after :each, rester: // do |ex|
+  config.after :each, rester: // do
     if defined?(service_response_code)
       expect(service_response_code).to eq stub_response_code
     end
@@ -67,10 +67,9 @@ RSpec.configure do |config|
 
     begin
       spec = @rester_stub[path][verb][context]
+      _stub_path_not_found(path, verb, context) unless spec
     rescue NoMethodError
-      fail Rester::Errors::StubError,
-        "Could not find path: #{path.inspect} verb: #{verb.inspect} context: "\
-          "#{context.inspect} in #{@rester_stub_filepath}"
+      _stub_path_not_found(path, verb, context)
     end
 
     ##
@@ -106,6 +105,12 @@ RSpec.configure do |config|
     ex.example_group.let(:subject) { service_response }
   end
 
+  def _stub_path_not_found(path, verb, context)
+    fail Rester::Errors::TestError,
+      "Could not find path: #{path.inspect} verb: #{verb.inspect} context: "\
+        "#{context.inspect} in #{@rester_stub_filepath}"
+  end
+
   ##
   # Check to see if each stub example has a corresponding test written for it
   def _validate_test_coverage(ex)
@@ -164,24 +169,24 @@ RSpec.configure do |config|
   #   }
   # }
   def _missing_stub_tests(tests)
-    @rester_stub.reject { |k, _|
+    Hash[@rester_stub.reject { |k, _|
       ['version', 'consumer', 'producer'].include?(k)
     }.map { |path, verbs|
       [
         path,
-        verbs.map { |verb, contexts|
+        Hash[verbs.map { |verb, contexts|
           [
             verb,
-            contexts.map { |context, _|
+            Hash[contexts.map { |context, _|
               [
                 context,
                 !!(tests[path] && tests[path][verb] && tests[path][verb][context])
               ]
-            }.to_h.reject { |_, v| v }
+            }].reject { |_, v| v }
           ]
-        }.to_h.reject { |_, v| v.empty? }
+        }].reject { |_, v| v.empty? }
       ]
-    }.to_h.reject { |_, v| v.empty? }
+    }].reject { |_, v| v.empty? }
   end
 
   def _find_child_with_description(group, description)

data/lib/rester/{middleware → service/middleware}/base.rb

@@ -1,5 +1,5 @@
 module Rester
-  module Middleware
+  module Service::Middleware
     class Base
       attr_reader :app
       attr_reader :options
@@ -40,5 +40,5 @@ module Rester
         Errors.throw_error!(klass, message)
       end
     end # Base
-  end # Middleware
+  end # Service::Middleware
 end # Rester

data/lib/rester/{middleware → service/middleware}/error_handling.rb

@@ -1,7 +1,7 @@
 require 'json'
 
 module Rester
-  module Middleware
+  module Service::Middleware
     ##
     # Provides error handling for Rester. Should be mounted above all other
     # Rester middleware.
@@ -15,6 +15,7 @@ module Rester
           end
         }
 
+        service.logger.error(error.inspect)
         _error_to_response(error).finish
       end
 
@@ -68,5 +69,5 @@ module Rester
         end
       end
     end # ErrorHandling
-  end # Middleware
+  end # Service::Middleware
 end # Rester

data/lib/rester/{middleware → service/middleware}/new_relic.rb

@@ -4,7 +4,7 @@ require 'active_support/inflector'
 NewRelic::Agent.manual_start unless defined?(Rails)
 
 module Rester
-  module Middleware
+  module Service::Middleware
     class NewRelic < Base
       include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
 

data/lib/rester/{middleware → service/middleware}/ping.rb

@@ -1,15 +1,15 @@
 module Rester
-  module Middleware
+  module Service::Middleware
     ##
     # Provides a basic status check. Used by the Client#connected? method.
     class Ping < Base
       def call(env)
-        if %r{\A/ping\z}.match(env['REQUEST_PATH'])
+        if %r{\A/ping\z}.match(Rester.request.path_info)
           [200, {}, []]
         else
           super
         end
       end
     end # Ping
-  end # Middleware
+  end # Service::Middleware
 end # Rester

data/lib/rester/service/middleware/request_handler.rb

@@ -0,0 +1,30 @@
+module Rester
+  module Service::Middleware
+    ##
+    # Create a Request object for this thread, store the correlation ID, and
+    # perform the necessary logging. Cleanup the request once it's complete.
+    class RequestHandler < Base
+      def call(env)
+        Rester.begin_request
+        Rester.request = request = Rester::Service::Request.new(env)
+        Rester.correlation_id = request.correlation_id
+        Rester.request_info[:producer_name] = service.name
+        Rester.request_info[:consumer_name] = request.consumer_name
+        Rester.request_info[:path] = request.path_info
+        Rester.request_info[:verb] = request.request_method
+
+        service.logger.info('request received')
+
+        start_time = Time.now.to_f
+        super.tap { |response|
+          elapsed_ms = (Time.now.to_f - start_time) * 1000
+          response[1]["X-Rester-Producer-Name"] = service.name
+          service.logger.info("responding with #{response[0]} after %0.3fms" %
+            elapsed_ms)
+        }
+      ensure
+        Rester.end_request
+      end
+    end # RequestHandler
+  end # Service::Middleware
+end # Rester

data/lib/rester/service/middleware.rb

@@ -0,0 +1,11 @@
+module Rester
+  class Service
+    module Middleware
+      autoload(:Base,           'rester/service/middleware/base')
+      autoload(:ErrorHandling,  'rester/service/middleware/error_handling')
+      autoload(:Ping,           'rester/service/middleware/ping')
+      autoload(:NewRelic,       'rester/service/middleware/new_relic')
+      autoload(:RequestHandler, 'rester/service/middleware/request_handler')
+    end
+  end
+end

data/lib/rester/service/request.rb

@@ -6,6 +6,9 @@ module Rester
       attr_reader :version
       attr_reader :object_chain
 
+      CUSTOM_FIELDS = ['correlation_id', 'producer_name',
+        'consumer_name'].freeze
+
       def initialize(env)
         super
         _parse_path if valid?
@@ -25,6 +28,10 @@ module Rester
         end
       end
 
+      CUSTOM_FIELDS.each { |field|
+        define_method(field) { env["HTTP_X_RESTER_#{field.upcase}"] }
+      }
+
       private
 
       def _parse_path

data/lib/rester/service/resource/params.rb

@@ -51,9 +51,9 @@ module Rester
           _error!("unexpected params: #{unexpected.join(', ')}")
         end
 
-        validated_params = params.map do |key, value|
-          [key.to_sym, validate!(key.to_sym, value)]
-        end.to_h
+        validated_params = Hash[
+          params.map { |key, value| [key.to_sym, validate!(key.to_sym, value)] }
+        ]
 
         @_defaults.merge(validated_params)
       end

data/lib/rester/service/resource.rb

@@ -82,7 +82,7 @@ module Rester
       # determining which instance method to call. For example, if the request
       # method is GET: the ID being specified will call the `get` method and if
       # it's not specified then it will call the `search` method.
-      def process(request_method, id_provided, params={})
+      def process(request_method, id_provided, params = {})
         meth = (id_provided ? REQUEST_METHOD_TO_IDENTIFIED_METHOD
           : REQUEST_METHOD_TO_UNIDENTIFIED_METHOD)[request_method]
 

data/lib/rester/service.rb

@@ -1,17 +1,22 @@
 require 'uri'
 require 'rack'
 require 'active_support/inflector'
+require 'logger'
 
 module Rester
   class Service
-    autoload(:Request, 'rester/service/request')
-    autoload(:Resource,  'rester/service/resource')
+    autoload(:Request,    'rester/service/request')
+    autoload(:Resource,   'rester/service/resource')
+    autoload(:Middleware, 'rester/service/middleware')
+
+    attr_reader :logger
 
     ##
     # The base set of middleware to use for every service.
     # Middleware will be executed in the order specified.
     BASE_MIDDLEWARE = [
       Rack::Head,
+      Middleware::RequestHandler,
       Middleware::ErrorHandling,
       Middleware::Ping
     ].freeze
@@ -57,6 +62,10 @@ module Rester
         }.map(&:downcase).map(&:to_sym)
       end
 
+      def service_name
+        @__name ||= name.split('::').last
+      end
+
       def version_module(version)
         (@__version_modules ||= {})[version.to_sym] ||= _load_version_module(version)
       end
@@ -81,6 +90,19 @@ module Rester
       end
     end # Class methods
 
+    def logger
+      @_logger || Rester.logger
+    end
+
+    def logger=(new_logger)
+      new_logger = Utils::LoggerWrapper.new(new_logger) if new_logger
+      @_logger = new_logger
+    end
+
+    def name
+      self.class.service_name
+    end
+
     ##
     # To be called by Rack. Wraps the app in middleware.
     def rack_call(env)
@@ -102,7 +124,7 @@ module Rester
     # Calls methods that may modify instance variables, so the instance should
     # be dup'd beforehand.
     def call!(env)
-      _process_request(Request.new(env))
+      _process_request(Rester.request)
     end
 
     private
@@ -142,7 +164,6 @@ module Rester
     # request.
     def _call_method(request)
       params = request.params
-      retval = nil
       resource_obj = nil
       resource_id = nil
 

data/lib/rester/utils/logger_wrapper.rb

@@ -0,0 +1,41 @@
+module Rester
+  module Utils
+    class LoggerWrapper
+      attr_reader :logger
+
+      def initialize(logger = Logger.new(STDOUT))
+        @logger = logger
+      end
+
+      (Logger::SEV_LABEL - ['ANY']).map(&:downcase).map(&:to_sym).each do |sev|
+        define_method(sev) { |msg| _log(sev, msg) if logger }
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        logger.public_send(meth, *args, &block)
+      end
+
+      def respond_to_missing?(*args)
+        logger.respond_to?(*args)
+      end
+
+      def _log(level, msg)
+        if Rester.processing_request?
+          producer_name = Rester.request_info[:producer_name]
+          consumer_name = Rester.request_info[:consumer_name]
+          path = Rester.request_info[:path]
+          verb = Rester.request_info[:verb]
+          verb = verb && verb.upcase
+
+          msg = "Correlation-ID=#{Rester.correlation_id} Consumer=" \
+            "#{consumer_name} Producer=#{producer_name} #{verb} " \
+            "#{path} - #{msg}"
+        end
+
+        logger.public_send(level, msg)
+      end
+    end # LoggerWrapper
+  end # Utils
+end # Rester

data/lib/rester/utils/stub_file.rb

@@ -92,7 +92,7 @@ module Rester
         # Takes a response key (e.g., "response[successful=false]") and parses out
         # the tags (e.g., {"successful" => false})
         def _parse_tags(path, verb, context, resp_key)
-          DEFAULT_TAGS.merge(resp_key.scan(/(\w+) *= *(\w+)/).to_h).tap { |tags|
+          DEFAULT_TAGS.merge(Hash[resp_key.scan(/(\w+) *= *(\w+)/)]).tap { |tags|
             _validate_tags(path, verb, context, tags)
           }
         end

data/lib/rester/utils.rb

@@ -6,6 +6,7 @@ module Rester
     autoload(:StubFile,       'rester/utils/stub_file')
     autoload(:RSpec,          'rester/utils/rspec')
     autoload(:CircuitBreaker, 'rester/utils/circuit_breaker')
+    autoload(:LoggerWrapper,  'rester/utils/logger_wrapper')
 
     class << self
       ##

data/lib/rester/version.rb

@@ -1,3 +1,3 @@
 module Rester
-  VERSION = '0.5.1'
+  VERSION = '0.5.2'
 end

data/lib/rester.rb

@@ -1,5 +1,7 @@
 require 'rester/version'
 require 'rack'
+require 'securerandom'
+require 'active_support/core_ext/class/subclasses'
 
 module Rester
   require 'rester/railtie' if defined?(Rails)
@@ -9,17 +11,92 @@ module Rester
   autoload(:Utils,       'rester/utils')
   autoload(:Middleware,  'rester/middleware')
 
+  @_request_infos ||= ThreadSafe::Cache.new
+
+  # Set up the Client middleware if it's a Rails application
+  if defined?(Rails) && Rails.application
+    Rails.configuration.middleware.use(Client::Middleware::RequestHandler)
+  end
+
   class << self
+    def logger
+      @_logger ||= Utils::LoggerWrapper.new
+    end
+
+    def logger=(new_logger)
+      @_logger = Utils::LoggerWrapper.new(new_logger)
+    end
+
     def load_tasks
       Dir[
         File.expand_path("../../tasks", __FILE__) + '/**.rake'
       ].each { |rake_file| load rake_file }
     end
 
-    def connect(service, params={})
+    def connect(service, params = {})
       adapter_opts = Client::Adapters.extract_opts(params)
       adapter = Client::Adapters.connect(service, adapter_opts)
       Client.new(adapter, params)
     end
+
+    def service_name
+      @_service_name ||= _get_service_name
+    end
+
+    def service_name=(name)
+      @_service_name = name
+    end
+
+    def begin_request
+      self.request_info = {}
+    end
+
+    def end_request
+      self.request_info = nil
+    end
+
+    def processing_request?
+      !!request_info
+    end
+
+    def request_info
+      @_request_infos[Thread.current.object_id]
+    end
+
+    def request_info=(info)
+      if info.nil?
+        @_request_infos.delete(Thread.current.object_id)
+      else
+        @_request_infos[Thread.current.object_id] = info
+      end
+    end
+
+    def request
+      request_info[:request]
+    end
+
+    def request=(request)
+      request_info[:request] = request
+    end
+
+    def correlation_id
+      request_info && request_info[:correlation_id]
+    end
+
+    def correlation_id=(correlation_id)
+      request_info[:correlation_id] = correlation_id
+    end
+
+    private
+
+    def _get_service_name
+      if defined?(Rails) && Rails.application
+        Rails.application.class.parent_name
+      else
+        services = Service.descendants
+        fail "Define a service name" if services.empty?
+        services.first.service_name
+      end
+    end
   end # Class Methods
 end # Rester

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rester
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-07 00:00:00.000000000 Z
+date: 2016-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -45,6 +45,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  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: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -145,22 +159,27 @@ files:
 - lib/rester/client/adapters/http_adapter/connection.rb
 - lib/rester/client/adapters/local_adapter.rb
 - lib/rester/client/adapters/stub_adapter.rb
+- lib/rester/client/middleware.rb
+- lib/rester/client/middleware/base.rb
+- lib/rester/client/middleware/request_handler.rb
 - lib/rester/client/resource.rb
 - lib/rester/client/response.rb
 - lib/rester/errors.rb
-- lib/rester/middleware.rb
-- lib/rester/middleware/base.rb
-- lib/rester/middleware/error_handling.rb
-- lib/rester/middleware/new_relic.rb
-- lib/rester/middleware/ping.rb
 - lib/rester/railtie.rb
 - lib/rester/rspec.rb
 - lib/rester/service.rb
+- lib/rester/service/middleware.rb
+- lib/rester/service/middleware/base.rb
+- lib/rester/service/middleware/error_handling.rb
+- lib/rester/service/middleware/new_relic.rb
+- lib/rester/service/middleware/ping.rb
+- lib/rester/service/middleware/request_handler.rb
 - lib/rester/service/request.rb
 - lib/rester/service/resource.rb
 - lib/rester/service/resource/params.rb
 - lib/rester/utils.rb
 - lib/rester/utils/circuit_breaker.rb
+- lib/rester/utils/logger_wrapper.rb
 - lib/rester/utils/rspec.rb
 - lib/rester/utils/stub_file.rb
 - lib/rester/version.rb
@@ -184,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A framework for creating simple RESTful interfaces between services.

data/lib/rester/middleware.rb

@@ -1,8 +0,0 @@
-module Rester
-  module Middleware
-    autoload(:Base,          'rester/middleware/base')
-    autoload(:ErrorHandling, 'rester/middleware/error_handling')
-    autoload(:Ping,          'rester/middleware/ping')
-    autoload(:NewRelic,      'rester/middleware/new_relic')
-  end
-end