RTALogger 1.1.0 → 2.1.0

data/lib/RTALogger/version.rb

@@ -1,3 +1,3 @@
 module RTALogger
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.1.0'.freeze
 end

data/lib/log_factory_filter.rb

@@ -0,0 +1,33 @@
+require_relative 'log_filter_base'
+
+module RTALogger
+  # Log factory to get new instance of log filter
+  module LogFactory
+    def self.create_filter(type, config_json = '')
+      lib_file = @log_filters[type.to_sym]
+      raise "unregistered filter class: #{type.to_s}" if lib_file.nil? || lib_file.empty?
+      begin
+        load lib_file
+      rescue
+        raise "unable to load formatter class file: #{lib_file}"
+      end
+
+      filter_class_name = 'RTALogger::' + ('log_filter_' + type.to_s).split('_').map(&:capitalize).join
+      filter_class = Object.const_get(filter_class_name)
+      return nil unless filter_class
+      result = filter_class.new
+
+      return result if config_json.empty?
+      result.load_config(config_json) if result.present?
+      return result
+    end
+
+    def self.register_log_filter(type, class_file_name)
+      @log_filters[type.to_sym] = class_file_name
+    end
+
+    @log_filters = {:topic => 'log_filter_topic.rb',
+                    :context => 'log_filter_context.rb',
+                    :message => 'log_filter_message.rb'}
+  end
+end

data/lib/log_filter_base.rb

@@ -0,0 +1,39 @@
+module RTALogger
+  class LogFilterBase
+    def initialize
+      @title = self.class.to_s.split('::').last.underscore
+      @enable = true
+    end
+
+    attr_accessor :title
+    attr_accessor :enable
+    attr_accessor :default_regex
+
+    def match_conditions(log_record)
+      return true if !@enable
+      return log_record.present?
+    end
+
+    def load_config(config_json)
+      @title = config_json['title'] if config_json['title'].present?
+      @enable = config_json['enable'].nil? ? true : config_json['enable'].present?
+      @default_regex = config_json['default_regex'] if config_json['default_regex'].present?
+    end
+
+    def apply_run_time_config(config_json)
+      @enable = config_json['enable'].nil? ? true : config_json['enable'].present?
+      @default_regex = config_json['default_regex'] if config_json['default_regex'].present?
+    end
+
+    def to_builder
+      jb = Jbuilder.new do |json|
+        json.type self.class.to_s.split('::').last.underscore.sub('log_filter_', '')
+        json.title @title
+        json.enable @enable
+        json.default_regex @default_regex
+      end
+
+      jb
+    end
+  end
+end

data/lib/log_filter_context.rb

@@ -0,0 +1,13 @@
+require_relative 'log_filter_base'
+
+module RTALogger
+  class LogFilterContext < LogFilterBase
+    def match_conditions(log_record)
+      return true if !@enable
+      result = super
+      return result unless result
+
+      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.context_id.to_s)) : result
+    end
+  end
+end

data/lib/log_filter_message.rb

@@ -0,0 +1,13 @@
+require_relative 'log_filter_base'
+
+module RTALogger
+  class LogFilterMessage < LogFilterBase
+    def match_conditions(log_record)
+      return true if !@enable
+      result = super
+      return result unless result
+
+      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.full_message)) : result
+    end
+  end
+end

data/lib/log_filter_topic.rb

@@ -0,0 +1,13 @@
+require_relative 'log_filter_base'
+
+module RTALogger
+  class LogFilterTopic < LogFilterBase
+    def match_conditions(log_record)
+      return true if !@enable
+      result = super
+      return result unless result
+
+      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.topic_title)) : result
+    end
+  end
+end

data/lib/log_formatter_json.rb

@@ -1,10 +1,13 @@
 require 'jbuilder'
 require_relative 'log_formatter_base'
+require_relative 'severity_level'
 
 module RTALogger
   # json formatter which receive log_record and
   # returns it's data as json string
   class LogFormatterJson < LogFormatterBase
+    include SeverityLevel
+
     def format(log_record)
       return '' unless log_record
 
@@ -13,7 +16,7 @@ module RTALogger
         json.app_name log_record.app_name
         json.topic_title log_record.topic_title
         json.context_id log_record.context_id
-        json.severity log_record.severity
+        json.severity parse_severity_level_to_s(log_record.severity)
         json.message log_record.message.flatten.join(' ')
       end
 

data/lib/log_formatter_text.rb

@@ -1,17 +1,20 @@
 require_relative 'log_formatter_base'
+require_relative 'severity_level'
 
 module RTALogger
   # text formatter which receive log_record and
   # returns it's data as delimited text string
   class LogFormatterText < LogFormatterBase
+    include SeverityLevel
+
     def format(log_record)
       return '' unless log_record
 
       result = log_record.occurred_at.strftime('%F %H:%M:%S:%3N')
       result << @delimiter << log_record.app_name
       result << @delimiter << log_record.topic_title
-      result << @delimiter << log_record.context_id
-      result << @delimiter << log_record.severity
+      result << @delimiter << log_record.context_id.to_s
+      result << @delimiter << parse_severity_level_to_s(log_record.severity)
       result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
 
       result

