carrot_rpc 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9202e93b42d441f3781fef272d5957cfab7ea4a
-  data.tar.gz: 91e6cc50e86d52b94693bacf40a45ba13a17c70d
+  metadata.gz: b377cb46e74db89d8b6bcd97d305a26a0964d539
+  data.tar.gz: 266101d5211ce7409438a958dc5f9629e20cd43e
 SHA512:
-  metadata.gz: 6020b67ed40ebdee85b960f2254cdedceca9d93cc289e0c5900f7ab10f3ec9a77d5b9c8a64274c2530f94fd6263ef2703cc808398ea1819db23668dc1c6101fd
-  data.tar.gz: b001fd637d344818920319b27b1ddc51dda764f5a2335d037864a6f36687eee030ee411c2238ee31324b015e1fe23fa0192322fe6f10f7691df663f30a8a5a8d
+  metadata.gz: 4b42e357b5212e94d321a9ef2448567f23d905330a931218046f5920a39c818dadf20f3ad940d20da7b63841bb0a9e97595b911da978ae78d6305fa12c1b8dd7
+  data.tar.gz: a23da7aca020a9b0dfc1e17a521aea69a2675db343a1065c152b628d72d90e04c47655c8a6f9b218480174e16bb282112ab6664decd22ad6ec7b0bde07a51b07

data/CHANGELOG.md

@@ -40,6 +40,14 @@
 # Changelog
 All significant changes in the project are documented here.
 
