RTALogger 2.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af9ac8a5e34e79ce013e0447fe227f1bc0d86b6a4c7d3822c9d09775709722aa
-  data.tar.gz: d395ec41a747196bbac4d9ce1a8efe68237d294bce287e66b80dde78bea8455d
+  metadata.gz: 6e3e0080b58239ca52e5c80dceab5dfacd7202d25dbef441695c8f3fef56ad70
+  data.tar.gz: 40f0c55f14e92a4207b932e6090c14db5b6177fbc10e0f5c642ceb65c2c5e2b3
 SHA512:
-  metadata.gz: 7332a7ac1b188d309646d117b9e529eeefbac12ced002596e040c10e3f83e92e0ace272851a0b75cc673798dfd9d9d0fc5a7ebd5c56ca6df39bfc791f3e261f6
-  data.tar.gz: 959c6efbc7bb3be254954798b544b7a6505d57550f8b5b3c55b516a5455d1cfc2acb5c012fb4de737cb9dc5d1cca6a3d6b5d21721888d5574f0361f9c901e95f
+  metadata.gz: 50e947dbcfbbda443696f07bc804b982a7310407580d429011f1932cdb304707eb303346445edb98c4cd0f140ca8ba46a4d84f5752f9017db4c64e9871b3886c
+  data.tar.gz: d9414ec73afcede5e67987fe83de43afc3ce5312db5b7089358bd4c1162004fbdaab2dbe48c02e8191d82a9a64bf2c69f5501ced9288aec49fee42bfc7f71b24

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    RTALogger (2.0.1)
+    RTALogger (2.2.0)
       fluent-logger (~> 0.9)
       jbuilder (~> 2.10)
 

data/README.md

@@ -94,7 +94,7 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
         "app_name": "TestApp",
         "severity_level": "trace",
         "buffer_size": 100,
