kiev 2.7.3

data/lib/kiev/httparty.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Kiev
+  module HTTParty
+    def self.headers
+      SubrequestHelper.headers
+    end
+  end
+end

data/lib/kiev/json.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Kiev
+  class JSON
+    class << self
+      attr_accessor :engine
+    end
+  end
+end
+
+begin
+  require "oj"
+  Kiev::JSON.engine = :oj
+rescue LoadError
+  require "json"
+
+  if defined?(ActiveSupport::JSON)
+    Kiev::JSON.engine = :activesupport
+  elsif defined?(::JSON)
+    Kiev::JSON.engine = :json
+  end
+end
+
+module Kiev
+  class JSON
+    OJ_OPTIONS_3 = {
+      mode: :rails,
+      use_as_json: true,
+      use_to_json: true
+    } # do not do freeze for Oj3 and Rails 4.1
+
+    OJ_OPTIONS_2 = {
+      float_precision: 16,
+      bigdecimal_as_decimal: false,
+      nan: :null,
+      time_format: :xmlschema,
+      second_precision: 3,
+      mode: :compat,
+      use_as_json: true,
+      use_to_json: true
+    }.freeze
+
+    OJ_OPTIONS = (defined?(Oj::VERSION) && Oj::VERSION >= "3") ? OJ_OPTIONS_3 : OJ_OPTIONS_2
+
+    FAIL_JSON = "{\"error_json\":\"failed to generate json\"}"
+    NO_JSON = "{\"error_json\":\"no json backend\"}"
+
+    class << self
+      def generate(obj)
+        if engine == :oj
+          oj_generate(obj)
+        elsif engine == :activesupport
+          activesupport_generate(obj)
+        elsif engine == :json
+          json_generate(obj)
+        else
+          NO_JSON.dup
+        end
+      end
+
+      def logstash(entry)
+        entry.each do |key, value|
+          entry[key] = if value.respond_to?(:iso8601)
+            value.iso8601(3)
+          elsif !scalar?(value)
+            generate(value)
+          elsif value.is_a?(String) && value.encoding != Encoding::UTF_8
+            value.encode(
+              Encoding::UTF_8,
+              invalid: :replace,
+              undef: :replace,
+              replace: "?"
+            )
+          elsif value.respond_to?(:infinite?) && value.infinite?
+            nil
+          else
+            value
+          end
+        end
+
+        generate(entry) << "\n"
+      end
+
+      private
+
+      # Arrays excluded here because Elastic indexes very picky:
+      # if you have array of mixed things it will complain
+      def scalar?(value)
+        value.is_a?(String) ||
+          value.is_a?(Numeric) ||
+          value.is_a?(Symbol) ||
+          value.is_a?(TrueClass) ||
+          value.is_a?(FalseClass) ||
+          value.is_a?(NilClass)
+      end
+
+      def oj_generate(obj)
+        Oj.dump(obj, OJ_OPTIONS)
+      rescue Exception
+        FAIL_JSON.dup
+      end
+
+      def activesupport_generate(obj)
+        ActiveSupport::JSON.encode(obj)
+      rescue Exception
+        FAIL_JSON.dup
+      end
+
+      def json_generate(obj)
+        ::JSON.generate(obj, quirks_mode: true)
+      rescue Exception
+        FAIL_JSON.dup
+      end
+    end
+  end
+end

