protobuf 2.0.0.rc3 → 2.0.0.rc4

data/lib/protobuf/cli.rb

@@ -1,7 +1,6 @@
 require 'thor'
-require 'pry'
 require 'protobuf/version'
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'protobuf/rpc/servers/evented_runner'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/rpc/servers/zmq_runner'

data/lib/protobuf/field/base_field.rb

@@ -1,4 +1,4 @@
-require 'protobuf/common/wire_type'
+require 'protobuf/wire_type'
 require 'protobuf/field/field_array'
 
 module Protobuf

data/lib/protobuf/{common/logger.rb → logger.rb}

@@ -53,13 +53,34 @@ module Protobuf
     module LogMethods
       [:debug, :info, :warn, :error, :fatal, :any, :add, :log].each do |m|
         define_method("log_#{m}") do |*params, &block|
+          params.map! { |message| sign_message(message) }
           Protobuf::Logger.__send__(m, *params, &block)
         end
       end
 
+      # When included, also extend the LogMethods module for class access.
       def self.included(base)
         base.extend(LogMethods)
       end
+
+      # We often want to log an exception, so let's make that a core
+      # concern of the logger.
+      #
+      def log_exception(ex)
+        log_error { ex.message }
+        log_error { ex.backtrace[0..5].join("\n") }
+        log_debug { ex.backtrace.join("\n") }
+      end
+
+      def log_signature
+        @_log_signature ||= "[#{self.class == Class ? self.name : self.class.name}]"
+      end
+
+      def sign_message(message)
+        "#{log_signature} #{message}"
+      end
+
     end
+
   end
 end

data/lib/protobuf/message/decoder.rb

@@ -1,5 +1,5 @@
-require 'protobuf/common/wire_type'
-require 'protobuf/common/exceptions'
+require 'protobuf/wire_type'
+require 'protobuf/exceptions'
 
 module Protobuf
 

data/lib/protobuf/message/encoder.rb

@@ -1,5 +1,5 @@
-require 'protobuf/common/wire_type'
-require 'protobuf/common/exceptions'
+require 'protobuf/wire_type'
+require 'protobuf/exceptions'
 
 module Protobuf
 
@@ -10,8 +10,10 @@ module Protobuf
     # Encode +message+ and write to +stream+.
     def encode(stream, message)
       # FIXME make this not as ghetto
-      raise NotInitializedError, "Message %s is not initialized (one or more fields is improperly set): %s" % [message.class.name, JSON.parse(message.to_json)] unless message.initialized?
-      
+      unless message.initialized?
+        raise NotInitializedError, "Message #{message.class.name} is not initialized (one or more fields is improperly set): #{JSON.parse(message.to_json)}"
+      end
+
       message.each_field do |field, value|
         next unless message.has_field?(field.name)
 

data/lib/protobuf/rpc/buffer.rb

@@ -32,7 +32,7 @@ module Protobuf
         end
 
         @size = @data.length
-        '%d-%s' % [@size, @data]
+        "#{@size}-#{@data}"
       end
 
       def <<(data)
@@ -63,7 +63,7 @@ module Protobuf
       def get_data_size
         if @size == 0 || @data.match(SIZE_REGEX)
           sliced_size = @data.slice!(SIZE_REGEX)
-          @size = sliced_size.gsub('-', '').to_i unless(sliced_size.nil?)
+          @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
         end
       end
 

data/lib/protobuf/rpc/client.rb

@@ -1,6 +1,6 @@
 require 'forwardable'
 require 'protobuf'
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'protobuf/rpc/error'
 require 'protobuf/rpc/connector'
 
@@ -10,7 +10,7 @@ module Protobuf
       extend Forwardable
       include Protobuf::Logger::LogMethods
 
-      delegate [:options, :complete_cb, :success_cb, :failure_cb, :async?] => :@connector
+      delegate [:options, :complete_cb, :success_cb, :failure_cb] => :@connector
       attr_reader :connector
 
       # Create a new client with default options (defined in ClientConnection)
@@ -29,15 +29,14 @@ module Protobuf
       def initialize(opts={})
         raise "Invalid client configuration. Service must be defined." if opts[:service].nil?
         @connector = Connector.connector_for_client.new(opts)
-        log_debug { "[#{log_signature}] Initialized with options: %s" % opts.inspect }
+        log_debug { sign_message("Initialized with options: #{opts.inspect}") }
       end
 
       def log_signature
-        @log_signature ||= "client-#{self.class}"
+        @_log_signature ||= "client-#{self.class}"
       end
 
       # Set a complete callback on the client to return the object (self).