-        "flush_wait_seconds": 10,
+        "flush_wait_seconds": 5,
         "repositories":
         [
           {
@@ -104,8 +104,24 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
             "formatter":
             {
               "type": "text",
-              "delimiter": "|"
-            }
+              "delimiter": "|",
+              "colorize": true
+            },
+            "filters":
+            [
+              {
+                "type": "topic",
+                "title": "topic_filter_1",
+                "enable": true,
+                "default_regex" : "^test$"
+              },
+              {
+                "type": "message",
+                "title": "message_filter_1",
+                "enable": false,
+                "default_regex" : "error"
+              }
+            ]
           },
           {
             "type": "file",
@@ -121,8 +137,8 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
             }
           },
           {
-            "enable": true,
-            "title": "console_repo_1",
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",
@@ -191,7 +207,7 @@ the result will be:
         "app_name": "TestApp",
         "severity_level": "trace",
         "buffer_size": 100,
-        "flush_wait_seconds": 10,
+        "flush_wait_seconds": 5,
         "repositories":
         [
           {
@@ -201,8 +217,24 @@ the result will be:
             "formatter":
             {
               "type": "text",
-              "delimiter": "|"
-            }
+              "delimiter": "|",
+              "colorize": true
+            },
+            "filters":
+            [
+              {
+                "type": "topic",
+                "title": "topic_filter_1",
+                "enable": true,
+                "default_regex" : "^test$"
+              },
+              {
+                "type": "message",
+                "title": "message_filter_1",
+                "enable": false,
+                "default_regex" : "error"
+              }
+            ]
           },
           {
             "type": "file",
@@ -218,8 +250,8 @@ the result will be:
             }
           },
           {
-            "enable": true,
-            "title": "console_repo_1",
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",
@@ -261,7 +293,7 @@ the result will be:
       - buffer_size: Minimune possible value for this attribute is 100 and defines memory buffer size (number of buffered log objects) to 
         decread api consumers wait time. when the buffer is full the flush operation will
         save buffered logs to log repositoies.
-      - flush_wait_seconds: Minimum possible value for this attribure is 10 seconds and defines time in soconds which log managers wait to flush buffered log records
+      - flush_wait_seconds: Minimum possible value for this attribure is 5 seconds and defines time in soconds which log managers wait to flush buffered log records
         to log repository.
       - repositories: Array of log repositories. It is possible to define multiple log repositories to
         store log data. there are variaty of log repositories and it is possible to
@@ -275,6 +307,8 @@ the result will be:
              - "foramtter" is the text, json or any custome defined types as LogRecord formatter
                 - "type": ["text"/"json"] type of formatter
                 - "delimiter": [any text delimiter you need.(as an instance pipe line "|")]
+                - "colorize": [true/false] default value of this attribute is false. 
+                   if you need to colorize your out put format on standard output set this attribute to true.
                 if formatter not defined then the json formatter will be used
           2- file: Store log data in a file.
              - "type": "console"
@@ -302,13 +336,30 @@ the result will be:
                 - "type": ["text"/"json"] type of formatter
                 - "delimiter": [any text delimiter you need.(as an instance pipe line "|")]
                 if formatter not defined then the json formatter will be used
+          New Features: 
+             * In RTALogger version 2.1.0 and above defineing filters is possible for each repository.
+             * Repositories filtes could restrict the amount of data stored by specific repository.
+             * Also you can add new repositories and filters at run time.
+             * filters configuration: It's possible to apply multiple filters on a repository. When repository will 
+               flush a log_record only if the record pass all filter conditions.
+             * There are variaty of filter types, including:
+               'topic' which apply a regular expresion on log_record.topic_title to pass filtering condition.
+               'context' which apply a regular expresion on log_record.context_id to pass filtering condition.
+               'message' which apply a regular expression on log_record.full_message to pass filtering condition.
+             * Each filter has following attributes to counfigure:
+               "type": ["topic"/"context"/"message" or any customized filter] described in previous lines.
+               "title": "filte_title" a unique title to make filter run time configuration
+               "enable": [true/false] this will enable or disable filtering opration of current filter.
+               "default_regex": "valid regual expression" to compare with corresponding attribute.
+             * It's possible to implement customize filter classes and integerate with RTALogger filter factory. 
+             * In RTALogger version 2.2.0 colorize out put format is availabel.
         - topics: This is an optional item. When you need to customize a specific topic severity level or
                   enable value, you can define the settings here.
           - title: The topic title to customize. (mandatoy).
           - severity_level: Defines which level of log data will be stored in log repositories.
           - enable: [true/false] to enable or disable logging process of the topic.
 ```
-###Some useful features
+##Some useful features
 ```ruby
     # change log manager app name at run time
     log_manager.app_name = 'myTestApp'
@@ -341,17 +392,19 @@ the result will be:
     # log_manager.enable
     # log_manager.default_severity_level    
     # log_manager.buffer_size (minimum is 100)
-    # log_manager.flush_wait_time (minimum 15 second)
+    # log_manager.flush_wait_time (minimum 5 second)
     # repository.enable
     # topic.enable
     # topic.severity_level
     # Other attributes could only change via config file via manager config_use_json_file 
+    # In RTALogger version 2.1.0 and above, it is possible to add new repositories or repository filters at run time
+    # using log_manager.apply_run_time_config method. 
     log_manager.apply_run_time_config(config_json) 
 ```
 ### Implement and Expand
-#### Implement new log repository
+#### Implement new customized log repository
   It is possible to implement new log repositories. There will be fue rules to implement and
-  integrate new customized log repository with RTALogger LogManager.
+  integrate new customized log repository with RTALogger LogManager factory.
   
   1- Define you class inside RTALogger module.
   
@@ -396,6 +449,91 @@ module RTALogger
 end
 ```
 
+#### Implement new customized log repository filter
+  It is possible to implement new log repository filter. There will be fue rules to implement and
+  integrate new customized log repository filter with RTALogger LogManager factory.
+  
+  1- Define you class inside RTALogger module.
+  
+  2- The class should be inherited from 'RTALogger::LogFilterBase'.
+  
+  3- Also appropriate naming convention is necessary. 
+     As an example if you are implementing a Console Repo, your class name should be LogFilterTopic and 
+     your source code should be placed in a ruby file and name it log_filter_topic.rb
+  
+  4- After implementing your own log filter, you should register the class at run-time using the following syntax:
+  ```ruby
+  RTALogger::LogFactory.register_log_filter :topic, 'log_filter_topic.rb'
+  ```
+  Another example: LogFilterMyCustomizedFilter
+
+  ```ruby
+  RTALogger::LogFactory.register_log_filter :my_customized_filter, 'log_repository_my_customized_filter.rb'
+  ```
+  Here is 'LogRepositoryTopic' implementation:
+  ```ruby
+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
+```
+#### Implement new customized log formatter
+
+  It is possible to implement new log formatter. There will be fue rules to implement and
+  integrate new customized log formatter with RTALogger LogManager factory.
+  
+  1- Define you class inside RTALogger module.
+  
+  2- The class should be inherited from 'RTALogger::LogFormatter'.
+  
+  3- Also appropriate naming convention is necessary. 
+     As an example if you are implementing a Text formatter, your class name should be LogFormatterText and 
+     your source code should be placed in a ruby file and name it log_formatter_text.rb
+  
+  4- After implementing your own log formatter, you should register the class at run-time using the following syntax:
+  ```ruby
+  RTALogger::LogFactory.register_log_formatter :text, 'log_formatter_text.rb'
+  ```
+  Another example: LogFormatterMyCustomizedFormatter
+
+  ```ruby
+  RTALogger::LogFactory.register_log_formatter :my_customized_formatter, 'log_formatter_my_customized_formatter.rb'
+  ```
+  Here is 'LogFormatterText' implementation:
+  ```ruby
+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.to_s
+      result << @delimiter << parse_severity_level_to_s(log_record.severity)
+      result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
+
+      result
+    end
+  end
+end
+```
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/BBahrainy/RTALogger.

data/lib/RTALogger/version.rb

@@ -1,3 +1,3 @@
 module RTALogger
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.2.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_base.rb

@@ -1,16 +1,22 @@
 require 'jbuilder'
 require_relative 'string'
+require_relative 'severity_level'
 
 module RTALogger
   class LogFormatterBase
+    include SeverityLevel
+
     def initialize
       @delimiter = '|'
+      @colorize = false
     end
 
     attr_accessor :delimiter
+    attr_accessor :colorize
 
     def load_config(config_json)
       @delimiter = config_json['delimiter'].nil? ? true : config_json['delimiter']
+      @colorize = config_json['colorize'].nil? ? false : config_json['colorize']
     end
 
     def format(log_record)
@@ -20,7 +26,8 @@ module RTALogger
     def to_builder
       jb = Jbuilder.new do |json|
         json.type self.class.to_s.split('::').last.underscore.sub('log_formatter_', '')
-        json.delimiter delimiter
+        json.delimiter @delimiter
+        json.colorize @colorize
       end
 
       jb
@@ -29,5 +36,39 @@ module RTALogger
     def reveal_config
       to_builder.target!
     end
+
+    def apply_run_time_config(config_json)
+      @delimiter = config_json['delimiter'] unless config_json['delimiter'].nil?
+      @colorize = config_json['colorize'] unless config_json['colorize'].nil?
+    end
+
+    protected
+
+    def severity_text(severity)
+      text = parse_severity_level_to_s(severity)
+      text = severity_colorized_text(severity, text) if @colorize
+      return text
+    end
+
+    def severity_colorized_text(severity, text)
+      case severity
+      when 0
+        text.trace_color
+      when 1
+        text.debug_color
+      when 2
+        text
+      when 3
+        text.warning_color
+      when 4
+        text.error_color
+      when 5
+        text.fatal_color
+      when 6
+        text.unknown_colorj
+      else
+        text
+      end
+    end
   end
 end

data/lib/log_formatter_json.rb

@@ -1,12 +1,11 @@
 require 'jbuilder'
 require_relative 'log_formatter_base'
-require_relative 'severity_level'
+require_relative 'string'
 
 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
@@ -20,7 +19,21 @@ module RTALogger
         json.message log_record.message.flatten.join(' ')
       end
 
-      jb.target!
+      result = jb.target!
+      result = colorize_json(result) if @colorize
+
+      return result
+    end
+
+    protected
+
+    def colorize_json(json_text)
+      json_text.gsub(/"severity":"TRACE"/i, '"severity":"TRACE"'.trace_color)
+               .gsub(/"severity":"DEBUG"/i, '"severity":"DEBUG"'.debug_color)
+               .gsub(/"severity":"WARN"/i, '"severity":"WARN"'.warning_color)
+               .gsub(/"severity":"ERROR"/i, '"severity":"ERROR"'.error_color)
+               .gsub(/"severity":"FATAL"/i, '"severity":"FATAL"'.fatal_color)
+               .gsub(/"severity":"UNKNOWN"/i, '"severity":"UNKNOWN"'.unknown_color)
     end
   end
 end

data/lib/log_formatter_text.rb

@@ -1,12 +1,9 @@
 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
 
@@ -14,7 +11,7 @@ module RTALogger
       result << @delimiter << log_record.app_name
       result << @delimiter << log_record.topic_title
       result << @delimiter << log_record.context_id.to_s
-      result << @delimiter << parse_severity_level_to_s(log_record.severity)
+      result << @delimiter << severity_text(log_record.severity)
       result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
 
       result

data/lib/log_manager.rb

@@ -27,7 +27,7 @@ module RTALogger
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
       self.buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
-      self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
+      self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 5)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -64,7 +64,7 @@ module RTALogger
     end
 
     def flush_wait_time=(time_in_seconds)
