gruf 1.2.7 → 2.0.0

data/lib/gruf/{instrumentation/output_metadata_timer.rb → interceptors/context.rb}

@@ -15,30 +15,40 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 module Gruf
-  module Instrumentation
+  module Interceptors
     ##
-    # Appends the timer metadata to the active call output metadata
+    # Runs interceptors in a given request context
     #
-    class OutputMetadataTimer < Gruf::Instrumentation::Base
+    class Context
+      include Gruf::Loggable
+
       ##
-      # Handle the instrumented response. Note: this will only instrument timings of _successful_ responses.
+      # Initialize the interception context
       #
-      # @param [Gruf::Instrumentation::RequestContext] rc The current request context for the call
-      # @return [Hash] The resulting output metadata with the timer attached
+      # @param [Array<Gruf::Interceptors::ServerInterceptor>] interceptors
       #
-      def call(rc)
-        return unless rc.active_call && rc.active_call.respond_to?(:output_metadata)
-
-        rc.active_call.output_metadata.update(metadata_key => rc.execution_time.to_s)
+      def initialize(interceptors = [])
+        @interceptors = interceptors
       end
 
-      private
-
       ##
-      # @return [Symbol] The metadata key that the time result should be set to
+      # Intercept the given request and run interceptors in a FIFO execution order
       #
-      def metadata_key
-        options.fetch(:output_metadata_timer, {}).fetch(:metadata_key, :timer).to_sym
+      def intercept!
+        return yield if @interceptors.none?
+
+        i = @interceptors.pop
+        return yield unless i
+
+        logger.debug "Intercepting request with interceptor: #{i.class}"
+
+        i.call do
+          if @interceptors.any?
+            intercept! { yield }
+          else
+            yield
+          end
+        end
       end
     end
   end

data/lib/gruf/interceptors/instrumentation/output_metadata_timer.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+# 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
+  module Interceptors
+    module Instrumentation
+      ##
+      # Appends the timer metadata to the active call output metadata
+      #
+      class OutputMetadataTimer < ::Gruf::Interceptors::ServerInterceptor
+        delegate :active_call, to: :request
+
+        ##
+        # Handle the instrumented response. Note: this will only instrument timings of _successful_ responses.
+        #
+        def call
+          return unless active_call.respond_to?(:output_metadata)
+
+          result = Gruf::Interceptors::Timer.time do
+            yield
+          end
+          output_metadata.update(metadata_key => result.elapsed.to_s)
+
+          raise result.message unless result.successful?
+          result.message
+        end
+
+        private
+
+        ##
+        # @return [Symbol] The metadata key that the time result should be set to
+        #
+        def metadata_key
+          options.fetch(:metadata_key, :timer).to_sym
+        end
+
+        ##
+        # @return [Hash]
+        #
+        def output_metadata
+          active_call.output_metadata
+        end
+      end
+    end
+  end
+end

data/lib/gruf/{instrumentation → interceptors/instrumentation}/request_logging/formatters/base.rb

@@ -15,21 +15,23 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 module Gruf
-  module Instrumentation
-    module RequestLogging
-      module Formatters
-        ##
-        # Base class for request log formatting
-        #
-        class Base
+  module Interceptors
+    module Instrumentation
+      module RequestLogging
+        module Formatters
           ##
-          # Format the parameters into a loggable string. Must be implemented in every derivative class
+          # Base class for request log formatting
           #
-          # @param [Hash] _payload The incoming request payload
-          # @return [String] The formatted string
-          #
-          def format(_payload)
-            raise NotImplementedError
+          class Base
+            ##
+            # Format the parameters into a loggable string. Must be implemented in every derivative class
+            #
+            # @param [Hash] _payload The incoming request payload
+            # @return [String] The formatted string
+            #
+            def format(_payload)
+              raise NotImplementedError
+            end
           end
         end
       end

data/lib/gruf/{instrumentation → interceptors/instrumentation}/request_logging/formatters/logstash.rb

@@ -17,21 +17,23 @@
 require 'json'
 
 module Gruf
-  module Instrumentation
-    module RequestLogging
-      module Formatters
-        ##
-        # Formats logging for gruf services into a Logstash-friendly JSON format
-        #
-        class Logstash < Base
+  module Interceptors
+    module Instrumentation
+      module RequestLogging
+        module Formatters
           ##
-          # Format the request into a JSON-friendly payload
+          # Formats logging for gruf services into a Logstash-friendly JSON format
           #