-      # Callback is called regardless of :async setting.
       #
       #   client = Client.new(:service => WidgetService)
       #   client.on_complete {|obj| ... }
@@ -57,7 +56,6 @@ module Protobuf
       # Set a failure callback on the client to return the
       # error returned by the service, if any. If this callback
       # is called, success_cb will NOT be called.
-      # Callback is called regardless of :async setting.
       #
       #   client = Client.new(:service => WidgetService)
       #   client.on_failure {|err| ... }
@@ -68,7 +66,7 @@ module Protobuf
 
       def on_failure=(callable)
         if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
-          raise "callable must take a single argument and respond to :call"
+          raise "Callable must take a single argument and respond to :call"
         end
 
         @connector.failure_cb = callable
@@ -77,7 +75,6 @@ module Protobuf
       # Set a success callback on the client to return the
       # successful response from the service when it is returned.
       # If this callback is called, failure_cb will NOT be called.
-      # Callback is called regardless of :async setting.
       #
       #   client = Client.new(:service => WidgetService)
       #   client.on_success {|res| ... }
@@ -88,7 +85,7 @@ module Protobuf
 
       def on_success=(callable)
         if callable != nil && !callable.respond_to?(:call) && callable.arity != 1
-          raise "callable must take a single argument and respond to :call"
+          raise "Callable must take a single argument and respond to :call"
         end
 
         @connector.success_cb = callable
@@ -108,26 +105,29 @@ module Protobuf
       #
       def method_missing(method, *params)
         service = options[:service]
-        unless service.rpcs[service].keys.include?(method)
-          log_error { "[#{log_signature}] %s#%s not rpc method, passing to super" % [service.name, method.to_s] }
+        unless service.rpc_method?(method)
+          log_error { sign_message("#{service.name}##{method.to_s} not rpc method, passing to super") }
           super(method, *params)
         else
-          log_debug { "[#{log_signature}] %s#%s" % [service.name, method.to_s] }
-          rpc = service.rpcs[service][method.to_sym]
+          log_debug { sign_message("#{service.name}##{method.to_s}") }
+          rpc = service.rpcs[method.to_sym]
+
           options[:request_type] = rpc.request_type
-          log_debug { "[#{log_signature}] Request Type: %s" % options[:request_type].name }
+          log_debug { sign_message("Request Type: #{options[:request_type].name}") }
+
           options[:response_type] = rpc.response_type
-          log_debug { "[#{log_signature}] Response Type: %s" % options[:response_type].name }
+          log_debug { sign_message("Response Type: #{options[:response_type].name}") }
+
           options[:method] = method.to_s
           options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
-          log_debug { "[#{log_signature}] Request Data: %s" % options[:request].inspect }
+          log_debug { sign_message("Request Data: #{options[:request].inspect}") }
 
           # Call client to setup on_success and on_failure event callbacks
           if block_given?
-            log_debug { "[#{log_signature}] client setup callback given, invoking" }
+            log_debug { sign_message("client setup callback given, invoking") }
             yield(self)
           else
-            log_debug { "[#{log_signature}] no block given for callbacks" }
+            log_debug { sign_message("no block given for callbacks") }
           end
 
           send_request

data/lib/protobuf/rpc/connectors/base.rb

@@ -1,4 +1,4 @@
-require 'protobuf/common/logger'
+require 'protobuf/logger'
 require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
 require 'protobuf/rpc/error'
@@ -16,27 +16,22 @@ module Protobuf
         :request        => nil,           # The request object sent by the client
         :request_type   => nil,           # The request type expected by the client
         :response_type  => nil,           # The response type expected by the client
-        :async          => false,         # Whether or not to block a client call, this is actually handled by client.rb
         :timeout        => 30             # The default timeout for the request, also handled by client.rb
       }
 
       class Base
         include Protobuf::Logger::LogMethods
-        
+
         attr_reader :options
         attr_accessor :success_cb, :failure_cb, :complete_cb
 
         def initialize(options)
           @options = DEFAULT_OPTIONS.merge(options)
         end
-        
+
         def send_request
           raise 'If you inherit a Connector from Base you must implement send_request'
         end
-        
-        def async?
-          !!@options[:async]
-        end
       end
     end
   end

data/lib/protobuf/rpc/connectors/common.rb

@@ -12,23 +12,23 @@ module Protobuf
         end
 
         def complete
-          @stats.end
-          @stats.log_stats
-          log_debug { "[#{log_signature}] Response proceessing complete" }
+          @stats.stop
+          log_info { @stats.to_s }
+          log_debug { sign_message('Response proceessing complete') }
           @complete_cb.call(self) unless @complete_cb.nil?