-      @flush_wait_time = time_in_seconds < 10 ? 10 : time_in_seconds
+      @flush_wait_time = time_in_seconds < 5 ? 5 : time_in_seconds
     end
 
     def config_use_json_file(file_name, title = '')
@@ -76,7 +76,7 @@ module RTALogger
       @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
 
-    def config_use_json_string(config_string,  title = '')
+    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
@@ -138,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! }
@@ -156,22 +157,23 @@ module RTALogger
     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_i(config_json['severity_level']) unless config_json['severity_level'].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)
-
-      if config_json['topics']
-        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
-        end
-      end
+      apply_run_time_config_topics(config_json)
     end
 
     private
 
+    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)
@@ -207,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,20 +16,34 @@ 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
@@ -48,23 +62,41 @@ module RTALogger
 
     def apply_run_time_config(config_json)
       return unless config_json
+      apply_run_time_config_repositories(config_json)
+    end
 
-      if config_json['repositories']
-        config_json['repositories'].each do |repository_config|
-          next if repository_config['title'].nil?
-          repository = repository_by_title(repository_config['title'])
-          repository.apply_run_time_config(repository_config) if repository
+    def propagate
+      @semaphore.synchronize do
+        @repositories.keys.each do |repository_key|
+          @repositories[repository_key.to_sym].add_log_records(@records)
         end
