protobuffy 3.1.0

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -0,0 +1,46 @@
+require 'protobuf/logger'
+
+module Protobuf
+  module Rpc
+    class ServiceDispatcher
+      include ::Protobuf::Logger::LogMethods
+
+      attr_reader :env
+
+      def initialize(app)
+        # End of the line...
+      end
+
+      def call(env)
+        @env = env
+
+        env.response = dispatch_rpc_request
+        env
+      end
+
+      def rpc_service
+        @rpc_service ||= env.rpc_service.new(env)
+      end
+
+    private
+
+      # Call the given service method.
+      def dispatch_rpc_request
+        unless rpc_service.respond_to?(method_name)
+          raise MethodNotFound.new("#{service_name}##{method_name} is not a publicly defined method.")
+        end
+
+        rpc_service.callable_rpc_method(method_name).call
+        rpc_service.response
+      end
+
+      def method_name
+        env.method_name
+      end
+
+      def service_name
+        env.service_name
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/service_filters.rb

@@ -0,0 +1,273 @@
+module Protobuf
+  module Rpc
+    module ServiceFilters
+
+      def self.included(other)
+        other.class_eval do
+          extend Protobuf::Rpc::ServiceFilters::ClassMethods
+          include Protobuf::Rpc::ServiceFilters::InstanceMethods
+        end
+      end
+
+      module ClassMethods
+
+        [:after, :around, :before].each do |type|
+          # Setter DSL method for given filter types.
+          #
+          define_method "#{type}_filter" do |*args|
+            set_filters(type, *args)
+          end
+          alias_method "#{type}_action", "#{type}_filter"
+        end
+
+        # Filters hash keyed based on filter type (e.g. :before, :after, :around),
+        # whose values are Sets.
+        #
+        def filters
+          @filters ||= Hash.new { |h,k| h[k] = [] }
+        end
+
+        # Filters hash keyed based on filter type (e.g. :before, :after, :around),
+        # whose values are Sets.
+        #
+        def rescue_filters
+          @rescue_filters ||= {}
+        end
+
+        def rescue_from(*ex_klasses, &block)
+          options = ex_klasses.last.is_a?(Hash) ? ex_klasses.pop : {}
+          callable = options.delete(:with) { block }
+          raise ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
+          ex_klasses.each { |ex_klass| rescue_filters[ex_klass] = callable }
+        end
+
+        private
+
+        def define_filter(type, filter, options = {})
+          return if filter_defined?(type, filter)
+          filters[type] << options.merge({ :callable => filter })
+          remember_filter(type, filter)
+        end
+
+        def defined_filters
+          @defined_filters ||= Hash.new { |h,k| h[k] = Set.new }
+        end
+
+        # Check to see if the filter has been defined.
+        #
+        def filter_defined?(type, filter)
+          defined_filters[type].include?(filter)
+        end
+
+        # Remember that we stored the filter.
+        #
+        def remember_filter(type, filter)
+          defined_filters[type] << filter
+        end
+
+        # Takes a list of actually (or potentially) callable objects.
+        # TODO add support for if/unless
+        # TODO add support for only/except sub-filters
+        #
+        def set_filters(type, *args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          args.each do |filter|
+            define_filter(type, filter, options)
+          end
+        end
+
+      end
+
+      module InstanceMethods
+
+        private
+
+        # Get back to class filters.
+        #
+        def filters
+          self.class.filters
+        end
+
+        # Predicate which uses the filter options to determine if the filter
+        # should be called. Specifically checks the :if, :unless, :only, and :except
+        # options for every filter. Each option check is expected to return false
+        # if the filter should not be invoked, true if invocation should occur.
+        #
+        def invoke_filter?(rpc_method, filter)
+          return invoke_via_only?(rpc_method, filter) \
+            && invoke_via_except?(rpc_method, filter) \
+            && invoke_via_if?(rpc_method, filter) \
+            && invoke_via_unless?(rpc_method, filter)
+        end
+
+        # If the target rpc endpoint method is listed under an :except option,
+        # return false to indicate that the filter should not be invoked. Any
+        # other target rpc endpoint methods not listed should be invoked.
+        # This option is the opposite of :only.
+        #
+        # Value should be a symbol/string or an array of symbols/strings.
+        #
+        def invoke_via_except?(rpc_method, filter)
+          except = [ filter.fetch(:except) { [] } ].flatten
+          return except.empty? || ! except.include?(rpc_method)
+        end
+
+        # Invoke the given :if callable (if any) and return its return value.
+        # Used by `invoke_filter?` which expects a true/false
+        # return value to determine if we should invoke the target filter.
+        #
+        # Value can either be a symbol/string indicating an instance method to call
+        # or an object that responds to `call`.
+        #
+        def invoke_via_if?(rpc_method, filter)
+          if_check = filter.fetch(:if) { lambda { |service| return true } }
+          do_invoke = case
+                      when if_check.nil? then
+                        true
+                      else
+                        call_or_send(if_check)
+                      end
+
+          return do_invoke
+        end
+
+        # If the target rpc endpoint method is listed in the :only option,
+        # it should be invoked. Any target rpc endpoint methods not listed in this
+        # option should not be invoked. This option is the opposite of :except.
+        #
+        # Value should be a symbol/string or an array of symbols/strings.
+        #
+        def invoke_via_only?(rpc_method, filter)
+          only = [ filter.fetch(:only) { [] } ].flatten
+          return only.empty? || only.include?(rpc_method)
+        end
+
+        # Invoke the given :unless callable (if any) and return the opposite
+        # of it's return value. Used by `invoke_filter?` which expects a true/false
+        # return value to determine if we should invoke the target filter.
+        #
+        # Value can either be a symbol/string indicating an instance method to call
+        # or an object that responds to `call`.
+        #
+        def invoke_via_unless?(rpc_method, filter)
+          unless_check = filter.fetch(:unless) { lambda { |service| return false } }
+          skip_invoke = case
+                        when unless_check.nil? then
+                          false
+                        else
+                          call_or_send(unless_check)
+                        end
+
+          return ! skip_invoke
+        end
+
+        def rescue_filters
+          self.class.rescue_filters
+        end
+
+        # Loop over the unwrapped filters and invoke them. An unwrapped filter
+        # is either a before or after filter, not an around filter.
+        #
+        def run_unwrapped_filters(unwrapped_filters, rpc_method, stop_on_false_return = false)
+          unwrapped_filters.each do |filter|
+            if invoke_filter?(rpc_method, filter)
+              return_value = call_or_send(filter[:callable])
+              return false if stop_on_false_return && return_value == false
+            end
+          end
+
+          return true
+        end
+
+        # Reverse build a chain of around filters. To implement an around chain,
+        # simply build a method that yields control when it expects the underlying
+        # method to be invoked. If the endpoint should not be run (due to some
+        # condition), simply do not yield.
+        #
+        # Around filters are invoked in the order they are defined, outer to inner,
+        # with the inner-most method called being the actual rpc endpoint.
+        #
+        # Let's say you have a class defined with the following filters:
+        #
+        #   class MyService
+        #     around_filter :filter1, :filter2, :filter3
+        #
+        #     def my_endpoint
+        #       # do stuff
+        #     end
+        #   end
+        #
+        # When the my_endpoint method is invoked using Service#callable_rpc_method,
+        # It is similar to this call chain:
+        #
+        #   filter1 do
+        #     filter2 do
+        #       filter3 do
+        #         my_endpoint
+        #       end
+        #     end
+        #   end
+        #
+        def run_around_filters(rpc_method)
+          final = lambda { __send__(rpc_method) }
+          filters[:around].reverse.inject(final) { |previous, filter|
+            if invoke_filter?(rpc_method, filter)
+              lambda { call_or_send(filter[:callable], &previous) }
+            else
+              previous
+            end
+          }.call
+        end
+
+
+        # Entry method to call each filter type in the appropriate order. This should
+        # be used instead of the other run methods directly.
+        #
+        def run_filters(rpc_method)
+          run_rescue_filters do
+            continue = run_unwrapped_filters(filters[:before], rpc_method, true)
+            if continue
+              run_around_filters(rpc_method)
+              run_unwrapped_filters(filters[:after], rpc_method)
+            end
+          end
+        end
+
+        def run_rescue_filters
+          if rescue_filters.keys.empty?
+            yield
+          else
+            begin
+              yield
+            rescue *rescue_filters.keys => ex
+              callable = rescue_filters.fetch(ex.class) {
+                mapped_klass = rescue_filters.keys.detect { |child_klass| ex.class < child_klass }
+                rescue_filters[mapped_klass]
+              }
+
+              call_or_send(callable, ex)
+            end
+          end
+        end
+
+        # Call the object if it is callable, otherwise invoke the method using
+        # __send__ assuming that we respond_to it. Return the call's return value.
+        #
+        def call_or_send(callable, *args, &block)
+          return_value = case
+                         when callable.respond_to?(:call) then
+                           callable.call(self, *args, &block)
+                         when respond_to?(callable, true) then
+                           __send__(callable, *args, &block)
+                         else
+                           raise "Object #{callable} is not callable"
+                         end
+
+          return return_value
+        end
+
+      end
+
+    end
+  end
+end

data/lib/protobuf/rpc/stat.rb

@@ -0,0 +1,148 @@
+require 'date'
+require 'time'
+require 'protobuf/logger'
+
+module Protobuf
+  module Rpc
+    class Stat
+      attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
+      attr_accessor :response_size, :client, :server, :service, :method_name
+
+      MODES = [:SERVER, :CLIENT].freeze
+
+      # Set the StatsD Client to send stats to. The client must match
+      # the interface provided by lookout-statsd
+      # (https://github.com/lookout/statsd).
+      def self.statsd_client=(statsd_client)
+        @statsd_client = statsd_client
+      end
+
+      # The StatsD Client configured, if any.
+      def self.statsd_client
+        @statsd_client
+      end
+
+      def initialize(mode = :SERVER)
+        @mode = mode
+        @request_size = 0
+        @response_size = 0
+        @success = false
+        @failure_code = nil
+        start
+      end
+
+      def client=(client_host)
+        @client = client_host
+      end
+
+      def client
+        @client || nil
+      end
+
+      def elapsed_time
+        (start_time && end_time ? "#{(end_time - start_time).round(4)}s" : nil)
+      end
+
+      def method_name
+        @method_name ||= @dispatcher.try(:service).try(:method_name)
+      end
+
+      def server=(peer)
+        @server = {:port => peer[0], :ip => peer[1]}
+      end
+
+      def server
+        @server ? "#{@server[:ip]}:#{@server[:port]}" : nil
+      end
+
+      def service
+        @service ||= @dispatcher.try(:service).class.name
+      end
+
+      def sizes
+        if stopped?
+          "#{@request_size}B/#{@response_size}B"
+        else
+          "#{@request_size}B/-"
+        end
+      end
+
+      def start
+        @start_time ||= ::Time.now
+      end
+
+      def stop
+        start unless @start_time
+        @end_time ||= ::Time.now
+        call_statsd_client
+      end
+
+      def success
+        @success = true
+      end
+
+      def failure(code)
+        @failure_code = code
+      end
+
+      def stopped?
+        ! end_time.nil?
+      end
+
+      def rpc
+        service && method_name ? "#{service}##{method_name}" : nil
+      end
+
+      def server?
+        @mode == :SERVER
+      end
+
+      def client?
+        @mode == :CLIENT
+      end
+
+      def to_s
+        [
+          server? ? "[SRV]" : "[CLT]",
+          server? ? client : server,
+          trace_id,
+          rpc,
+          sizes,
+          elapsed_time,
+          @end_time.try(:iso8601)
+        ].compact.join(' - ')
+      end
+
+      def trace_id
+        ::Thread.current.object_id.to_s(16)
+      end
+
+      # Return base path for StatsD metrics
+      def statsd_base_path
+        "rpc.#{service}.#{method_name}".gsub('::', '.').downcase
+      end
+
+      # If a StatsD Client has been configured, send stats to it upon
+      # completion.
+      def call_statsd_client
+        path = statsd_base_path
+        statsd_client = self.class.statsd_client
+        return unless statsd_client
+
+        if @success
+          statsd_client.increment("#{path}.success")
+        elsif @failure_code
+          statsd_client.increment("#{path}.failure.total")
+          statsd_client.increment("#{path}.failure.#{@failure_code}")
+        end
+
+        if start_time && end_time
+          duration = end_time - start_time
+          statsd_client.timing("#{path}.time", duration)
+        end
+      end
+      private :call_statsd_client
+    end
+  end
+end
+