-        rescue
-          log_error { "[#{log_signature}] Complete callback error encountered: %s" % $!.message }
-          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
+        rescue => e
+          log_error { sign_message('Complete callback error encountered') }
+          log_exception(e)
           raise
         end
 
         def data_callback(data)
-          log_debug { "[#{log_signature}] Using data_callback" }
+          log_debug { sign_message('Using data_callback') }
           @used_data_callback = true
           @data = data
         end
 
-        # All failures should be routed through this method
+        # All failures should be routed through this method.
         #
         # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
         # @param [String] message The error message
@@ -36,35 +36,36 @@ module Protobuf
           @error =  ClientError.new
           @error.code = code.is_a?(Symbol) ? Protobuf::Socketrpc::ErrorReason.values[code] : code
           @error.message = message
-          log_debug { "[#{log_signature}] Server failed request (invoking on_failure): %s" % @error.inspect }
+          log_debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
 
           @failure_cb.call(@error) unless @failure_cb.nil?
-        rescue
-          log_error { "[#{log_signature}] Failure callback error encountered: %s" % $!.message }
-          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
+        rescue => e
+          log_error { sign_message("Failure callback error encountered") }
+          log_exception(e)
           raise
         ensure
           complete
         end
 
         def initialize_stats
-          @stats = Protobuf::Rpc::Stat.new(:CLIENT, true)
+          @stats = Protobuf::Rpc::Stat.new(:CLIENT)
           @stats.server = [@options[:port], @options[:host]]
           @stats.service = @options[:service].name
           @stats.method = @options[:method].to_s
         rescue => ex
+          log_exception(ex)
           fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
         end
 
         def log_signature
-          @log_signature ||= "client-#{self.class}"
+          @_log_signature ||= "client-#{self.class}"
         end
 
         def parse_response
           # Close up the connection as we no longer need it
           close_connection
 
-          log_debug { "[#{log_signature}] Parsing response from server (connection closed)" }
+          log_debug { sign_message("Parsing response from server (connection closed)") }
 
           # Parse out the raw response
           response_wrapper = Protobuf::Socketrpc::Response.new
@@ -72,13 +73,13 @@ module Protobuf
 
           # Determine success or failure based on parsed data
           if response_wrapper.has_field?(:error_reason)
-            log_debug { "[#{log_signature}] Error response parsed" }
+            log_debug { sign_message("Error response parsed") }
 
             # fail the call if we already know the client is failed
             # (don't try to parse out the response payload)
             fail(response_wrapper.error_reason, response_wrapper.error)
           else
-            log_debug { "[#{log_signature}] Successful response parsed" }
+            log_debug { sign_message("Successful response parsed") }
 
             # Ensure client_response is an instance
             response_type = @options[:response_type].new
@@ -96,8 +97,8 @@ module Protobuf
 
         def post_init
           send_data unless error?
-        rescue
-          fail(:RPC_ERROR, 'Connection error: %s' % $!.message)
+        rescue => e
+          fail(:RPC_ERROR, "Connection error: #{e.message}")
         end
 
         def rpc_request_data
@@ -108,8 +109,8 @@ module Protobuf
             :method_name => @options[:method].to_s,
             :request_proto => @options[:request].serialize_to_string
           ).serialize_to_string