+        @records.clear
       end
     end
 
-    def propagate
+    def to_builder
+      result = nil
       @semaphore.synchronize do
-        @repositories.each do |repository|
-          repository.add_log_records(@records)
+        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'], repository_config)
+          add_log_repository(repository)
         end
-        @records.clear
       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
@@ -9,6 +10,7 @@ module RTALogger
       @title = self.class.to_s.split('::').last.underscore
       @enable = true
       @formatter = RTALogger::LogFactory.log_formatter_default
+      @filters = {}
     end
 
     # @@sub_classes = {}
@@ -33,8 +35,11 @@ module RTALogger
     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
 
@@ -42,16 +47,21 @@ module RTALogger
       @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
+
+      @formatter = LogFactory.create_formatter(formatter_config['type'], formatter_config) if formatter_config && formatter_config['type']
+
+      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
@@ -61,17 +71,64 @@ module RTALogger
       to_builder.target!
     end
 
-    def appy_run_time_config(config_json)
+    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?
+      @formatter.apply_run_time_config(config_json)
+      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

data/lib/log_repository_console.rb

@@ -17,7 +17,7 @@ module RTALogger
     protected
 
     def flush_and_clear
-      semaphore.synchronize do
+      @semaphore.synchronize do
         @log_records.each { |log_record| puts @formatter.format(log_record) }
       end
       super