data/lib/kiev/logger.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "logger"
+require "time"
+require "forwardable"
+
+# Keep this class minimal and compatible with Ruby Logger.
+# If you add custom methods to this class and they will be used by developer,
+# it will be hard to swap this class with any other Logger implementation.
+module Kiev
+  class Logger
+    extend Forwardable
+    def_delegators(*([:@logger] + ::Logger.instance_methods(false)))
+
+    DEFAULT_EVENT_NAME = "log"
+
+    FORMATTER = proc do |severity, time, event_name, data|
+      entry =
+        {
+          application: Config.instance.app,
+          event: event_name || DEFAULT_EVENT_NAME,
+          level: severity,
+          timestamp: time.utc,
+          request_id: RequestStore.store[:request_id],
+          request_depth: RequestStore.store[:request_depth],
+          tree_path: RequestStore.store[:tree_path]
+        }
+
+      # data required to restore source of log entry
+      if RequestStore.store[:web]
+        entry[:verb] = RequestStore.store[:request_verb]
+        entry[:path] = RequestStore.store[:request_path]
+      end
+      if RequestStore.store[:background_job]
+        entry[:job_name] = RequestStore.store[:job_name]
+        entry[:jid] = RequestStore.store[:jid]
+      end
+
+      if !RequestStore.store[:subrequest_count] && %i(request_finished job_finished).include?(event_name)
+        entry[:tree_leaf] = true
+      end
+
+      if RequestStore.store[:payload]
+        if %i(request_finished job_finished).include?(event_name)
+          entry.merge!(RequestStore.store[:payload])
+        else
+          Config.instance.persistent_log_fields.each do |field|
+            entry[field] = RequestStore.store[:payload][field]
+          end
+        end
+      end
+
+      if data.is_a?(Hash)
+        entry.merge!(data)
+      elsif !data.nil?
+        entry[:message] = data.to_s
+      end
+
+      # Save some disk space
+      entry.reject! { |_, value| value.nil? }
+
+      JSON.logstash(entry)
+    end
+
+    DEVELOPMENT_FORMATTER = proc do |severity, time, event_name, data|
+      entry = []
+
+      entry << time.iso8601
+      entry << (event_name || severity).upcase
+
+      if data.is_a?(String)
+        entry << "#{data}\n"
+      end
+
+      if %i(request_finished job_finished).include?(event_name)
+        verb = RequestStore.store[:request_verb]
+        path = RequestStore.store[:request_path]
+        entry << "#{verb} #{path}" if verb && path
+
+        job_name = RequestStore.store[:job_name]
+        jid = RequestStore.store[:jid]
+        entry << "#{job_name} #{jid}" if job_name && jid
+
+        status = data.is_a?(Hash) ? data.delete(:status) : nil
+        entry << "- #{status}" if status
+        duration = data.is_a?(Hash) ? data.delete(:request_duration) : nil
+        entry << "(#{duration}ms)" if duration
+        entry << "\n"
+
+        meta = {
+          request_id: RequestStore.store[:request_id],
+          request_depth: RequestStore.store[:request_depth]
+        }.merge!(Hash(RequestStore.store[:payload]))
+
+        meta.reject! { |_, value| value.nil? }
+
+        entry << "  Meta: #{meta.inspect}\n"
+
+        entry << "  Params: #{data[:params].inspect}\n" if data.is_a?(Hash) && data[:params]
+
+        if data.is_a?(Hash) && data[:body]
+          entry << "  Response: #{data[:body]}\n"
+        end
+      end
+
+      entry.join(" ")
+    end
+
+    def initialize(log_path)
+      @logger = ::Logger.new(log_path)
+    end
+
+    def path=(log_path)
+      previous_logger = @logger
+      @logger = ::Logger.new(log_path)
+      if previous_logger
+        @logger.level = previous_logger.level
+        @logger.formatter = previous_logger.formatter
+      end
+    end
+  end
+end

data/lib/kiev/param_filter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kiev
+  module ParamFilter
+    FILTERED = "[FILTERED]"
+
+    def self.filter(params, filtered_params, ignored_params)
+      params.each_with_object({}) do |(key, value), acc|
+        next if ignored_params.include?(key)
+
+        if defined?(ActionDispatch) && value.is_a?(ActionDispatch::Http::UploadedFile)
+          value = {
+            original_filename: value.original_filename,
+            content_type: value.content_type,
+            headers: value.headers
+          }
+        end
+
+        acc[key] =
+          if filtered_params.include?(key) && !value.is_a?(Hash)
+            FILTERED
+          elsif value.is_a?(Hash)
+            filter(value, filtered_params, ignored_params)
+          else
+            value
+          end
+      end
+    end
+  end
+end

