RTALogger 1.1.0 → 2.1.0

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,24 +28,30 @@ 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
@@ -50,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
@@ -59,12 +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/log_topic.rb

@@ -21,6 +21,10 @@ module RTALogger
     attr_reader :title
     attr_accessor :severity_level
 
+    def trace(context_id, *message)
+      add(context_id, TRACE, message) if @severity_level.to_i <= TRACE.to_i
+    end
+
     def debug(context_id, *message)
       add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
     end
@@ -54,6 +58,13 @@ module RTALogger
 
       jb
     end
+
+    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?
+    end
+
     private
 
     def add(context_id, severity, *message)

data/lib/rta_logger_config.json

@@ -5,37 +5,55 @@
     "log_managers":
     [
       {
-        "manager_name": "develop",
+        "title": "develop",
         "enable": true,
         "app_name": "TestApp",
-        "severity_level": "debug",
+        "severity_level": "trace",
         "buffer_size": 100,
-        "flush_wait_seconds": 15,
+        "flush_wait_seconds": 10,
         "repositories":
         [
           {
-            "enable": true,
             "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
             "formatter":
             {
               "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"
+              }
+            ]
           },
           {
-            "enable": true,
             "type": "file",
+            "title": "file_repo_1",
+            "enable": true,
             "file_path": "log.txt",
             "roll_period": "daily",
             "roll_size": "1048576",
             "formatter":
             {
-              "type": "text",
+              "type": "json",
               "delimiter": "|"
             }
           },
           {
-            "enable": true,
+            "enable": false,
+            "title": "fluentd_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",

data/lib/sample.rb

@@ -28,6 +28,7 @@ test_topic = log_manager.add_topic('test')
 # test_topic.enable = false
 
 # add log information to log topic
+topic.trace(userID, 'Controller Name=', controller_name, 'trace')
 topic.debug(userID, 'Controller Name=', controller_name, 'debug')
 topic.info(userID, 'Controller Name=', controller_name, 'information')
 topic.warning(userID, 'Controller Name=', controller_name, 'warning')
@@ -38,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)

data/lib/severity_level.rb

@@ -1,60 +1,68 @@
 module RTALogger
   # Logging severity.
   module SeverityLevel
+    # all information that helps us to trace the processing of an incoming request through our application
+    TRACE = 0
     # Low-level information, mostly for developers.
-    DEBUG = 0
+    DEBUG = 1
     # Generic (useful) information about system operation.
-    INFO = 1
+    INFO = 2
     # A warning.
-    WARN = 2
+    WARN = 3
     # A handleable error condition.
-    ERROR = 3
+    ERROR = 4
     # An un-handleable error that results in a program crash.
-    FATAL = 4
+    FATAL = 5
     # An unknown message that should always be logged.
-    UNKNOWN = 5
+    UNKNOWN = 6
 
 
     def parse_severity_level_to_i(severity_level)
       return severity_level if severity_level.is_a? ::Integer
 
       case severity_level.upcase
-      when 'DEBUG'
+      when 'TRACE'
         0
-      when 'INFO'
+      when 'DEBUG'
         1
+      when 'INFO'
+        2
       when 'INFORMATIONّٔ'
-        1
-      when 'WARN'
         2
+      when 'WARN'
+        3
       when 'WARNING'
-        2
+        5
       when 'ERROR'
-        3
-      when 'FATAL'
         4
-      when 'UNKNOWN'
+      when 'FATAL'
         5
+      when 'UNKNOWN'
+        6
+      else
+        2
       end
-    end
+  end
 
-    def parse_severity_level_to_s(severity_level)
-      return severity_level if severity_level.is_a? ::String
+  def parse_severity_level_to_s(severity_level)
+    return severity_level if severity_level.is_a? ::String
 
-      case severity_level.to_i
-      when 0
-        'DEBUG'
-      when 1
-        'INFO'
-      when 2
-        'WARN'
-      when 3
-        'ERROR'
-      when 4
-        'FATAL'
-      when 5
-        'UNKNOWN'
-      end
+    case severity_level.to_i
+    when 0
+      'TRACE'
+    when 1
+      'DEBUG'
+    when 2
+      'INFO'
+    when 3
+      'WARN'
+    when 4
+      'ERROR'
+    when 5
+      'FATAL'
+    when 6
+      'UNKNOWN'
     end
   end
 end
+end