data/lib/log_repository_file.rb

@@ -31,8 +31,15 @@ module RTALogger
 
       json
     end
+
     # register :file
 
+    def apply_run_time_config(config_json)
+      super config_json
+
+      @formatter.colorize = false
+    end
+
     protected
 
     def create_ruby_logger(file_path, period, shift_size)
@@ -45,7 +52,7 @@ module RTALogger
     end
 
     def flush_and_clear
-      semaphore.synchronize do
+      @semaphore.synchronize do
         @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }
       end
       super

data/lib/log_repository_fluentd.rb

@@ -7,43 +7,87 @@ module RTALogger
       super()
       @host = host
       @port = port
-      @fluent_logger = create_fluentd_logger(host, port, tls_options)
+      @tls_options = tls_options
+      @fluent_logger = nil
     end
 
     def load_config(config_json)
       super
 
-      host = config_json['host'].to_s
-      port = config_json['port'].to_s
-      tls_options = config_json['tls_options']
+      @host = config_json['host'].to_s
+      @port = config_json['port'].to_i
+      @tls_options = config_json['tls_options']
 
-      @fluent_logger = create_fluentd_logger(host, port, tls_options)
+      @semaphore.synchronize { @fluent_logger = nil }
+    end
+
+    def host=(host)
+      if @host != host
+        @host = host ? host : 'localhost'
+        @semaphore.synchronize { @fluent_logger = nil }
+      end
+    end
+
+    def host
+      @host
+    end
+
+    def port=(port)
+      if @port != port
+        @port = port ? port : 24224
+        @semaphore.synchronize { @fluent_logger = nil }
+      end
+    end
+
+    def port
+      @port
     end
 
     def to_builder
       json = super
-      json.enable enable
+      json.enable @enable
       json.host @host
       json.port @port
+      json.tls_options @tls_options
 
       json
     end
+
     # register :fluentd
 
+    def apply_run_time_config(config_json)
+      super config_json
+
+      @host = config_json['host'] unless config_json['host'].nil?
+      @port = config_json['port'] unless config_json['port'].nil?
+      @tls_options = config_json['tls_options'] unless config_json['tls_options'].nil?
+      @semaphore.synchronize { @fluent_logger = nil }
+
+      @formatter.colorize = false
+    end
+
     protected
 
     def create_fluentd_logger(host, port, tls_options)
+      return nil unless @enable
+
       unless tls_options
         fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :use_nonblock => true, :wait_writeable => false)
       else
-        fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :tls_options => tls_options, :use_nonblock => true, :wait_writeable => false)
+        fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host,
+                                                           :port => port,
+                                                           :tls_options => tls_options,
+                                                           :use_nonblock => true,
+                                                           :wait_writeable => false)
       end
 
       fluent_logger
     end
 
     def flush_and_clear
-      semaphore.synchronize do
+      @semaphore.synchronize do
+        @fluent_logger = create_fluentd_logger(@host, @port, @tls_options) unless @fluent_logger.present?
+
         @log_records.each do |log_record|
           fluent_tag = log_record.app_name + '.' + log_record.topic_title
           log_json_string = @formatter.format(log_record)
@@ -52,6 +96,7 @@ module RTALogger
           @fluent_logger.post(fluent_tag, log_json)
         end
       end
+
       super
     end
   end

data/lib/log_topic.rb

@@ -59,7 +59,7 @@ module RTALogger
       jb
     end
 
-    def appy_run_time_config(config_json)
+    def apply_run_time_config(config_json)
       return unless config_json
       @enable = config_json['enable'] unless config_json['enable'].nil?
       @severity_level = parse_severity_level_to_i(config_json['severity_level']) unless config_json['severity_level'].nil?

data/lib/rta_logger_config.json

@@ -10,7 +10,7 @@
         "app_name": "TestApp",
         "severity_level": "trace",
         "buffer_size": 100,
