kiev 4.5.0 → 4.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f160c0e287ac552fab279ebc1974bf2de5704af494766872e1e2abfa11b48766
-  data.tar.gz: f2601c9be33ecc63b3741e76832b2b409250a4b5e7365ede3a40cc6a59c0eb6f
+  metadata.gz: 4d40605191a7b91d8df6797e3d0e9fa73f82eec5b60dc340f600f5a70b1374ce
+  data.tar.gz: 524309f5f0e91a96abc5d85ae158e9316f71c13af2f4076742c14f45812aaec8
 SHA512:
-  metadata.gz: 9560e9929db4c64e968dc39d2efadb6b9a09cff5ced0a7e5ffacd823c63273bcd05be4e1918b5e4b70586c73f8520e4d62dccc9e83795908f0981d0ed14ca6e1
-  data.tar.gz: 4caa6b83331e522867ec3254ac5a3f0356c3336a452ade39e9c8df022f5409a17cc1a024c10cee80353252bec8da66b36aea5430cc4947c59acc0dab0fa1eccd
+  metadata.gz: 52737e6382ca2e0ce2e6cf5c0ead72a30454e456ea8b126fc65c30f06c68dc02ba082f74534a84e041b88931d1ea6de1f365d6dff73e148c160c158659553b3f
+  data.tar.gz: 9010b961ccbef8dcbc2f39a844ab1f2992e50f7d4ede821cc5329391df24f5e8fde18422d06aa20f9fbc6110fa60d9d1170bd1b95918e7c630413c1f89c1d42e

data/README.md

@@ -176,13 +176,13 @@ Kiev::Kafka.inject_context(headers)
 
 After this operation the headers variable will also include required context for the Kiev logger.
 
-If you have a consumed `Kafka::FetchedMessage` you can extract logger context with: 
+If you have a consumed `Kafka::FetchedMessage` you can extract logger context with:
 
 ```ruby
 Kiev::Kafka.extract_context(message)
 ```
 
-This will work regardless if headers are in HTTP format, e.g. `X-Tracking-Id` or plain field names: `tracking_id`. Plus the `message_key` field will contain the key of processed message. In case you want to log some more fields configure `persistent_log_fields` and `jobs_propagated_fields`.  
+This will work regardless if headers are in HTTP format, e.g. `X-Tracking-Id` or plain field names: `tracking_id`. Plus the `message_key` field will contain the key of processed message. In case you want to log some more fields configure `persistent_log_fields` and `jobs_propagated_fields`.
 
 ### Que
 
@@ -251,7 +251,7 @@ For web requests the Kiev middleware will log the following information by defau
 
 * `request_id` is the correlation ID and will be the same across all requests within a chain of requests. It's represented as a UUID (version 4). (currently deprecated in favor of a new name: `tracking_id`)
 
-* `tracking_id` is the correlation ID and will be the same across all requests within a chain of requests. It's represented as a UUID (version 4). If not provided the value is seeded from deprecated `request_id`. 
+* `tracking_id` is the correlation ID and will be the same across all requests within a chain of requests. It's represented as a UUID (version 4). If not provided the value is seeded from deprecated `request_id`.
 
 * `request_depth` represents the position of the current request within a chain of requests. It starts with 0.
 
@@ -317,6 +317,11 @@ Kiev.event(:my_event, { some_array: [1, 2, 3] })
 
 # Log other data types (will be available under the `message` key)
 Kiev.event(:my_event, "hello world")
+
+# Log with given severity [debug, info, warn, error, fatal]
+Kiev.info(:my_event)
+Kiev.info(:my_event, { some_array: [1, 2, 3] })
+Kiev.info(:my_event, "hello world")
 ```
 
 However, `Kiev.logger` implements the Ruby `Logger` class, so all the other methods are available as well:
@@ -439,6 +444,28 @@ get "/" do
 end
 ```
 
+### log_level
+You can specify log level.
+
+```ruby
+Kiev.configure do |config|
+  # One of: 0, 1, 2, 3, 4 (DEBUG, INFO, WARN, ERROR, FATAL)
+  config.log_level = 0
+end
+```
+
+### disable_filter_for_log_levels
+You can specify for which log levels personal identifying information filter will NOT be applied.
+
+```ruby
+Kiev.configure do |config|
+  # [DEBUG, INFO, WARN, ERROR, FATAL]
+  config.disable_filter_for_log_levels = [0, 1, 2, 3, 4]
+end
+```
+
+**By default enabled for all suppported log levels.**
+
 ## nginx
 
 If you want to log 499 and 50x errors in nginx, which will not be captured by Ruby application, consider adding this to your nginx configuration:

data/gemfiles/que_0.12.3.gemfile

