istox_gruf 2.7.1

data/lib/gruf/interceptors/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# 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
+    ##
+    # Base class for interception requests
+    #
+    class Base
+      # @var [Gruf::Controllers::Request] request
+      attr_reader :request
+      # @var [Gruf::Error] error
+      attr_reader :error
+      # @var [Hash] options
+      attr_reader :options
+
+      ##
+      # @param [Gruf::Controllers::Request] request
+      # @param [Gruf::Error] error
+      # @param [Hash] options
+      #
+      def initialize(request, error, options = {})
+        @request = request
+        @error = error
+        @options = options || {}
+      end
+    end
+  end
+end
+
+require_relative 'client_interceptor'
+require_relative 'server_interceptor'
+require_relative 'context'
+require_relative 'timer'
+require_relative 'active_record/connection_reset'
+require_relative 'authentication/basic'
+require_relative 'instrumentation/statsd'
+require_relative 'instrumentation/output_metadata_timer'
+require_relative 'instrumentation/request_logging/interceptor'

data/lib/gruf/interceptors/client_interceptor.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# 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
+    ##
+    # Intercepts outbound client requests to provide a unified interface and request context
+    #
+    class ClientInterceptor < GRPC::ClientInterceptor
+      include Gruf::Loggable
+
+      ##
+      # Handles interception of outbound calls. Implement this in your derivative interceptor implementation.
+      #
+      # @param [Gruf::Outbound::RequestContext] request_context The context of the outbound request
+      # @return [Object] This method must return the response from the yielded block
+      #
+      def call(request_context:)
+        logger.debug "Logging client interceptor for request: #{request_context.method}"
+        yield
+      end
+
+      ##
+      # Call the interceptor from the request_response call
+      #
+      # @param [Object] request The request being sent
+      # @param [GRPC::ActiveCall] call The GRPC ActiveCall object
+      # @param [Method] method The method being called
+      # @param [Hash] metadata A hash of outgoing metadata
+      # @return [Object] The response message
+      #
+      def request_response(request: nil, call: nil, method: nil, metadata: nil)
+        rc = Gruf::Outbound::RequestContext.new(
+          type: :request_response,
+          requests: [request],
+          call: call,
+          method: method,
+          metadata: metadata
+        )
+        call(request_context: rc) do
+          yield
+        end
+      end
+
+      ##
+      # Call the interceptor from the client_streamer call
+      #
+      # @param [Enumerable] requests An enumerable of requests being sent
+      # @param [GRPC::ActiveCall] call The GRPC ActiveCall object
+      # @param [Method] method The method being called
+      # @param [Hash] metadata A hash of outgoing metadata
+      # @return [Object] The response message
+      #
+      def client_streamer(requests: nil, call: nil, method: nil, metadata: nil)
+        rc = Gruf::Outbound::RequestContext.new(
+          type: :client_streamer,
+          requests: requests,
+          call: call,
+          method: method,
+          metadata: metadata
+        )
+        call(request_context: rc) do
+          yield
+        end
+      end
+
+      ##
+      # Call the interceptor from the server_streamer call
+      #
+      # @param [Object] request The request being sent
+      # @param [GRPC::ActiveCall] call The GRPC ActiveCall object
+      # @param [Method] method The method being called
+      # @param [Hash] metadata A hash of outgoing metadata
+      # @return [Object] The response message
+      #
+      def server_streamer(request: nil, call: nil, method: nil, metadata: nil)
+        rc = Gruf::Outbound::RequestContext.new(
+          type: :server_streamer,
+          requests: [request],
+          call: call,
+          method: method,
+          metadata: metadata
+        )
+        call(request_context: rc) do
+          yield
+        end
+      end
+
+      ##
+      # Call the interceptor from the bidi_streamer call
+      #
+      # @param [Enumerable] requests An enumerable of requests being sent
+      # @param [GRPC::ActiveCall] call The GRPC ActiveCall object
+      # @param [Method] method The method being called
+      # @param [Hash] metadata A hash of outgoing metadata
+      #
+      def bidi_streamer(requests: nil, call: nil, method: nil, metadata: nil)
+        rc = Gruf::Outbound::RequestContext.new(
+          type: :bidi_streamer,
+          requests: requests,
+          call: call,
+          method: method,
+          metadata: metadata
+        )
+        call(request_context: rc) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/gruf/interceptors/context.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# 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
+    ##
+    # Runs interceptors in a given request context
+    #
+    class Context
+      include Gruf::Loggable
+
+      ##
+      # Initialize the interception context
+      #
+      # @param [Array<Gruf::Interceptors::ServerInterceptor>] interceptors
+      #
+      def initialize(interceptors = [])
+        @interceptors = interceptors
+      end
+
+      ##
+      # Intercept the given request and run interceptors in a FIFO execution order
+      #
+      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
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# 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/interceptors/instrumentation/request_logging/formatters/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# 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
+      module RequestLogging
+        module Formatters
+          ##
+          # Base class for request log formatting
+          #
+          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
+    end
+  end
+end