-        "flush_wait_seconds": 10,
+        "flush_wait_seconds": 5,
         "repositories":
         [
           {
@@ -20,8 +20,24 @@
             "formatter":
             {
               "type": "text",
-              "delimiter": "|"
-            }
+              "delimiter": "|",
+              "colorize": true
+            },
+            "filters":
+            [
+              {
+                "type": "topic",
+                "title": "topic_filter_1",
+                "enable": false,
+                "default_regex" : "^test$"
+              },
+              {
+                "type": "message",
+                "title": "message_filter_1",
+                "enable": false,
+                "default_regex" : "error"
+              }
+            ]
           },
           {
             "type": "file",
@@ -37,8 +53,8 @@
             }
           },
           {
-            "enable": true,
-            "title": "console_repo_1",
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",

data/lib/sample.rb

@@ -1,5 +1,14 @@
 require_relative 'log_factory_manager'
 require_relative 'log_factory_repository'
+# require_relative 'string'
+
+# puts 'trace'.gray
+# puts 'debug'.green
+# puts 'info'
+# puts 'warning'.brown
+# puts 'error'.red
+# puts 'fatal'.bg_red
+# puts 'unknown'.bg_cyan
 
 controller_name = 'test_controller'
 userID = 5
@@ -39,7 +48,7 @@ topic.unknown(userID, 'Controller Name=', controller_name, 'unknown')
 test_topic.error(userID, 'test_topic', 'error')
 test_topic.fatal(userID, 'test_topic', 'fatal')
 
-puts log_manager.reveal_config
+# puts log_manager.reveal_config
 
 # update specific topic log level if necessary
 # log_manager.update_topic_level(controller_name, RTALogger::SeverityLevel::INFO)

data/lib/string.rb

@@ -1,9 +1,40 @@
 class String
   def underscore
     self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
         tr("-", "_").
         downcase
   end
+
+  def black;          "\e[30m#{self}\e[0m" end
+  def red;            "\e[31m#{self}\e[0m" end
+  def green;          "\e[32m#{self}\e[0m" end
+  def brown;          "\e[33m#{self}\e[0m" end
+  def blue;           "\e[34m#{self}\e[0m" end
+  def magenta;        "\e[35m#{self}\e[0m" end
+  def cyan;           "\e[36m#{self}\e[0m" end
+  def gray;           "\e[37m#{self}\e[0m" end
+
+  def bg_black;       "\e[40m#{self}\e[0m" end
+  def bg_red;         "\e[41m#{self}\e[0m" end
+  def bg_green;       "\e[42m#{self}\e[0m" end
+  def bg_brown;       "\e[43m#{self}\e[0m" end
+  def bg_blue;        "\e[44m#{self}\e[0m" end
+  def bg_magenta;     "\e[45m#{self}\e[0m" end
+  def bg_cyan;        "\e[46m#{self}\e[0m" end
+  def bg_gray;        "\e[47m#{self}\e[0m" end
+
+  def bold;           "\e[1m#{self}\e[22m" end
+  def italic;         "\e[3m#{self}\e[23m" end
+  def underline;      "\e[4m#{self}\e[24m" end
+  def blink;          "\e[5m#{self}\e[25m" end
+  def reverse_color;  "\e[7m#{self}\e[27m" end
+
+  def trace_color; self.gray end
+  def debug_color; self.green end
+  def warning_color; self.brown end
+  def error_color; self.red end
+  def fatal_color; self.bg_red end
+  def unknown_color; self.bg_cyan end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-27 00:00:00.000000000 Z
+date: 2020-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger
@@ -68,12 +68,17 @@ files:
 - bin/setup
 - lib/RTALogger.rb
 - lib/RTALogger/version.rb
+- lib/log_factory_filter.rb
 - lib/log_factory_log_formatter.rb
 - lib/log_factory_manager.rb
 - lib/log_factory_propagator.rb
 - lib/log_factory_record.rb
 - lib/log_factory_repository.rb
 - lib/log_factory_topic.rb
+- lib/log_filter_base.rb
+- lib/log_filter_context.rb
+- lib/log_filter_message.rb
+- lib/log_filter_topic.rb
 - lib/log_formatter_base.rb
 - lib/log_formatter_json.rb
 - lib/log_formatter_text.rb