kiev 2.7.3

data/lib/kiev/rack/request_logger.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Kiev
+  module Rack
+    class RequestLogger
+      ERROR_STATUS = 500
+      ERROR_HEADERS = [].freeze
+      ERROR_BODY = [""].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        rescued_exception = nil
+        began_at = Time.now.to_f
+
+        request = ::Rack::Request.new(env)
+
+        begin
+          status, headers, body = @app.call(env)
+        rescue Exception => e
+          rescued_exception = e
+
+          status = ERROR_STATUS
+          headers = ERROR_HEADERS
+          body = ERROR_BODY
+
+          if defined?(ActionDispatch::ExceptionWrapper)
+            status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(rescued_exception.class.name)
+          end
+        end
+
+        response = ::Rack::Response.new(body, status, headers)
+
+        rack_exception = log_rack_exception?(env[SINATRA_ERROR]) ? env[SINATRA_ERROR] : nil
+        log_exception = RequestStore.store[:error]
+        exception = rescued_exception || rack_exception || log_exception
+
+        if exception || Config.instance.log_request_condition.call(request, response)
+          Kiev.event(
+            :request_finished,
+            form_data(
+              began_at: began_at,
+              env: env,
+              request: request,
+              response: response,
+              status: status,
+              body: body,
+              exception: exception
+            )
+          )
+        end
+
+        raise rescued_exception if rescued_exception
+
+        [status, headers, body]
+      end
+
+      private
+
+      HTTP_USER_AGENT = "HTTP_USER_AGENT"
+      ACTION_REQUEST_PARAMETERS = "action_dispatch.request.request_parameters"
+      ACTION_QUERY_PARAMETERS = "action_dispatch.request.query_parameters"
+      NEW_LINE = "\n"
+      HTTP_X_REQUEST_START = "HTTP_X_REQUEST_START"
+      SINATRA_ERROR = "sinatra.error"
+
+      def log_rack_exception?(exception)
+        !Config.instance.ignored_rack_exceptions.include?(exception.class.name)
+      end
+
+      def form_data(request:, began_at:, status:, env:, body:, response:, exception:)
+        config = Config.instance
+
+        params =
+          if env[ACTION_REQUEST_PARAMETERS] && env[ACTION_QUERY_PARAMETERS]
+            env[ACTION_REQUEST_PARAMETERS].merge(env[ACTION_QUERY_PARAMETERS])
+          elsif env[ACTION_REQUEST_PARAMETERS]
+            env[ACTION_REQUEST_PARAMETERS]
+          else
+            request.params
+          end
+
+        params = ParamFilter.filter(params, config.filtered_params, config.ignored_params)
+
+        data = {
+          host: request.host, # env["HTTP_HOST"] || env["HTTPS_HOST"],
+          params: params.empty? ? nil : params, # env[Rack::QUERY_STRING],
+          ip: request.ip, # split_http_x_forwarded_headers(env) || env["REMOTE_ADDR"]
+          user_agent: env[HTTP_USER_AGENT],
+          status: status,
+          request_duration: ((Time.now.to_f - began_at) * 1000).round(3),
+          route: extract_route(env)
+        }
+
+        if env[HTTP_X_REQUEST_START]
+          data[:request_latency] = ((began_at - env[HTTP_X_REQUEST_START].to_f) * 1000).round(3)
+        end
+
+        if config.log_request_body_condition.call(request, response)
+          data[:request_body] =
+            RequestBodyFilter.filter(
+              request.content_type,
+              request.body,
+              config.filtered_params,
+              config.ignored_params
+            )
+        end
+
+        if config.log_response_body_condition.call(request, response)
+          # it should always respond to each, but this code is not streaming friendly
+          full_body = []
+          body.each do |str|
+            full_body << str
+          end
+          data[:body] = full_body.join
+        end
+
+        should_log_errors = config.log_request_error_condition.call(request, response)
+        if should_log_errors && exception.is_a?(Exception)
+          data[:error_class] = exception.class.name
+          data[:error_message] = exception.message[0..5000]
+          data[:error_backtrace] = Array(exception.backtrace).join(NEW_LINE)[0..5000]
+        end
+
+        data
+      end
+
+      def extract_route(env)
+        action_params = env["action_dispatch.request.parameters"]
+        if action_params
+          "#{action_params['controller']}##{action_params['action']}"
+        else
+          env["sinatra.route"]
+        end
+      end
+    end
+  end
+end