data/lib/gruf/interceptors/instrumentation/request_logging/formatters/logstash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# 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 'json'
+
+module Gruf
+  module Interceptors
+    module Instrumentation
+      module RequestLogging
+        module Formatters
+          ##
+          # Formats logging for gruf services into a Logstash-friendly JSON format
+          #
+          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
+    end
+  end
+end

data/lib/gruf/interceptors/instrumentation/request_logging/formatters/plain.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# 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
+      module RequestLogging
+        module Formatters
+          ##
+          # Formats the request into plaintext logging
+          #
+          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
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+# 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
+          # Default mappings of codes to log levels...
+          LOG_LEVEL_MAP = {
+            'GRPC::Ok' => :debug,
+            'GRPC::InvalidArgument' => :debug,
+            'GRPC::NotFound' => :debug,
+            'GRPC::AlreadyExists' => :debug,
+            'GRPC::OutOfRange' => :debug,
+            'GRPC::Unauthenticated' => :warn,
+            'GRPC::PermissionDenied' => :warn,
+            'GRPC::Unknown' => :error,
+            'GRPC::Internal' => :error,
+            'GRPC::DataLoss' => :error,
+            'GRPC::FailedPrecondition' => :error,
+            'GRPC::Unavailable' => :error,
+            'GRPC::DeadlineExceeded' => :error,
+            'GRPC::Cancelled' => :error
+          }.freeze
+
+          ###
+          # Log the request, sending it to the appropriate formatter
+          #
+          # @return [String]
+          #
+          def call
+            return yield if options.fetch(:ignore_methods, []).include?(request.method_name)
+
+            result = Gruf::Interceptors::Timer.time do
+              yield
+            end
+
+            # Fetch log level options and merge with default...
+            log_level_map = LOG_LEVEL_MAP.merge(options.fetch(:log_levels, {}))
+
+            # A result is either successful, or, some level of feedback handled in the else block...
+            if result.successful?
+              type = log_level_map['GRPC::Ok'] || :debug
+              status_name = 'GRPC::Ok'
+            else
+              type = log_level_map[result.message_class_name] || :error
+              status_name = result.message_class_name
+            end
+
+            payload = {}
+            if !request.client_streamer? && !request.bidi_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
+
+            logger.send(type, formatter.format(payload))
+
+            raise result.message unless result.successful?
+
+            result.message
+          end
+
+          private
+
+          ##
+          # @return [::Gruf::Logger]
+          #
+          def logger
+            @logger ||= options.fetch(:logger, ::Gruf.logger)
+          end
+
+          ##
+          # 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)
+            return "[GRPC::Ok] (#{request.method_name})" if result.successful?
+
+            "[#{result.message_class_name}] (#{request.method_name}) #{result.message.message}"
+          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
+                             prefix = 'Gruf::Interceptors::Instrumentation::RequestLogging::Formatters::'
+                             klass = "#{prefix}#{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.each_key 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