+## v0.6.0
+### Enhancements
+* [#34](https://github.com/C-S-D/carrot_rpc/pull/34) - `--server_test_mode` options for `carrot_rpc` sets `CarrotRpc.configuration.server_test_mode` to `true`.  When `server_test_mode` is true, `_test` is appended to the queue name used by `CarrotRpc::RpcServer` and `CarrotRpc::RpcClient`, so that tests don't use the same queue as production or development. - [@shamil614](https://github.com/C-S-D/carrot_rpc/pull/34)
+* [#36](https://github.com/C-S-D/carrot_rpc/pull/36) - Request in thread-local variable, so it can be used for client request - [@KronicDeth](https://github.com/KronicDeth)  
+  * `carrot_rpc --thread-request VARIABLE` allows the request payload to be put in a Thread-local `VARIABLE, so that client that are invoked during an RPC server request can use parts of the request, most importantly, parts of "meta" in their own requests. This is needed to pass along ownership information for db_connection in Ecto 2.0.
+  * Tag the log with the correlation_id, as it can be filtered for then.
+  * Clarify whether a request or response is being published or received, so that server vs client logging can be distinguished.
+
 ## v0.5.1
 ### Bug Fixes
 * [#31](https://github.com/C-S-D/carrot_rpc/pull/31) - If the server does not respond to a method in the `request_message`, then return a "Method not found" JSONRPC 2.0 error instead of the server crashing with `NoMethodError` exception. - [KronicDeth)(https://github.com/KronicDeth)

data/README.md

@@ -53,18 +53,19 @@ By typing in `carrot_rpc -h` you will see all the command line options:
 Usage: server [options]
 
 Process options:
-    -d, --daemonize              run daemonized in the background (default: false)
-        --pidfile PIDFILE        the pid filename
-    -s, --runloop_sleep VALUE    Configurable sleep time in the runloop
-        --autoload_rails VALUE   loads rails env by default. Uses Rails Logger by default.
-        --logfile VALUE          relative path and name for Log file. Overrides Rails logger.
-        --loglevel VALUE         levels of loggin: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
-        --rabbitmq_url VALUE     connection string to RabbitMQ 'amqp://user:pass@host:10000/vhost'
+    -d, --daemonize               run daemonized in the background (default: false)
+        --pidfile PIDFILE         the pid filename
+    -s, --runloop_sleep VALUE     Configurable sleep time in the runloop
+        --autoload_rails VALUE    loads rails env by default. Uses Rails Logger by default.
+        --logfile VALUE           relative path and name for Log file. Overrides Rails logger.
+        --loglevel VALUE          levels of loggin: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+        --rabbitmq_url VALUE      connection string to RabbitMQ 'amqp://user:pass@host:10000/vhost'
+        --thread-request VARIABLE Copies the current request into VARIABLE Thread local variable, where it can be retrieved with `Thread.thread_variable_get(<VARIABLE>)`
 
 Ruby options:
-    -I, --include PATH           an additional $LOAD_PATH
-        --debug                  set $DEBUG to true
-        --warn                   enable warnings
+    -I, --include PATH            an additional $LOAD_PATH
+        --debug                   set $DEBUG to true
+        --warn                    enable warnings
 
 Common options:
     -h, --help
@@ -95,9 +96,10 @@ CarrotRpc.configure do |config|
   config.rpc_client_response_key_format = :underscore
 
   # Don't use. Server implementation only. The values below are set via CLI:
+  # config.logfile = nil
   # config.pidfile = nil
   # config.runloop_sleep = 0
-  # config.logfile = nil
+  # config.thread_request_variable = nil
 end
 ```
 
@@ -182,6 +184,33 @@ car_client = CarClient.new(config)
 ```
 By duplicating the `Configuration` instance you can override the global configuration and pass a custom configuration to the RpcClient instance.
 
+#### Using request threading in clients
+
+If you run the server with `--thread-request VARIABLE`, you can retrieve that variable in the `before_request` callback, such as to pass along important meta data:
+
+```sh
+carrot_rpc --thread-request carrot_rpc_server_request_message
+```
+
+Example Client: `app/clients/profile_client.rb`
+```
+# Allows calls to other RPC server's profile resource.
+class ProfileClient < CarrotRpc::RpcClient
+  before_request ->(params){
+    request_message = Thread.current.thread_variable_get(:carrot_rpc_server_request_message)
+
+    if request_message
+      meta = params[:meta] || {}
+      # beam is test meta data specific to Elixir
+      meta = meta.merge(beam: request_message[:params][:meta][:beam])
+      params.merge(meta: meta)
+    else
+      params
+    end
+  }
+end
+```
+
 ### Support for JSONAPI::Resources
 In the case that you're writing an application that uses the `jsonapi-resources` gem and you want the `RpcServer` to have the same functionality, then we got you covered. All you need to do is import a few modules. See [jsonapi-resources](https://github.com/cerebris/jsonapi-resources) for details on how to implement resources for your models.
 

data/lib/carrot_rpc/cli.rb

@@ -38,6 +38,12 @@ module CarrotRpc::CLI
       CarrotRpc.configuration.runloop_sleep = value
     end
 
+    stm_msg = "runs servers with '_test' appended to queue names." \
+              "Set Rails Rack env vars to 'test' when used in conjunction with '--autoload_rails'"
+    option_parser.on(" ", "--server_test_mode", stm_msg) do
+      CarrotRpc.configuration.server_test_mode = true
+    end
+
     option_parser.on(
       " ",
       "--autoload_rails value",
@@ -67,6 +73,15 @@ module CarrotRpc::CLI
     ) do |value|
       CarrotRpc.configuration.bunny = Bunny.new(value)
     end
+
+    option_parser.on(
+      " ",
+      "--thread-request VARIABLE",
+      "Copies the current request into VARIABLE Thread local variable, " \
+      "where it can be retrieved with `Thread.thread_variable_get(<VARIABLE>)`"
+    ) do |variable|
+      CarrotRpc.configuration.thread_request_variable = variable
+    end
   end
 
   def self.add_ruby_options(option_parser)

data/lib/carrot_rpc/client_server.rb

@@ -22,4 +22,13 @@ module CarrotRpc::ClientServer
            "queue_name(new_name) :: new_name or queue_name() :: current_name are the only ways to call queue_name"
     end
   end
+
+  def test_queue_name(name, append_name = false)
+    return name unless append_name
+    if name
+      "#{name}_test"
+    else
+      fail CarrotRpc::Exception::InvalidQueueName
+    end
+  end
 end

data/lib/carrot_rpc/configuration.rb

@@ -1,7 +1,8 @@
 # Global configuration for {CarrotRpc}.  Access with {CarrotRpc.configuration}.
 class CarrotRpc::Configuration
   attr_accessor :logger, :logfile, :loglevel, :daemonize, :pidfile, :runloop_sleep, :autoload_rails, :bunny,
-                :before_request, :rpc_client_timeout, :rpc_client_response_key_format, :rpc_client_request_key_format
+                :before_request, :rpc_client_timeout, :rpc_client_response_key_format, :rpc_client_request_key_format,
+                :server_test_mode, :client_test_mode, :thread_request_variable
 
   # logfile - set logger to a file. overrides rails logger.
 
@@ -18,5 +19,8 @@ class CarrotRpc::Configuration
     @rpc_client_timeout = 5
     @rpc_client_response_key_format = :none
     @rpc_client_request_key_format = :none
+    @client_test_mode = false
+    @server_test_mode = false
+    @thread_request_variable = nil
   end # rubocop:enable Metrics/MethodLength
 end

data/lib/carrot_rpc/exception.rb

@@ -2,4 +2,5 @@
 module CarrotRpc::Exception
   # Exception to be raised when the client timesout waiting for a response.
   class RpcClientTimeout < StandardError; end
+  class InvalidQueueName < StandardError; end
 end

data/lib/carrot_rpc/format.rb

@@ -0,0 +1,23 @@
+# Used to format keys
+module CarrotRpc::Format
+  using CarrotRpc::HashExtensions
+
+  # Logic to process the renaming of keys in a hash.
+  # @param format [Symbol] :dasherize changes keys that have "_" to "-"
+  # @param format [Symbol] :underscore changes keys that have "-" to "_"
+  # @param format [Symbol] :skip, will not rename the keys
+  # @param data [Hash] data structure to be transformed
+  # @return [Hash] the transformed data
+  def self.keys(format, data)
+    case format
+    when :dasherize
+      data.rename_keys("_", "-")
+    when :underscore
+      data.rename_keys("-", "_")
+    when :none
+      data
+    else
+      data
+    end
+  end
+end

data/lib/carrot_rpc/reply.rb

@@ -0,0 +1,60 @@
+# Publishes properly formatted replies to consumed requests
+module CarrotRpc::Reply
+  private
+
+  def reply(properties:, response_message:)
+    payload = response_message.to_json
+
+    logger.debug "Publishing response: #{payload}"
+
+    @exchange.publish payload,
+                      correlation_id: properties.correlation_id,
+                      routing_key: properties.reply_to
+  end
+
+  # See http://www.jsonrpc.org/specification#error_object
+  def reply_error(error, properties:, request_message:)
+    response_message = { error: error, id: request_message[:id], jsonrpc: "2.0" }
+
+    reply properties: properties,
+          response_message: response_message
+  end
+
+  def reply_method_not_found(method:, properties:, request_message:)
+    error = CarrotRpc::Error.new code: CarrotRpc::Error::Code::METHOD_NOT_FOUND,
+                                 data: {
+                                   method: method
+                                 },
+                                 message: "Method not found"
+    logger.error(error)
+
+    reply_error error.serialized_message,
+                properties:      properties,
+                request_message: request_message
+  end
+
+  # See http://www.jsonrpc.org/specification#response_object
+  def reply_result(result, properties:, request_message:)
+    if result && result.is_a?(Hash) && result["errors"]
+      reply_result_with_errors(result, properties: properties, request_message: request_message)
+    else
+      reply_result_without_errors(result, properties: properties, request_message: request_message)
+    end
+  end
+
+  def reply_result_with_errors(result, properties:, request_message:)
+    scrubbed_result = result.merge(
+      "errors" => CarrotRpc::Scrub.errors(result.fetch("errors"))
+    )
+    reply_error({ code: 422, data: scrubbed_result, message: "JSONAPI error" },
+                properties: properties,
+                request_message: request_message)
+  end
+
+  def reply_result_without_errors(result, properties:, request_message:)
+    response_message = { id: request_message[:id], jsonrpc: "2.0", result: result }
+
+    reply properties: properties,
+          response_message: response_message
+  end
+end

data/lib/carrot_rpc/rpc_client.rb

@@ -4,8 +4,6 @@ require "securerandom"
 # Let's define a naming convention here for subclasses becuase I don't want to write a Confluence doc.
 # All subclasses should have the following naming convention: <Name>RpcConsumer  ex: PostRpcConsumer
 class CarrotRpc::RpcClient
-  using CarrotRpc::HashExtensions
-
   attr_reader :channel, :server_queue, :logger
 
   extend CarrotRpc::ClientServer
@@ -21,25 +19,6 @@ class CarrotRpc::RpcClient
     end
   end
 
-  # Logic to process the renaming of keys in a hash.
-  # @param format [Symbol] :dasherize changes keys that have "_" to "-"
-  # @param format [Symbol] :underscore changes keys that have "-" to "_"
-  # @param format [Symbol] :skip, will not rename the keys
-  # @param data [Hash] data structure to be transformed
-  # @return [Hash] the transformed data
-  def self.format_keys(format, data)
-    case format
-    when :dasherize
-      data.rename_keys("_", "-")
-    when :underscore
-      data.rename_keys("-", "_")
-    when :none
-      data
-    else
-      data
-    end
-  end
-
   # Use defaults for application level connection to RabbitMQ.
   #
   # @example pass custom {Configuration} class as an argument to override.
@@ -59,8 +38,9 @@ class CarrotRpc::RpcClient
     # Create a new channel on each request because the channel should be closed after each request.
     @channel = @config.bunny.create_channel
 
+    queue_name = self.class.test_queue_name(self.class.queue_name, @config.client_test_mode)
     # auto_delete => false keeps the queue around until RabbitMQ restarts or explicitly deleted
-    @server_queue = @channel.queue(self.class.queue_name, auto_delete: false)
+    @server_queue = @channel.queue(queue_name, auto_delete: false)
 
     # Setup a direct exchange.
     @exchange = @channel.default_exchange
@@ -76,12 +56,8 @@ class CarrotRpc::RpcClient
 
     # setup subscribe block to Service
     # block => false is a non blocking IO option.
-    @reply_queue.subscribe(block: false) do |_delivery_info, properties, payload|
-      response = JSON.parse(payload).with_indifferent_access
-
-      result = parse_response(response)
-      result = response_key_formatter(result).with_indifferent_access if result.is_a? Hash
-      @results[properties[:correlation_id]].push(result)
+    @reply_queue.subscribe(block: false) do |delivery_info, properties, payload|
+      consume(delivery_info, properties, payload)
     end
   end
 
@@ -97,9 +73,11 @@ class CarrotRpc::RpcClient
     start
     subscribe
     correlation_id = SecureRandom.uuid
-    params = self.class.before_request.call(params) if self.class.before_request
-    publish(correlation_id: correlation_id, method: remote_method, params: request_key_formatter(params))
-    wait_for_result(correlation_id)
+    logger.with_correlation_id(correlation_id) do
+      params = self.class.before_request.call(params) if self.class.before_request
+      publish(correlation_id: correlation_id, method: remote_method, params: request_key_formatter(params))
+      wait_for_result(correlation_id)
+    end
   end
 
   def wait_for_result(correlation_id)
@@ -120,14 +98,14 @@ class CarrotRpc::RpcClient
   # @param payload [Hash] response data received from the remote server.
   # @return [Hash] formatted data structure.
   def response_key_formatter(payload)
-    self.class.format_keys @config.rpc_client_response_key_format, payload
+    CarrotRpc::Format.keys @config.rpc_client_response_key_format, payload
   end
 
   # Formats keys in the request data.
   # @param payload [Hash] request data to be sent to the remote server.
   # @return [Hash] formatted data structure.
   def request_key_formatter(params)
-    self.class.format_keys @config.rpc_client_request_key_format, params
+    CarrotRpc::Format.keys @config.rpc_client_request_key_format, params
   end
 
   # A @reply_queue is deleted when the channel is closed.
@@ -138,10 +116,7 @@ class CarrotRpc::RpcClient
       params:         params,
       method:         method
     )
-    # Reply To => make sure the service knows where to send it's response.
-    # Correlation ID => identify the results that belong to the unique call made
-    @exchange.publish(message.to_json, routing_key: @server_queue.name, correlation_id: correlation_id,
-                                       reply_to:                                     @reply_queue.name)
+    publish_payload(message.to_json, correlation_id: correlation_id)
   end
 
   def message(correlation_id:, method:, params:)
@@ -155,6 +130,18 @@ class CarrotRpc::RpcClient
 
   private
 
+  def consume(_delivery_info, properties, payload)
+    logger.with_correlation_id(properties[:correlation_id]) do
+      logger.debug "Receiving response: #{payload}"
+
+      response = JSON.parse(payload).with_indifferent_access
+
+      result = parse_response(response)
+      result = response_key_formatter(result).with_indifferent_access if result.is_a? Hash
+      @results[properties[:correlation_id]].push(result)
+    end
+  end
+
   # Logic to find the data from the RPC response.
   # @param [Hash] response from rpc call
   # @return [Hash,nil]
@@ -169,4 +156,14 @@ class CarrotRpc::RpcClient
       response
     end
   end
+
+  def publish_payload(payload, correlation_id:)
+    # Reply To => make sure the service knows where to send it's response.
+    # Correlation ID => identify the results that belong to the unique call made
+    logger.debug "Publishing request: #{payload}"
+    @exchange.publish payload,
+                      correlation_id: correlation_id,
+                      reply_to:       @reply_queue.name,
+                      routing_key:    @server_queue.name
+  end
 end

data/lib/carrot_rpc/rpc_server.rb

@@ -4,19 +4,22 @@ class CarrotRpc::RpcServer
 
   using CarrotRpc::HashExtensions
 
-  attr_reader :channel, :server_queue, :logger
+  attr_reader :channel, :server_queue, :logger, :thread_request_variable
   # method_reciver => object that receives the method. can be a class or anything responding to send
 
   extend CarrotRpc::ClientServer
+  include CarrotRpc::Reply
 
   # Documentation advises not to share a channel connection. Create new channel for each server instance.
   def initialize(config: nil, block: true)
     # create a channel and exchange that both client and server know about
     config ||= CarrotRpc.configuration
+    @thread_request_variable = config.thread_request_variable
     @channel = config.bunny.create_channel
     @logger = config.logger
     @block = block
-    @server_queue = @channel.queue(self.class.queue_name)
+    queue_name = self.class.test_queue_name(self.class.queue_name, config.server_test_mode)
+    @server_queue = @channel.queue(queue_name)
     @exchange = @channel.default_exchange
   end
 
@@ -24,28 +27,21 @@ class CarrotRpc::RpcServer
   # method => object that receives the method. can be a class or anything responding to send
   def start
     # subscribe is like a callback
-    @server_queue.subscribe(block: @block) do |_delivery_info, properties, payload|
-      logger.debug "Receiving message: #{payload}"
-
-      request_message = JSON.parse(payload).with_indifferent_access
-
-      process_request(request_message, properties: properties)
+    @server_queue.subscribe(block: @block) do |delivery_info, properties, payload|
+      consume(delivery_info, properties, payload)
     end
   end
 
   def process_request(request_message, properties:)
-    method = request_message[:method]
-
-    handler = if respond_to? method
-                :call_found_method
-              else
-                :reply_method_not_found
-              end
-
-    send handler,
-         method:          method,
-         properties:      properties,
-         request_message: request_message
+    maybe_thread_request(request_message: request_message) do
+      method = request_message[:method]
+      handler = method_handler(method)
+
+      send handler,
+           method:          method,
+           properties:      properties,
+           request_message: request_message
+    end
   end
 
   private
@@ -64,73 +60,48 @@ class CarrotRpc::RpcServer
                  request_message: request_message
   end
 
-  def reply(properties:, response_message:)
-    @exchange.publish response_message.to_json,
-                      correlation_id: properties.correlation_id,
-                      routing_key: properties.reply_to
-  end
-
-  # See http://www.jsonrpc.org/specification#error_object
-  def reply_error(error, properties:, request_message:)
-    response_message = { error: error, id: request_message[:id], jsonrpc: "2.0" }
+  def consume(_delivery_info, properties, payload)
+    logger.tagged("server", "queue=#{server_queue.name}", "correlation_id=#{properties[:correlation_id]}") do
+      logger.debug "Receiving request: #{payload}"
 
-    logger.debug "Publish error: #{error} to #{response_message}"
+      # rubocop:disable Lint/RescueException
+      begin
+        request_message = JSON.parse(payload).with_indifferent_access
 
-    reply properties: properties,
-          response_message: response_message
-  end
-
-  def reply_method_not_found(method:, properties:, request_message:)
-    error = CarrotRpc::Error.new code: CarrotRpc::Error::Code::METHOD_NOT_FOUND,
-                                 data: {
-                                   method: method
-                                 },
-                                 message: "Method not found"
-    logger.error(error)
-
-    reply_error error.serialized_message,
-                properties:      properties,
-                request_message: request_message
+        process_request(request_message, properties: properties)
+      rescue Exception => exception
+        logger.error(exception)
+      end
+      # rubocop:enable Lint/RescueException
+    end
   end
 
-  # See http://www.jsonrpc.org/specification#response_object
-  def reply_result(result, properties:, request_message:)
-    if result && result.is_a?(Hash) && result["errors"]
-      reply_result_with_errors(result, properties: properties, request_message: request_message)
+  def maybe_thread_request(request_message:)
+    if thread_request_variable
+      thread_request(request_message: request_message, &Proc.new)
     else
-      reply_result_without_errors(result, properties: properties, request_message: request_message)
+      yield
     end
   end
 
-  def reply_result_with_errors(result, properties:, request_message:)
-    scrubbed_result = result.merge(
-      "errors" => scrub_errors(result.fetch("errors"))
-    )
-    reply_error({ code: 422, data: scrubbed_result, message: "JSONAPI error" },
-                properties: properties,
-                request_message: request_message)
+  def method_handler(method)
+    if respond_to? method
+      :call_found_method
+    else
+      :reply_method_not_found
+    end
   end
 
-  def reply_result_without_errors(result, properties:, request_message:)
-    response_message = { id: request_message[:id], jsonrpc: "2.0", result: result }
+  def thread_request(request_message:)
+    logger.debug "Threading request (#{request_message.inspect}) " \
+                   "in Thread.current.thread_variable_get(#{thread_request_variable.inspect})"
 
-    logger.debug "Publishing result: #{result} to #{response_message}"
+    Thread.current.thread_variable_set(thread_request_variable, request_message)
 
-    reply properties: properties,
-          response_message: response_message
-  end
-
-  # Removes `nil` values as JSONAPI spec expects unset keys not to be transmitted
-  def scrub_error(error)
-    error.reject { |_, value|
-      value.nil?
-    }
-  end
-
-  # Removes `nil` values as JSONAPI spec expects unset keys not to be transmitted
-  def scrub_errors(errors)
-    errors.map { |error|
-      scrub_error(error)
-    }
+    begin
+      yield
+    ensure
+      Thread.current.thread_variable_set(thread_request_variable, nil)
+    end
   end
 end

data/lib/carrot_rpc/scrub.rb

@@ -0,0 +1,16 @@
+# Removes `nil` valued keys from nested `Hash`es.
+module CarrotRpc::Scrub
+  # Removes `nil` values as JSONAPI spec expects unset keys not to be transmitted
+  def self.error(error)
+    error.reject { |_, value|
+      value.nil?
+    }
+  end
+
+  # Removes `nil` values as JSONAPI spec expects unset keys not to be transmitted
+  def self.errors(errors)
+    errors.map { |error|
+      error(error)
+    }
+  end
+end

data/lib/carrot_rpc/server_runner/autoload_rails.rb

@@ -19,7 +19,7 @@ module CarrotRpc::ServerRunner::AutoloadRails
 
     if File.exist?(rails_path)
       logger.info "Rails app found at: #{rails_path}"
-      ENV["RACK_ENV"] ||= ENV["RAILS_ENV"] || "development"
+      set_rack_rails_env
       require rails_path
       ::Rails.application.eager_load!
       true
@@ -38,4 +38,17 @@ module CarrotRpc::ServerRunner::AutoloadRails
       load_root(root, logger: logger)
     end
   end
+
+  # Set Rails/Rack env vars to test when server test mode is enabled.
+  #
+  # @return [Void]
+  def self.set_rack_rails_env
+    if CarrotRpc.configuration.server_test_mode
+      env_mode = "test"
+      ENV["RACK_ENV"] = ENV["RAILS_ENV"] = env_mode
+    else
+      env_mode = "development"
+      ENV["RACK_ENV"] ||= ENV["RAILS_ENV"] ||= env_mode
+    end
+  end
 end

data/lib/carrot_rpc/server_runner.rb

@@ -81,7 +81,8 @@ class CarrotRpc::ServerRunner
     server_klass_name = file.to_s.split("/").last.gsub(".rb", "").camelize
     server_klass = server_klass_name.constantize
 
-    logger.info "Starting #{server_klass}..."
+    stm = CarrotRpc.configuration.server_test_mode
+    logger.info "Starting: #{server_klass} | Rails/Rack ENV: #{ENV['RAILS_ENV']} | Server Test Mode: #{stm}"
 
     server = server_klass.new(block: false)
     server.start

data/lib/carrot_rpc/tagged_log.rb

@@ -21,4 +21,10 @@ class CarrotRpc::TaggedLog
       logger.tagged(tags) { logger.send(level, msg || block.call) }
     end
   end
+
+  delegate :tagged, to: :logger
+
+  def with_correlation_id(correlation_id, &block)
+    tagged("correlation_id=#{correlation_id}", &block)
+  end
 end

data/lib/carrot_rpc/version.rb

@@ -1,3 +1,3 @@
 module CarrotRpc
-  VERSION = "0.5.1".freeze
+  VERSION = "0.6.0".freeze
 end

data/lib/carrot_rpc.rb

@@ -23,10 +23,13 @@ module CarrotRpc
   autoload :Configuration
   autoload :Error
   autoload :Exception
+  autoload :Format
   autoload :HashExtensions
+  autoload :Reply
   autoload :RpcClient
   autoload :RpcServer
   autoload :ServerRunner
+  autoload :Scrub
   autoload :TaggedLog
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carrot_rpc
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Scott Hamilton
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-17 00:00:00.000000000 Z
+date: 2016-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -158,11 +158,14 @@ files:
 - lib/carrot_rpc/error.rb
 - lib/carrot_rpc/error/code.rb
 - lib/carrot_rpc/exception.rb
+- lib/carrot_rpc/format.rb
 - lib/carrot_rpc/hash_extensions.rb
+- lib/carrot_rpc/reply.rb
 - lib/carrot_rpc/rpc_client.rb
 - lib/carrot_rpc/rpc_server.rb
 - lib/carrot_rpc/rpc_server/jsonapi_resources.rb
 - lib/carrot_rpc/rpc_server/jsonapi_resources/actions.rb
+- lib/carrot_rpc/scrub.rb
 - lib/carrot_rpc/server_runner.rb
 - lib/carrot_rpc/server_runner/autoload_rails.rb
 - lib/carrot_rpc/server_runner/logger.rb