data/lib/kiev/rack/silence_action_dispatch_logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kiev
+  module Rack
+    class SilenceActionDispatchLogger
+      class << self
+        attr_accessor :disabled
+      end
+
+      NULL_LOGGER = ::Logger.new("/dev/null")
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["action_dispatch.logger"] = NULL_LOGGER unless self.class.disabled
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/kiev/rack/store_request_details.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kiev
+  module Rack
+    class StoreRequestDetails
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+        RequestStore.store[:web] = true
+        RequestStore.store[:request_verb] = request.request_method
+        RequestStore.store[:request_path] = request.path
+
+        Config.instance.pre_rack_hook.call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/kiev/railtie.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "action_view/log_subscriber"
+require "action_controller/log_subscriber"
+
+module Kiev
+  class Railtie < Rails::Railtie
+    initializer("kiev.insert_middleware") do |app|
+      app.config.middleware.insert_after(::RequestStore::Middleware, Kiev::Rack::RequestId)
+      app.config.middleware.insert_after(Kiev::Rack::RequestId, Kiev::Rack::StoreRequestDetails)
+      app.config.middleware.insert_after(ActionDispatch::ShowExceptions, Kiev::Rack::RequestLogger)
+    end
+
+    if Config.instance.disable_default_logger
+      initializer("kiev.disable_default_logger") do |app|
+        app.config.middleware.delete(Rails::Rack::Logger)
+        app.config.middleware.insert_before(ActionDispatch::DebugExceptions, Kiev::Rack::SilenceActionDispatchLogger)
+        Rails.logger = Config.instance.logger
+        app.config.after_initialize do
+          Kiev::Rack::SilenceActionDispatchLogger.disabled = app.config.consider_all_requests_local
+          remove_existing_log_subscriptions unless Kiev::Config.instance.development_mode
+        end
+      end
+    end
+
+    private
+
+    def remove_existing_log_subscriptions
+      ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+        case subscriber
+        when ActionView::LogSubscriber
+          unsubscribe(:action_view, subscriber)
+        when ActionController::LogSubscriber
+          unsubscribe(:action_controller, subscriber)
+        when defined?(ActiveRecord::LogSubscriber) && ActiveRecord::LogSubscriber
+          unsubscribe(:active_record, subscriber)
+        when defined?(SequelRails::Railties::LogSubscriber) && SequelRails::Railties::LogSubscriber
+          unsubscribe(:sequel, subscriber)
+        end
+      end
+    end
+
+    def unsubscribe(component, subscriber)
+      events = subscriber.public_methods(false).reject { |method| method.to_s == "call" }
+      events.each do |event|
+        ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
+          if listener.instance_variable_get("@delegate") == subscriber
+            ActiveSupport::Notifications.unsubscribe(listener)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kiev/request_body_filter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "request_body_filter/default"
+require_relative "request_body_filter/xml"
+require_relative "request_body_filter/json"
+require_relative "request_body_filter/form_data"
+
+module Kiev
+  module RequestBodyFilter
+    FILTERED = "[FILTERED]"
+
+    JSON_CONTENT_TYPE = %w(text/json application/json)
+    XML_CONTENT_TYPES = %w(text/xml application/xml)
+    FORM_DATA_CONTENT_TYPES = %w(application/x-www-form-urlencoded multipart/form-data)
+
+    def self.for_content_type(content_type)
+      case content_type
+      when *JSON_CONTENT_TYPE
+        Json
+      when *XML_CONTENT_TYPES
+        Xml
+      when *FORM_DATA_CONTENT_TYPES
+        FormData
+      else
+        Default
+      end
+    end
+
+    def self.filter(content_type, request_body, filtered_params, ignored_params)
+      body = request_body.read
+      request_body.rewind
+      body_filter = for_content_type(content_type)
+      body_filter.call(body, filtered_params, ignored_params)
+    end
+  end
+end

data/lib/kiev/request_body_filter/default.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kiev
+  module RequestBodyFilter
+    class Default
+      def self.call(request_body, _filtered_params, _ignored_params)
+        request_body
+      end
+    end
+  end
+end

data/lib/kiev/request_body_filter/form_data.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kiev
+  module RequestBodyFilter
+    class FormData
+      def self.call(request_body, filtered_params, ignored_params)
+        params = ::Rack::Utils.parse_nested_query(request_body)
+        ParamFilter.filter(params, filtered_params, ignored_params)
+      end
+    end
+  end
+end

