RTALogger 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8fb5a3e4e0c67b6e485cf932ab274fc5a55539fb6432e76e119c0877d786c23
-  data.tar.gz: 57c69c4601f00d24c395fd42b8a75fe74020a5f9b5222b14e38fe9c673134c97
+  metadata.gz: c31a37c1f8f9ce88c8fae11d7df9fe88d397e9e21da9c8b13ddce48fe5e216c5
+  data.tar.gz: 920e2000e9cf216dea8251dd6e6b5b2e3e2c114533e7459cd698eb2131c69c65
 SHA512:
-  metadata.gz: 22b65c1867090cadd8aaff4f735ef401be30fe890e3164b7a45b5df40979ee0d5439d5c2fae66273c929e4c821abaa928b208b2e7c6ad535908be48b2923bea2
-  data.tar.gz: 191367dfa21447a54f6ad218ed0f66d0615297b126e6a9aeda446c82900f05fbd457fbe0f200d860885be4f2760dd04a62e008634bc525c2e8554d5784883fc5
+  metadata.gz: 626deeb001694ef40e87743bb61742f1db0cbeeb46125f1f7b3185a52d33494d811439c3bc9d669c15e60563c9dc71d305159d3c801c06cdfcce82c4450970d0
+  data.tar.gz: 2a3a39efce340c0e0e204ebf6390d17283f6804b3846b3b086e849c25d92e9aec9994beb2a06ab6c81cf10a9abc8af0ded19d37317adbbe5abe16c1744a43aff

data/Gemfile.lock

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

data/README.md

@@ -105,7 +105,22 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
             {
               "type": "text",
               "delimiter": "|"
-            }
+            },
+            "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 +136,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",
@@ -202,7 +217,22 @@ the result will be:
             {
               "type": "text",
               "delimiter": "|"
-            }
+            },
+            "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 +248,8 @@ the result will be:
             }
           },
           {
-            "enable": true,
-            "title": "console_repo_1",
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",
@@ -302,6 +332,22 @@ 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. 
         - 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).
@@ -346,12 +392,14 @@ the result will be:
     # 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 +444,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.2'.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_manager.rb

@@ -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'], config_json)
+          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
 
@@ -45,6 +50,8 @@ module RTALogger
       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
@@ -52,6 +59,9 @@ module RTALogger
         json.type self.class.to_s.split('::').last.underscore.sub('log_repository_', '')
         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,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

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,13 @@ module RTALogger
 
       json
     end
+
     # register :file
 
+    def apply_run_time_config(config_json)
+      super config_json
+    end
+
     protected
 
     def create_ruby_logger(file_path, period, shift_size)
@@ -45,7 +50,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,85 @@ 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 }
+    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 +94,7 @@ module RTALogger
           @fluent_logger.post(fluent_tag, log_json)
         end
       end
+
       super
     end
   end

data/lib/rta_logger_config.json

@@ -21,7 +21,22 @@
             {
               "type": "text",
               "delimiter": "|"
-            }
+            },
+            "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",
@@ -37,8 +52,8 @@
             }
           },
           {
-            "enable": true,
-            "title": "console_repo_1",
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",

data/lib/sample.rb

@@ -39,7 +39,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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.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-28 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