-          # @param [Hash] payload The incoming request payload
-          # @return [String] The JSON representation of the payload
-          #
-          def format(payload)
-            payload.merge(format: 'json').to_json
+          class Logstash < Base
+            ##
+            # Format the request into a JSON-friendly payload
+            #
+            # @param [Hash] payload The incoming request payload
+            # @return [String] The JSON representation of the payload
+            #
+            def format(payload)
+              payload.merge(format: 'json').to_json
+            end
           end
         end
       end

data/lib/gruf/{instrumentation → interceptors/instrumentation}/request_logging/formatters/plain.rb

@@ -15,28 +15,30 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 module Gruf
-  module Instrumentation
-    module RequestLogging
-      module Formatters
-        ##
-        # Formats the request into plaintext logging
-        #
-        class Plain < Base
+  module Interceptors
+    module Instrumentation
+      module RequestLogging
+        module Formatters
           ##
-          # Format the request by only outputting the message body and params (if set to log params)
+          # Formats the request into plaintext logging
           #
-          # @param [Hash] payload The incoming request payload
-          # @return [String] The formatted string
-          #
-          def format(payload)
-            time = payload.fetch(:duration, 0)
-            grpc_status = payload.fetch(:grpc_status, 'GRPC::Ok')
-            route_key = payload.fetch(:method, 'unknown')
-            body = payload.fetch(:message, '')
+          class Plain < Base
+            ##
+            # Format the request by only outputting the message body and params (if set to log params)
+            #
+            # @param [Hash] payload The incoming request payload
+            # @return [String] The formatted string
+            #
+            def format(payload)
+              time = payload.fetch(:duration, 0)
+              grpc_status = payload.fetch(:grpc_status, 'GRPC::Ok')
+              route_key = payload.fetch(:method, 'unknown')
+              body = payload.fetch(:message, '')
 
-            msg = "[#{grpc_status}] (#{route_key}) [#{time}ms] #{body}".strip
-            msg += " Parameters: #{payload[:params].to_h}" if payload.key?(:params)
-            msg.strip
+              msg = "[#{grpc_status}] (#{route_key}) [#{time}ms] #{body}".strip
+              msg += " Parameters: #{payload[:params].to_h}" if payload.key?(:params)
+              msg.strip
+            end
           end
         end
       end

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

