RTALogger 1.1.1 → 2.1.1

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,26 +5,43 @@
     "log_managers":
     [
       {
-        "manager_name": "develop",
+        "title": "develop",
         "enable": true,
         "app_name": "TestApp",
-        "severity_level": "debug",
+        "severity_level": "trace",
         "buffer_size": 100,
         "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",
@@ -35,7 +52,8 @@
             }
           },
           {
-            "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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.1.1
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-26 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