RTALogger 1.1.1 → 2.1.1

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_manager.rb

@@ -20,14 +20,13 @@ 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
       self.buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
-      @flush_size = @buffer_size * 20 / 100
       self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
@@ -42,7 +41,7 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    attr_reader :name
+    attr_reader :title
     attr_accessor :enable
     attr_accessor :app_name
     attr_reader :propagator
@@ -57,6 +56,7 @@ module RTALogger
 
     def buffer_size=(size)
       @buffer_size = size < 100 ? 100 : size
+      @flush_size = @buffer_size * 20 / 100
     end
 
     def flush_wait_time
@@ -67,8 +67,8 @@ module RTALogger
       @flush_wait_time = time_in_seconds < 10 ? 10 : time_in_seconds
     end
 
-    def config_use_json_file(file_name, manager_name = '')
-      config_json = load_config_from_json_file(file_name, manager_name)
+    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
@@ -76,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
@@ -114,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
@@ -126,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! }
@@ -141,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
 
@@ -178,15 +209,10 @@ module RTALogger
       @default_severity_level = parse_severity_level_to_i(config_json['severity_level']) if config_json['severity_level']
       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.drop_all_repositories
-      apply_config_repos(config_json)
+      @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']

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

data/lib/log_record.rb

@@ -16,6 +16,10 @@ module RTALogger
     attr_reader :message
     attr_reader :occurred_at
 
+    def full_message
+      message.join(' ')
+    end
+
     def app_name
       @log_topic.log_manager.app_name
     end

data/lib/log_repository.rb

@@ -1,4 +1,5 @@
 require_relative 'string'
+require_relative 'log_factory_filter'
 
 module RTALogger
   # base log repository class
@@ -6,8 +7,10 @@ module RTALogger
     def initialize
       @semaphore = Mutex.new
       @log_records = []
+      @title = self.class.to_s.split('::').last.underscore
       @enable = true
       @formatter = RTALogger::LogFactory.log_formatter_default
+      @filters = {}
     end
 
     # @@sub_classes = {}
@@ -25,31 +28,41 @@ module RTALogger
     #   @@sub_classes[repository_name] = self
     # end
 
+    attr_accessor :title
     attr_accessor :enable
     attr_accessor :formatter
 
     def add_log_records(items)
       return 0 unless @enable
       @semaphore.synchronize do
-        items.each { |item| @log_records.push(item.dup) }
+        items.each do |item|
+          @log_records.push(item.dup) if filters_accept(item)
+        end
       end
+
       flush_and_clear
     end
 
     def load_config(config_json)
       @enable = config_json['enable'].nil? ? true : config_json['enable']
-
+      @title = config_json['title'].nil? ? self.class.to_s.split('::').last.underscore : config_json['title']
       formatter_config = config_json['formatter']
       if formatter_config && formatter_config['type']
         @formatter = LogFactory.create_formatter(formatter_config['type'], formatter_config)
       end
+
+      apply_config_filters(config_json)
     end
 
     def to_builder
       jb = Jbuilder.new do |json|
         json.type self.class.to_s.split('::').last.underscore.sub('log_repository_', '')
+        json.title @title
         json.enable enable
         json.formatter @formatter.to_builder.attributes!
+        json.filters do
+          json.array! @filters.keys.collect { |filter_key| @filters[filter_key].to_builder.attributes! }
+        end
       end
 
       jb
@@ -59,12 +72,63 @@ module RTALogger
       to_builder.target!
     end
 
+    def filter_by_title(title)
+      result = nil
+      @semaphore.synchronize do
+        @filters.keys.each do |filter_key|
+          result = @filters[filter_key.to_sym] if filter_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
+      @enable = config_json['enable'] unless config_json['enable'].nil?
+      apply_run_time_config_filters(config_json)
+    end
+
     protected
 
+    def apply_config_filters(config_json)
+      config_json['filters']&.each do |filter_config|
+        next if filter_config['type'].nil? || filter_config['title'].nil?
+        filter = LogFactory.create_filter(filter_config['type'], filter_config)
+        @filters[filter_config['title'].to_sym] = filter if filter.present?
+      end
+    end
+
+    def apply_run_time_config_filters(config_json)
+      return unless config_json
+
+      config_json['filters']&.each do |filter_config|
+        next if filter_config['title'].nil?
+        filter = filter_by_title(filter_config['title'])
+        if filter.present?
+          filter.apply_run_time_config(filter_config)
+        else
+          filter = LogFactory.create_filter(filter_config['type'], filter_config)
+          @semaphore.synchronize { @filters[filter_config['title'].to_sym] = filter if filter.present? }
+        end
+      end
+    end
+
     def flush_and_clear
       @semaphore.synchronize { @log_records.clear }
     end
 
+    def filters_accept(log_record)
+      result = true
+      @filters&.keys.each do |filter_key|
+        result = @filters[filter_key.to_sym]&.match_conditions(log_record)
+        break unless result
+      end
+
+      return result
+    end
+
     attr_reader :log_records
     attr_reader :semaphore
   end