-        rescue
-          fail :INVALID_REQUEST_PROTO, "Could not set request proto: #{$!.message}"
+        rescue => e
+          fail(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
         end
 
         def setup_connection
@@ -118,12 +119,12 @@ module Protobuf
         end
 
         def succeed(response)
-          log_debug { "[#{log_signature}] Server succeeded request (invoking on_success)" }
+          log_debug { sign_message("Server succeeded request (invoking on_success)") }
           @success_cb.call(response) unless @success_cb.nil?
-        rescue
-          log_error { "[#{log_signature}] Success callback error encountered: %s" % $!.message }
-          log_error { "[#{log_signature}] %s" % $!.backtrace.join("\n") }
-          fail :RPC_ERROR, 'An exception occurred while calling on_success: %s' % $!.message
+        rescue => e
+          log_error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          fail(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
         ensure
           complete
         end
@@ -132,13 +133,13 @@ module Protobuf
           unless @options[:request].class == @options[:request_type]
             expected = @options[:request_type].name
             actual = @options[:request].class.name
-            fail :INVALID_REQUEST_PROTO, 'Expected request type to be type of %s, got %s instead' % [expected, actual]
+            fail(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
           end
         end
 
         def verify_callbacks
           if !any_callbacks?
-            log_debug { "[#{log_signature}] No callbacks set, using data_callback" }
+            log_debug { sign_message("No callbacks set, using data_callback") }
             @success_cb = @failure_cb = self.method(:data_callback)
           end
         end

data/lib/protobuf/rpc/connectors/em_client.rb

@@ -19,9 +19,9 @@ module Protobuf
           @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
           verify_options
 
-          log_debug { "[#{log_signature}] Client Initialized: %s" % options.inspect }
-        rescue
-          fail(:RPC_ERROR, 'Failed to initialize connection: %s' % $!.message)
+          log_debug { sign_message("Client Initialized: #{options.inspect}") }
+        rescue => e
+          fail(:RPC_ERROR, "Failed to initialize connection: #{e.message}")
         end
 
         ##
@@ -29,7 +29,7 @@ module Protobuf
         #
         def self.connect(options={})
           options = DEFAULT_OPTIONS.merge(options)
-          log_debug { "[client-#{self}] Connecting to server: %s" % options.inspect }
+          log_debug { sign_message("Connecting to server: #{options.inspect}") }
           EM.connect(options[:host], options[:port], self, options)
         end
 
@@ -56,19 +56,19 @@ module Protobuf
         end
 
         def receive_data(data)
-          log_debug { "[#{log_signature}] receive_data: %s" % data }
+          log_debug { sign_message("receive_data: #{data}") }
           @response_buffer << data
           @response_data = @response_buffer.data
-          parse_response if(!@response_data.nil? && @response_buffer.flushed?)
+          parse_response if !@response_data.nil? && @response_buffer.flushed?
         end
 
         def send_data
           request_buffer = ::Protobuf::Rpc::Buffer.new(:write)
           request_buffer.set_data(@request_data)
-          log_debug { "[#{log_signature}] sending data: #{request_buffer.inspect}" }
+          log_debug { sign_message("sending data: #{request_buffer.inspect}") }
           super(request_buffer.write)
-        rescue
-          fail(:RPC_ERROR, 'Connection error: %s' % $!.message)
+        rescue => e
+          fail(:RPC_ERROR, "Connection error: #{e.message}")
         end
 
         # overwriting this method for java because it's broken in eventmachine. See https://github.com/eventmachine/eventmachine/issues/14

data/lib/protobuf/rpc/connectors/eventmachine.rb

@@ -11,17 +11,17 @@ module Protobuf
             f = Fiber.current
 
             ::EM.next_tick do
-              log_debug { "[#{log_signature}] Scheduling EventMachine client request to be created on next tick" }
+              log_debug { sign_message('Scheduling EventMachine client request to be created on next tick') }
               cnxn = EMClient.connect(options, &ensure_cb)
               cnxn.on_success(&success_cb) if success_cb
               cnxn.on_failure(&ensure_cb)
-              cnxn.on_complete { resume_fiber(f) } unless async?
+              cnxn.on_complete { resume_fiber(f) }
               cnxn.setup_connection
               cnxn.send_data
-              log_debug { "[#{log_signature}] Connection scheduled" }
+              log_debug { sign_message('Connection scheduled') }
             end
 
-            async? ? true : set_timeout_and_validate_fiber
+            set_timeout_and_validate_fiber
           end
         end
 
@@ -32,11 +32,11 @@ module Protobuf
         # don't want to swallow the black holes.
         #
         def ensure_cb
-          @ensure_cb ||= (@failure_cb || lambda { |error| raise '%s: %s' % [error.code.name, error.message] } )
+          @ensure_cb ||= (@failure_cb || lambda { |error| raise "#{error.code.name}: #{error.message}" })
         end
 
         def log_signature
-          @log_signature ||= "client-#{self.class}"
+          @_log_signature ||= "client-#{self.class}"
         end
 
         private
@@ -58,18 +58,20 @@ module Protobuf
           ::EM::cancel_timer(@timeout_timer)
           fib.resume(true)
         rescue => ex
-          message = 'Synchronous client failed: %s' % ex.message
+          log_exception(ex)
+          message = "Synchronous client failed: #{ex.message}"
           error_stop_reactor(message)
         end
 
         def set_timeout_and_validate_fiber
           @timeout_timer = ::EM::add_timer(@options[:timeout]) do
-            message = 'Client timeout of %d seconds expired' % @options[:timeout]
+            message = "Client timeout of #{@options[:timeout]} seconds expired"
             error_stop_reactor(message)
           end
 
           Fiber.yield
-        rescue FiberError
+        rescue FiberError => ex
+          log_exception(ex)
           message = "Synchronous calls must be in 'EM.fiber_run' block"
           error_stop_reactor(message)
         end