@@ -6,7 +6,7 @@ source "https://rubygems.org"
 gem "multi_json"
 gem "oj"
 
-gem "que", ">= 0.12.3"
+gem "que", "0.12.3"
 gem "pg"
 gem "sequel"
 

data/gemfiles/sidekiq_4.2.gemfile

@@ -11,5 +11,8 @@ gem "rspec", require: false
 gem "minitest-reporters", require: false
 
 gem "her"
+# We need to do it, since her gem doesn't lock upper boundry
+# https://github.com/remi/her/blob/master/her.gemspec#L26
+gem "faraday", "~> 1.9.3"
 
 gemspec path: "../"

data/lib/kiev/base.rb

@@ -13,21 +13,38 @@ require_relative "config"
 require_relative "util"
 require_relative "subrequest_helper"
 require_relative "hanami"
+require "forwardable"
+require "logger"
 
 module Kiev
   class << self
+    extend Forwardable
+
+    def_delegators :config,
+                   :logger,
+                   :filtered_params,
+                   :ignored_params,
+                   :log_level,
+                   :disable_filter_for_log_levels
+
     EMPTY_OBJ = {}.freeze
 
     def configure
       yield(Config.instance)
     end
 
-    def logger
-      Config.instance.logger
+    def config
+      Config.instance
+    end
+
+    def event(log_name, data = EMPTY_OBJ, severity = log_level)
+      logger.log(severity, logged_data(data), log_name)
     end
 
-    def event(event_name, data = EMPTY_OBJ)
-      logger.log(::Logger::Severity::INFO, data, event_name)
+    Config.instance.supported_log_levels.each_pair do |key, value|
+      define_method(key) do |log_name, data = EMPTY_OBJ|
+        event(log_name, data, value)
+      end
     end
 
     def []=(name, value)
@@ -51,5 +68,13 @@ module Kiev
     end
 
     alias_method :tracking_id, :request_id
+
+    private
+
+    def logged_data(data)
+      return data if disable_filter_for_log_levels.include?(log_level)
+
+      ParamFilter.filter(data, filtered_params, ignored_params)
+    end
   end
 end

data/lib/kiev/config.rb

@@ -75,6 +75,16 @@ module Kiev
       end
     end
 
+    SUPPORTED_LOG_LEVELS = {
+      debug: ::Logger::DEBUG,
+      info: ::Logger::INFO,
+      warn: ::Logger::WARN,
+      error: ::Logger::ERROR,
+      fatal: ::Logger::FATAL
+    }.freeze
+
+    private_constant :SUPPORTED_LOG_LEVELS
+
     attr_accessor :app,
                   :log_request_condition,
                   :log_request_error_condition,
@@ -89,10 +99,12 @@ module Kiev
 
     attr_reader :development_mode,
                 :logger,
+                :log_level,
                 :http_propagated_fields,
                 :jobs_propagated_fields,
                 :all_http_propagated_fields, # for internal use
-                :all_jobs_propagated_fields # for internal use
+                :all_jobs_propagated_fields, # for internal use
+                :disable_filter_for_log_levels
 
     def initialize
       @log_request_condition = DEFAULT_LOG_REQUEST_CONDITION
@@ -105,9 +117,10 @@ module Kiev
       @development_mode = false
       @ignored_rack_exceptions = DEFAULT_IGNORED_RACK_EXCEPTIONS.dup
       @logger = Kiev::Logger.new(STDOUT)
-      @log_level = nil
+      @log_level = default_log_level
       @persistent_log_fields = []
       @pre_rack_hook = DEFAULT_PRE_RACK_HOOK
+      @disable_filter_for_log_levels = []
       self.propagated_fields = {}
       update_logger_settings
     end
@@ -138,20 +151,32 @@ module Kiev
     end
 
     def log_level=(value)
+      raise ArgumentError, "Unsupported log level #{value}" unless supported_log_level?(value)
+
       @log_level = value
       update_logger_settings
     end
 
+    def disable_filter_for_log_levels=(log_levels)
+      raise ArgumentError, "Unsupported log levels" unless array_with_log_levels?(log_levels)
+
+      @disable_filter_for_log_levels = log_levels
+    end
+
     def development_mode=(value)
       @development_mode = value
       update_logger_settings
     end
 
+    def supported_log_levels
+      SUPPORTED_LOG_LEVELS
+    end
+
     private
 
     def update_logger_settings
       @logger.formatter = formatter
-      @logger.level = @log_level || default_log_level
+      @logger.level = @log_level
     end
 
     def formatter
@@ -161,5 +186,15 @@ module Kiev
     def default_log_level
       development_mode ? ::Logger::DEBUG : ::Logger::INFO
     end