data/lib/log_manager.rb

@@ -20,15 +20,14 @@ module RTALogger
 
     def initialize
       @enable = true
-      @name = 'default_log_manager'
+      @title = 'default_log_manager'
       @app_name = ENV.fetch('RTA_LOGGER_APP_NAME', 'unknown_app')
-      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', WARN)
+      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', INFO)
       @config_file_name = ''
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
-      @buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
-      @flush_size = @buffer_size * 20 / 100
-      @flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
+      self.buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
+      self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -42,19 +41,34 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    attr_reader :name
+    attr_reader :title
     attr_accessor :enable
     attr_accessor :app_name
     attr_reader :propagator
     attr_accessor :default_severity_level
-    attr_accessor :buffer_size
     attr_reader :flush_size
-    attr_accessor :flush_wait_time
     attr_reader :topics
     attr_reader :config_file_name
 
-    def config_use_json_file(file_name, manager_name = '')
-      config_json = load_config_from_json_file(file_name, manager_name)
+    def buffer_size
+      @buffer_size
+    end
+
+    def buffer_size=(size)
+      @buffer_size = size < 100 ? 100 : size
+      @flush_size = @buffer_size * 20 / 100
+    end
+
+    def flush_wait_time
+      @flush_wait_time
+    end
+
+    def flush_wait_time=(time_in_seconds)
+      @flush_wait_time = time_in_seconds < 10 ? 10 : time_in_seconds
+    end
+
+    def config_use_json_file(file_name, title = '')
+      config_json = load_config_from_json_file(file_name, title)
       @config_file_name = file_name if config_json
       apply_config(config_json)
     rescue StandardError => e
@@ -62,8 +76,8 @@ module RTALogger
       @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
 
-    def config_use_json_string(config_string, manager_name = '')
-      config_json = load_config_from_json_string(config_string, manager_name)
+    def config_use_json_string(config_string, title = '')
+      config_json = load_config_from_json_string(config_string, title)
       apply_config(config_json)
     rescue StandardError => e
       @propagator.drop_all_repositories
@@ -100,10 +114,22 @@ module RTALogger
       @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].severity_level = severity_level } }
     end
 
+    def topic_by_title(title)
+      result = nil
+      @topic_semaphore.synchronize do
+        @topics.keys.each do |topic_key|
+          result = @topics[topic_key.to_sym] if topic_key.to_s.casecmp(title).zero?
+          break if result
+        end
+      end
+
+      return result
+    end
+
     def to_builder
       @topic_semaphore.synchronize do
         jb = Jbuilder.new do |json|
-          json.name name
+          json.title title
           json.enable enable
           json.app_name app_name
           json.config_file_name config_file_name
@@ -112,7 +138,8 @@ module RTALogger
           json.flush_size flush_size
           json.flush_wait_time flush_wait_time
           json.repositories do
-            json.array! @propagator.repositories.collect { |repository| repository.to_builder.attributes! }
+            # json.array! @propagator.repositories.collect { |repository| repository.to_builder.attributes! }
+            json.array! @propagator.to_builder
           end
           json.topics do
             json.array! topics.keys.collect { |topic_key| @topics[topic_key].to_builder.attributes! }
@@ -127,33 +154,51 @@ module RTALogger
       to_builder.target!
     end
 
+    def apply_run_time_config(config_json)
+      return unless config_json
+      @enable = config_json['enable'] unless config_json['enable'].nil?
+      @default_severity_level = parse_severity_level_to_s(config_json['severity_level']) unless config_json['severity_level'].nil?
+      self.buffer_size = config_json['buffer_size'] unless config_json['buffer_size'].nil?
+      self.flush_wait_time = config_json['flush_wait_time'] unless config_json['flush_wait_time'].nil?
+      @propagator.apply_run_time_config(config_json)
+      apply_run_time_config_topics(config_json)
+    end
+
     private
 
-    def load_config_from_json_file(config_file_name, manager_name = '')
+    def apply_run_time_config_topics(config_json)
+      config_json['topics']&.each do |topic_config|
+        next if topic_config['title'].nil?
+        topic = topic_by_title(topic_config['title'])
+        topic.apply_run_time_config(topic_config) if topic.present?
+      end
+    end
+
+    def load_config_from_json_file(config_file_name, title = '')
       config_file = File.open config_file_name
       config_json = ::JSON.load(config_file)
-      config_json = extract_config(config_json, manager_name)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def load_config_from_json_string(config_string, manager_name = '')
+    def load_config_from_json_string(config_string, title = '')
       config_json = ::JSON.parse(config_string)
-      config_json = extract_config(config_json, manager_name)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def extract_config(json_data, manager_name = '')
+    def extract_config(json_data, title = '')
       config_json = json_data['rta_logger']
       raise 'RTALogger configuration not found!' unless config_json
       raise 'Log_Managers section does not exists json configuration' unless config_json['log_managers']
       raise 'No config manager defined in json configuration' unless config_json['log_managers'].count.positive?