data/lib/kiev/request_body_filter/json.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kiev
+  module RequestBodyFilter
+    class Json
+      def self.call(request_body, filtered_params, ignored_params)
+        params = ::JSON.parse(request_body)
+        ParamFilter.filter(params, filtered_params, ignored_params)
+      rescue Exception
+        request_body
+      end
+    end
+  end
+end

data/lib/kiev/request_body_filter/xml.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "oga"
+
+module Kiev
+  module RequestBodyFilter
+    class Xml
+      def self.call(request_body, filtered_params, _ignored_params)
+        document = Oga.parse_xml(request_body)
+        filtered_params.each do |param|
+          sensitive_param = document.at_xpath("//#{param}/text()")
+          sensitive_param.text = FILTERED if sensitive_param.respond_to?(:text=)
+        end
+        document.to_xml
+      end
+    end
+  end
+end

data/lib/kiev/request_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kiev
+  module RequestStore
+    def self.store
+      ::RequestStore.store[:kiev] ||= {}
+    end
+
+    module Mixin
+      def wrap_request_store_13
+        ::RequestStore.begin!
+        yield
+      ensure
+        ::RequestStore.end!
+        ::RequestStore.clear!
+      end
+
+      def wrap_request_store_10
+        ::RequestStore.clear!
+        yield
+      ensure
+        ::RequestStore.clear!
+      end
+
+      if ::RequestStore::VERSION >= "1.3"
+        alias_method :wrap_request_store, :wrap_request_store_13
+      else
+        alias_method :wrap_request_store, :wrap_request_store_10
+      end
+    end
+  end
+end

data/lib/kiev/sidekiq.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Kiev
+  module Sidekiq
+    require_relative "sidekiq/client_request_id"
+    require_relative "sidekiq/request_store"
+    require_relative "sidekiq/request_logger"
+    require_relative "sidekiq/request_id"
+    require_relative "sidekiq/store_request_details"
+
+    class << self
+      def enable(base = nil)
+        base ||= ::Sidekiq
+        base.configure_client do |config|
+          enable_client_middleware(config)
+        end
+        base.configure_server do |config|
+          enable_client_middleware(config)
+          enable_server_middleware(config)
+        end
+      end
+
+      def enable_server_middleware(config)
+        config.server_middleware do |chain|
+          chain.prepend(Kiev::Sidekiq::RequestLogger)
+          chain.prepend(Kiev::Sidekiq::StoreRequestDetails)
+          chain.prepend(Kiev::Sidekiq::RequestId)
+          chain.prepend(Kiev::Sidekiq::RequestStore)
+        end
+      end
+
+      def enable_client_middleware(config)
+        config.client_middleware do |chain|
+          chain.prepend(Kiev::Sidekiq::ClientRequestId)
+        end
+      end
+    end
+  end
+end

data/lib/kiev/sidekiq/client_request_id.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kiev
+  module Sidekiq
+    class ClientRequestId
+      def call(_worker_class, job, _queue, _redis_pool)
+        job.merge!(SubrequestHelper.payload)
+        yield
+      end
+    end
+  end
+end

data/lib/kiev/sidekiq/request_id.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Kiev
+  module Sidekiq
+    class RequestId
+      REQUEST_ID = "request_id"
+      REQUEST_DEPTH = "request_depth"
+      TREE_PATH = "tree_path"
+
+      def call(_worker, job, _queue)
+        Kiev::RequestStore.store[:request_id] = request_id(job)
+        Kiev::RequestStore.store[:request_depth] = request_depth(job)
+        Kiev::RequestStore.store[:tree_path] = tree_path(job)
+        yield
+      end
+
+      private
+
+      def request_id(job)
+        # cron jobs will be triggered without request_id
+        job[REQUEST_ID] || SecureRandom.uuid
+      end
+
+      def tree_root?(job)
+        !job[REQUEST_ID]
+      end
+
+      def request_depth(job)
+        tree_root?(job) ? 0 : (job[REQUEST_DEPTH].to_i + 1)
+      end
+
+      def tree_path(job)
+        tree_root?(job) ? SubrequestHelper.root_path(synchronous: false) : job[TREE_PATH]
+      end
+    end
+  end
+end