+
+    def array_with_log_levels?(log_levels)
+      return false unless log_levels.is_a?(Array)
+
+      log_levels.all? { |level| supported_log_level?(level) }
+    end
+
+    def supported_log_level?(log_level)
+      supported_log_levels.value?(log_level)
+    end
   end
 end

data/lib/kiev/logger.rb

@@ -12,17 +12,19 @@ module Kiev
     extend Forwardable
     def_delegators(*([:@logger] + ::Logger.instance_methods(false)))
 
-    DEFAULT_EVENT_NAME = "log"
+    DEFAULT_LOG_NAME = "log"
+    DEFAULT_MESSAGE = "log"
     LOG_ERROR = "ERROR"
     ERROR_STATUS = 500
 
-    FORMATTER = proc do |severity, time, event_name, data|
+    FORMATTER = proc do |severity, time, log_name, data|
       entry =
         {
           application: Config.instance.app,
-          event: event_name || DEFAULT_EVENT_NAME,
+          log_name: log_name || DEFAULT_LOG_NAME,
           level: severity,
           timestamp: time.utc,
+          message: log_name || DEFAULT_MESSAGE,
           tracking_id: RequestStore.store[:tracking_id],
           request_id: RequestStore.store[:request_id],
           request_depth: RequestStore.store[:request_depth],
@@ -39,12 +41,12 @@ module Kiev
         entry[:jid] = RequestStore.store[:jid]
       end
 
-      if !RequestStore.store[:subrequest_count] && %i(request_finished job_finished).include?(event_name)
+      if !RequestStore.store[:subrequest_count] && %i(request_finished job_finished).include?(log_name)
         entry[:tree_leaf] = true
       end
 
       if RequestStore.store[:payload]
-        if %i(request_finished job_finished).include?(event_name)
+        if %i(request_finished job_finished).include?(log_name)
           entry.merge!(RequestStore.store[:payload])
         else
           Config.instance.persistent_log_fields.each do |field|
@@ -68,17 +70,17 @@ module Kiev
       JSON.logstash(entry)
     end
 
-    DEVELOPMENT_FORMATTER = proc do |severity, time, event_name, data|
+    DEVELOPMENT_FORMATTER = proc do |severity, time, log_name, data|
       entry = []
 
       entry << time.iso8601
-      entry << (event_name || severity).upcase
+      entry << (log_name || severity).upcase
 
       if data.is_a?(String)
         entry << "#{data}\n"
       end
 
-      if %i(request_finished job_finished).include?(event_name)
+      if %i(request_finished job_finished).include?(log_name)
         verb = RequestStore.store[:request_verb]
         path = RequestStore.store[:request_path]
         entry << "#{verb} #{path}" if verb && path

data/lib/kiev/param_filter.rb

@@ -1,12 +1,23 @@
 # frozen_string_literal: true
 
 module Kiev
-  module ParamFilter
+  class ParamFilter
     FILTERED = "[FILTERED]"
 
     def self.filter(params, filtered_params, ignored_params)
+      new(filtered_params, ignored_params).call(params)
+    end
+
+    def initialize(filtered_params, ignored_params)
+      @filtered_params = normalize(filtered_params)
+      @ignored_params = normalize(ignored_params)
+    end
+
+    def call(params)
+      return params unless filterable?(params)
+
       params.each_with_object({}) do |(key, value), acc|
-        next if ignored_params.include?(key)
+        next if ignored_params.include?(key.to_s)
 
         if defined?(ActionDispatch) && value.is_a?(ActionDispatch::Http::UploadedFile)
           value = {
@@ -17,14 +28,26 @@ module Kiev
         end
 
         acc[key] =
-          if filtered_params.include?(key) && !value.is_a?(Hash)
+          if filtered_params.include?(key.to_s) && !value.is_a?(Hash)
             FILTERED
           elsif value.is_a?(Hash)
-            filter(value, filtered_params, ignored_params)
+            call(value)
           else
             value
           end
       end
     end
+
+    private
+
+    attr_reader :filtered_params, :ignored_params
+
+    def filterable?(params)
+      params.respond_to?(:each_with_object)
+    end
+
+    def normalize(params)
+      Set.new(params.map(&:to_s))
+    end
   end
 end

data/lib/kiev/rack/request_logger.rb

@@ -85,8 +85,6 @@ module Kiev
             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],

data/lib/kiev/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kiev
-  VERSION = "4.5.0"
+  VERSION = "4.8.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kiev
 version: !ruby/object:Gem::Version
-  version: 4.5.0
+  version: 4.8.1
 platform: ruby
 authors:
 - Blacklane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-08 00:00:00.000000000 Z
+date: 2022-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oga
@@ -222,8 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Distributed logging to JSON integrated with various Ruby frameworks and tools