-      manager_name = config_json['default_manager'] if manager_name.empty?
-      unless manager_name.to_s.strip.empty?
-        config_json = config_json['log_managers'].find { |item| item['manager_name'] == manager_name }
+      title = config_json['default_manager'] if title.empty?
+      unless title.to_s.strip.empty?
+        config_json = config_json['log_managers'].find { |item| item['title'] == title }
       end
       config_json ||= config_json['log_managers'][0]
       raise 'Unable to extract RTA Log Manager configuration!' unless config_json
-      @name = manager_name if config_json
+      @title = title if config_json
       config_json
     end
 
@@ -162,17 +207,12 @@ module RTALogger
       @enable = config_json['enable'].nil? ? true : config_json['enable']
       @app_name = config_json['app_name'] unless config_json['app_name'].empty?
       @default_severity_level = parse_severity_level_to_i(config_json['severity_level']) if config_json['severity_level']
-      @buffer_size = config_json['buffer_size'] if config_json['buffer_size']
-      @flush_wait_time = config_json['flush_wait_seconds'] if config_json['flush_wait_seconds']
-      @propagator.drop_all_repositories
-      apply_config_repos(config_json)
+      self.buffer_size = config_json['buffer_size'] if config_json['buffer_size']
+      self.flush_wait_time = config_json['flush_wait_seconds'] if config_json['flush_wait_seconds']
+      @propagator.load_repositories(config_json)
       apply_config_topics(config_json)
     end
 
-    def apply_config_repos(config_json)
-      config_json['repositories']&.each { |item| @propagator.load_log_repository(item) }
-    end
-
     def apply_config_topics(config_json)
       config_json['topics']&.each do |topic|
         next unless topic['title']
@@ -187,7 +227,7 @@ module RTALogger
       @flush_scheduler = Thread.new do
         loop do
           elapsed_seconds = ((DateTime.now - @last_flush_time) * 24 * 60 * 60).to_i
-          flush if elapsed_seconds > @flush_wait_time
+          flush if elapsed_seconds > flush_wait_time
           sleep(1)
           break if @exit_flush_scheduler
         end

data/lib/log_propagator.rb

@@ -6,7 +6,7 @@ module RTALogger
     def initialize
       @semaphore = Mutex.new
       @records = []
-      @repositories = []
+      @repositories = {}
     end
 
     attr_reader :repositories
@@ -16,31 +16,87 @@ module RTALogger
     end
 
     def add_log_repository(repository)
+      return if repository.nil? || repository.title.to_s.empty?
       return unless repository.is_a? RTALogger::LogRepository
-      @repositories.push(repository) unless @repositories.include?(repository)
+      @semaphore.synchronize { @repositories[repository.title.to_sym] = repository unless @repositories[repository.title.to_sym].present? }
     end
 
     def load_log_repository(config_json)
       type = config_json['type']
       return if type.to_s.strip.empty?
-      enable = config_json['enable'].nil? ? true : config_json['enable']
-      return unless enable
 
       repository = ::RTALogger::LogFactory.create_repository(type, config_json)
       add_log_repository(repository)
     end
 
+    def load_repositories(config_json)
+      return if config_json.nil?
+
+      @semaphore.synchronize do
+        @repositories.clear
+        config_json['repositories']&.each do |repository_config|
+          type = repository_config['type']
+          next if type.to_s.strip.empty?
+
+          repository = ::RTALogger::LogFactory.create_repository(type, repository_config)
+          @repositories[repository.title.to_sym] = repository unless @repositories[repository.title.to_sym].present?
+        end
+      end
+    end
+
     def drop_all_repositories
       @semaphore.synchronize { @repositories.clear }
     end
 
+    def repository_by_title(title)
+      result = nil
+      @semaphore.synchronize do
+        @repositories.keys.each do |repository_key|
+          result = @repositories[repository_key.to_sym] if repository_key.to_s.casecmp(title).zero?
+          break if result
+        end
+      end
+
+      return result
+    end
+
+    def apply_run_time_config(config_json)
+      return unless config_json
+      apply_run_time_config_repositories(config_json)
+    end
+
     def propagate
       @semaphore.synchronize do
-        @repositories.each do |repository|
-          repository.add_log_records(@records)
+        @repositories.keys.each do |repository_key|
+          @repositories[repository_key.to_sym].add_log_records(@records)
         end
         @records.clear
       end
     end
+
+    def to_builder
+      result = nil
+      @semaphore.synchronize do
+        result = @repositories&.keys.collect { |repository_key| @repositories[repository_key].to_builder.attributes! }
+      end
+
+      return result
+    end
+
+    private
+
+    def apply_run_time_config_repositories(config_json)
+      config_json['repositories']&.each do |repository_config|
+        next if repository_config['title'].nil?
+        repository = repository_by_title(repository_config['title'])
+        if repository.present?
+          repository.apply_run_time_config(repository_config)
+        else
+          repository = ::RTALogger::LogFactory.create_repository(repository_config['type'], config_json)
+          add_log_repository(repository)
+        end
+      end
+    end
+
   end
 end