@@ -0,0 +1,191 @@
+# coding: utf-8
+# 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 'socket'
+require_relative 'formatters/base'
+require_relative 'formatters/logstash'
+require_relative 'formatters/plain'
+
+module Gruf
+  module Interceptors
+    module Instrumentation
+      module RequestLogging
+        ##
+        # Represents an error if the formatter does not extend the base formatter
+        #
+        class InvalidFormatterError < StandardError; end
+
+        ##
+        # Handles Rails-style request logging for gruf services.
+        #
+        # This is added by default to gruf servers; if you have `Gruf.use_default_hooks = false`, you can add it back
+        # manually by doing:
+        #
+        #   Gruf::Instrumentation::Registry.add(:request_logging, Gruf::Instrumentation::RequestLogging::Hook)
+        #
+        class Interceptor < ::Gruf::Interceptors::ServerInterceptor
+
+          ###
+          # Log the request, sending it to the appropriate formatter
+          #
+          # @return [String]
+          #
+          def call
+            result = Gruf::Interceptors::Timer.time do
+              yield
+            end
+
+            if result.successful?
+              type = options.fetch(:success_log_level, :info).to_sym
+              status_name = 'GRPC::Ok'
+            else
+              type = options.fetch(:failure_log_level, :error).to_sym
+              status_name = result.message_class_name
+            end
+
+            payload = {}
+            if !request.client_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?)
+            else
+              payload[:params] = {}
+              payload[:message] = ''
+              payload[:status] = GRPC::Core::StatusCodes::OK
+            end
+            payload[:service] = request.service_key
+            payload[:method] = request.method_key
+            payload[:action] = request.method_key
+            payload[:grpc_status] = status_name
+            payload[:duration] = result.elapsed_rounded
+            payload[:thread_id] = Thread.current.object_id
+            payload[:time] = Time.now.to_s
+            payload[:host] = Socket.gethostname
+
+            ::Gruf.logger.send(type, formatter.format(payload))
+
+            raise result.message unless result.successful?
+            result.message
+          end
+
+          private
+
+          ##
+          # Return an appropriate log message dependent on the status
+          #
+          # @param [Gruf::Controllers::Request] request
+          # @param [Gruf::Interceptors::Timer::Result] result
+          # @return [String] The appropriate message body
+          #
+          def message(request, result)
+            if result.successful?
+              "[GRPC::Ok] (#{request.method_name})"
+            else
+              "[#{result.message_class_name}] (#{request.method_name}) #{result.message.message}"
+            end
+          end
+
+          ##
+          # Return the proper status code for the response
+          #
+          # @param [Object] response The response object
+          # @param [Boolean] successful If the response was successful
+          # @return [Boolean] The proper status code
+          #
+          def status(response, successful)
+            successful ? GRPC::Core::StatusCodes::OK : response.code
+          end
+
+          ##
+          # Determine the appropriate formatter for the request logging
+          #
+          # @return [Gruf::Instrumentation::RequestLogging::Formatters::Base]
+          #
+          def formatter
+            unless @formatter
+              fmt = options.fetch(:formatter, :plain)
+              @formatter = case fmt
+                             when Symbol
+                               klass = "Gruf::Interceptors::Instrumentation::RequestLogging::Formatters::#{fmt.to_s.capitalize}"
+                               fmt = klass.constantize.new
+                             when Class
+                               fmt = fmt.new
+                             else
+                               fmt
+                           end
+              raise InvalidFormatterError unless fmt.is_a?(Formatters::Base)
+            end
+            @formatter
+          end
+
+          ##
+          # Redact any blacklisted params and return an updated hash
+          #
+          # @param [Hash] params The hash of parameters to sanitize
+          # @return [Hash] The sanitized params in hash form
+          #
+          def sanitize(params = {})
+            blacklists = options.fetch(:blacklist, []).map(&:to_s)
+            redacted_string = options.fetch(:redacted_string, 'REDACTED')
+            blacklists.each do |blacklist|
+              parts = blacklist.split('.').map(&:to_sym)
+              redact!(parts, 0, params, redacted_string)
+            end
+            params
+          end
+
+          ##
+          # Helper method to recursively redact based on the black list
+          #
+          # @param [Array] parts The blacklist. ex. 'data.schema' -> [:data, :schema]
+          # @param [Integer] idx The current index of the blacklist
+          # @param [Hash] params The hash of parameters to sanitize
+          # @param [String] redacted_string The custom redact string
+          #
+          def redact!(parts = [], idx = 0, params = {}, redacted_string = 'REDACTED')
+            return unless parts.is_a?(Array) && params.is_a?(Hash)
+            return if idx >= parts.size || !params.key?(parts[idx])
+            if idx == parts.size - 1
+              if params[parts[idx]].is_a? Hash
+                hash_deep_redact!(params[parts[idx]], redacted_string)
+              else
+                params[parts[idx]] = redacted_string
+              end
+              return
+            end
+            redact!(parts, idx + 1, params[parts[idx]], redacted_string)
+          end
+
+          ##
+          # Helper method to recursively redact the value of all hash keys
+          #
+          # @param [Hash] hash Part of the hash of parameters to sanitize
+          # @param [String] redacted_string The custom redact string
+          #
+          def hash_deep_redact!(hash, redacted_string)
+            hash.keys.each do |key|
+              if hash[key].is_a? Hash
+                hash_deep_redact!(hash[key], redacted_string)
+              else
+                hash[key] = redacted_string
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gruf/interceptors/instrumentation/statsd.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+# 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
+  module Interceptors
+    module Instrumentation
+      ##
+      # Adds increment and timing stats to gRPC routes, pushing data to StatsD
+      #
+      class Statsd < Gruf::Interceptors::ServerInterceptor
+        ##
+        # Push data to StatsD, only doing so if a client is set
+        #
+        def call
+          unless client
+            Gruf.logger.error 'Statsd module loaded, but no client configured!'
+            return yield
+          end
+
+          client.increment(route_key)
+
+          result = Gruf::Interceptors::Timer.time do
+            yield
+          end
+
+          client.increment("#{route_key}.#{postfix(result.successful?)}")
+          client.timing(route_key, result.elapsed)
+
+          raise result.message unless result.successful?
+          result.message
+        end
+
+        private
+
+        ##
+        # @param [Boolean] successful Whether or not the request was successful
+        # @return [String] The appropriate postfix for the key dependent on response status
+        #
+        def postfix(successful)
+          successful ? 'success' : 'failure'
+        end
+
+        ##
+        # @return [String] Return a composed route key that is used in the statsd metric
+        #
+        def route_key
+          "#{key_prefix}#{request.method_name}"
+        end
+
+        ##
+        # @return [String] Return the sanitized key prefix for the statsd metric key
+        #
+        def key_prefix
+          prefix = options.fetch(:prefix, '').to_s
+          prefix.empty? ? '' : "#{prefix}."
+        end
+
+        ##
+        # @return [::Statsd] Return the given StatsD client
+        #
+        def client
+          @client ||= options.fetch(:client, nil)
+        end
+      end
+    end
+  end
+end