data/lib/kiev/que/job.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Kiev
+  module Que
+    # Original implementation https://github.com/chanks/que/blob/master/lib/que/job.rb
+    class Job < ::Que::Job
+      include Kiev::RequestStore::Mixin
+
+      def self.enqueue(*args)
+        if ::Que.mode == :async
+          super(*args.unshift(SubrequestHelper.payload))
+        else
+          super
+        end
+      end
+
+      def _run
+        if ::Que.mode == :async
+          wrap_request_store { kiev_run }
+        else
+          kiev_run
+        end
+      end
+
+      private
+
+      NEW_LINE = "\n"
+
+      def kiev_run
+        args = attrs[:args]
+        payload = {}
+
+        if args.first.is_a?(Hash)
+          options = args.shift
+          payload = Config.instance.all_jobs_propagated_fields.map do |key|
+            # sometimes JSON decoder is overridden and it can be instructed to symbolize keys
+            [key, options.delete(key.to_s) || options.delete(key)]
+          end.to_h
+          args.unshift(options) if options.any?
+        end
+
+        if ::Que.mode == :async
+          Config.instance.jobs_propagated_fields.each do |key|
+            Kiev[key] = payload[key]
+          end
+          request_store = Kiev::RequestStore.store
+          request_store[:request_id] = payload[:request_id]
+          request_store[:request_depth] = payload[:request_depth].to_i + 1
+          request_store[:tree_path] = payload[:tree_path]
+
+          request_store[:background_job] = true
+          request_store[:job_name] = attrs[:job_class]
+        end
+
+        began_at = Time.now
+
+        ::Que::Job.instance_method(:_run).bind(self).call
+
+        data = {
+          params: attrs[:args],
+          request_duration: ((Time.now - began_at) * 1000).round(3)
+        }
+
+        error ||= _error
+
+        if error
+          data[:error_class] = error.class.name
+          data[:error_message] = error.message[0..5000]
+          data[:error_backtrace] = Array(error.backtrace).join(NEW_LINE)[0..5000]
+        end
+
+        Kiev.event(:job_finished, data)
+      end
+    end
+  end
+end

data/lib/kiev/rack.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "rack/request_logger"
+require_relative "rack/request_id"
+require_relative "rack/store_request_details"
+require_relative "rack/silence_action_dispatch_logger"
+require_relative "../ext/rack/common_logger"
+
+module Kiev
+  module Rack
+    def self.included(base)
+      # The order is important
+      base.use(::RequestStore::Middleware)
+      base.use(Kiev::Rack::RequestLogger)
+      base.use(Kiev::Rack::StoreRequestDetails)
+      base.use(Kiev::Rack::RequestId)
+    end
+  end
+end

data/lib/kiev/rack/request_id.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Kiev
+  module Rack
+    class RequestId
+      # for Rails 4
+      RAILS_REQUEST_ID = "action_dispatch.request_id"
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request_id_header_out = to_rack(:request_id)
+        request_id_header_in = to_http(:request_id)
+
+        request_id = make_request_id(env[RAILS_REQUEST_ID] || env[request_id_header_in])
+        RequestStore.store[:request_id] = request_id
+        RequestStore.store[:request_depth] = request_depth(env)
+        RequestStore.store[:tree_path] = tree_path(env)
+
+        @app.call(env).tap { |_status, headers, _body| headers[request_id_header_out] = request_id }
+      end
+
+      private
+
+      # TODO: in Rails 5 they set `headers[X_REQUEST_ID]`, so this will not work
+      # https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/request_id.rb
+      # https://github.com/interagent/pliny/blob/master/lib/pliny/middleware/request_id.rb
+      def tree_root?(env)
+        request_id_header_in = to_http(:request_id)
+        !env[request_id_header_in]
+      end
+
+      def request_depth(env)
+        request_depth_header = to_http(:request_depth)
+        tree_root?(env) ? 0 : (env[request_depth_header].to_i + 1)
+      end
+
+      def tree_path(env)
+        tree_path_header = to_http(:tree_path)
+        tree_root?(env) ? SubrequestHelper.root_path(synchronous: true) : Util.sanitize(env[tree_path_header])
+      end
+
+      def to_http(value)
+        Util.to_http(to_rack(value))
+      end
+
+      def to_rack(value)
+        Config.instance.all_http_propagated_fields[value]
+      end
+
+      def make_request_id(request_id)
+        if request_id.nil? || request_id.empty?
+          internal_request_id
+        else
+          Util.sanitize(request_id)
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.uuid
+      end
+    end
+  end
+end