RTALogger 2.1.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 344cc6430343748963541c7f025549d8ee80007f8abc30fa6218b8924fe73755
-  data.tar.gz: 4c84b47e1f0a6d9007c1d0df5dc210955e3a0c525851a2edd46be8732b4e8d57
+  metadata.gz: ed82424b9451e92cb8424657eff8192e25e6bcff6aa66eed5e23867dcbe9386a
+  data.tar.gz: 309892ff41c57d310929b27287c0c024406de2bef493ecbd7e25ac04608be14a
 SHA512:
-  metadata.gz: 0a8e5f960166d6dd6ffc5627d61eedcc4bd0a3e15dcbc9dc2bcc4d8d6da20810ddc05a302931001165e28eee7e6db1c4513cc352b8425091f8a1271ecd05cdd0
-  data.tar.gz: 4c3a4cb3e2458afbceceabd517083565992ae034ca8f5ad9baddb580ab37919d422e7f9e670ae94a62aecbad3eab9e9bee768cab03e747b1e2510900c623c06d
+  metadata.gz: af198b2b5df5603f541d20aed1e618c4ec61b69f674302c0c6a6433f920f2089e08c24198a414a8ed9ab79556c2f5f95c5610411349a3f0c09ed07e6b9198b3b
+  data.tar.gz: 5ed2d9c7676d9c6713d2706bc27366bb3bdb7c98ed3c04615fe8bf72e6940bb3f7a52d942169358bd43e86f24a3f44217024d738b2a5e68cc5cf568a9885a9f6

data/Gemfile.lock

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

data/README.md

@@ -104,7 +104,8 @@ 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":
             [
@@ -216,7 +217,8 @@ the result will be:
             "formatter":
             {
               "type": "text",
-              "delimiter": "|"
+              "delimiter": "|",
+              "colorize": true
             },
             "filters":
             [
@@ -305,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"
@@ -348,6 +352,7 @@ the result will be:
                "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).

data/lib/RTALogger/version.rb

@@ -1,3 +1,3 @@
 module RTALogger
-  VERSION = '2.1.2'.freeze
+  VERSION = '2.4.0'.freeze
 end

data/lib/log_factory_filter.rb

@@ -9,7 +9,7 @@ module RTALogger
       begin
         load lib_file
       rescue
-        raise "unable to load formatter class file: #{lib_file}"
+        raise "unable to load filter class file: #{lib_file}"
       end
 
       filter_class_name = 'RTALogger::' + ('log_filter_' + type.to_s).split('_').map(&:capitalize).join

data/lib/log_factory_log_formatter.rb

@@ -21,7 +21,7 @@ module RTALogger
       return nil unless formatter_class
       result = formatter_class.new
 
-      return result if config_json.empty?
+      return result if config_json.nil? || config_json.empty?
       result.load_config(config_json) if result.present?
       return result
     end

data/lib/log_filter_base.rb

@@ -3,11 +3,14 @@ module RTALogger
     def initialize
       @title = self.class.to_s.split('::').last.underscore
       @enable = true
+      @action = :accept
     end
 
     attr_accessor :title
     attr_accessor :enable
     attr_accessor :default_regex
+    # possible values: accept, ignore
+    attr_accessor :action
 
     def match_conditions(log_record)
       return true if !@enable
@@ -18,11 +21,13 @@ module RTALogger
       @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?
+      @action = valid_action(config_json['action']) if config_json['action'].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?
+      @action = valid_action(config_json['action']) if config_json['action'].present?
     end
 
     def to_builder
@@ -31,9 +36,23 @@ module RTALogger
         json.title @title
         json.enable @enable
         json.default_regex @default_regex
+        json.action @action.to_s
       end
 
       jb
     end
+
+    private
+
+    def valid_action(action_value)
+      case action_value.to_s.downcase
+      when 'accept'
+        :accept
+      when 'ignore'
+        :ignore
+      else
+        :accept
+      end
+    end
   end
 end

data/lib/log_filter_context.rb

@@ -7,7 +7,9 @@ module RTALogger
       result = super
       return result unless result
 
-      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.context_id.to_s)) : result
+      result = default_regex.present? ? (Regexp.new(@default_regex).match(log_record.context_id.to_s)) : result
+      result = !result if @action == :ignore
+      return result
     end
   end
 end

data/lib/log_filter_message.rb

@@ -7,7 +7,9 @@ module RTALogger
       result = super
       return result unless result
 
-      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.full_message)) : result
+      result = default_regex.present? ? (Regexp.new(@default_regex).match(log_record.full_message)) : result
+      result = !result if @action == :ignore
+      return result
     end
   end
 end

data/lib/log_filter_topic.rb

@@ -7,7 +7,9 @@ module RTALogger
       result = super
       return result unless result
 
-      return default_regex.present? ? (Regexp.new(@default_regex).match(log_record.topic_title)) : result
+      result = default_regex.present? ? (Regexp.new(@default_regex).match(log_record.topic_title)) : result
+      result = !result if @action == :ignore
+      return result
     end
   end
 end

data/lib/log_formatter_base.rb

@@ -1,16 +1,24 @@
 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)
+      return unless config_json.present?
+
       @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 +28,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 +38,41 @@ module RTALogger
     def reveal_config
       to_builder.target!
     end
+
+    def apply_run_time_config(config_json)
+      return unless config_json.present?
+
+      @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_color
+      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

@@ -71,6 +71,7 @@ module RTALogger
       config_json = load_config_from_json_file(file_name, title)
       @config_file_name = file_name if config_json
       apply_config(config_json)
+      self
     rescue StandardError => e
       @propagator.drop_all_repositories
       @propagator.add_log_repository(LogFactory.create_repository(:console))
@@ -79,6 +80,7 @@ module RTALogger
     def config_use_json_string(config_string, title = '')
       config_json = load_config_from_json_string(config_string, title)
       apply_config(config_json)
+      self
     rescue StandardError => e
       @propagator.drop_all_repositories
       @propagator.add_log_repository(LogFactory.create_repository(:console))

data/lib/log_repository.rb

@@ -86,6 +86,7 @@ module RTALogger
     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['formatter'])
       apply_run_time_config_filters(config_json)
     end
 

data/lib/log_repository_file.rb

@@ -36,6 +36,8 @@ module RTALogger
 
     def apply_run_time_config(config_json)
       super config_json
+
+      @formatter.colorize = false
     end
 
     protected

data/lib/log_repository_fluentd.rb

@@ -62,6 +62,8 @@ module RTALogger
       @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

data/lib/log_topic.rb

@@ -22,33 +22,47 @@ module RTALogger
     attr_accessor :severity_level
 
     def trace(context_id, *message)
-      add(context_id, TRACE, message) if @severity_level.to_i <= TRACE.to_i
+      add(context_id, TRACE, message) if trace?
     end
 
     def debug(context_id, *message)
-      add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
+      add(context_id, DEBUG, message) if debug?
     end
 
     def info(context_id, *message)
-      add(context_id, INFO, message) if @severity_level.to_i <= INFO.to_i
+      add(context_id, INFO, message) if info?
     end
 
     def warning(context_id, *message)
-      add(context_id, WARN, message) if @severity_level.to_i <= WARN.to_i
+      add(context_id, WARN, message) if warn?
     end
 
     def error(context_id, *message)
-      add(context_id, ERROR, message) if @severity_level.to_i <= ERROR.to_i
+      add(context_id, ERROR, message) if error?
     end
 
     def fatal(context_id, *message)
-      add(context_id, FATAL, message) if @severity_level.to_i <= FATAL.to_i
+      add(context_id, FATAL, message) if fatal?
     end
 
     def unknown(context_id, *message)
-      add(context_id, UNKNOWN, message) if @severity_level.to_i <= UNKNOWN.to_i
+      add(context_id, UNKNOWN, message) if unknown?
     end
 
+    def trace?; @severity_level.to_i <= TRACE.to_i; end
+
+    def debug?; @severity_level.to_i <= DEBUG.to_i; end
+
+    def info?; @severity_level.to_i <= INFO.to_i; end
+
+    def warn?; @severity_level.to_i <= WARN.to_i; end
+
+    def error?; @severity_level.to_i <= ERROR.to_i; end
+
+    def fatal?; @severity_level.to_i <= FATAL.to_i; end
+
+    def unknown?; @severity_level.to_i <= UNKNOWN.to_i; end
+
     def to_builder
       jb = Jbuilder.new do |json|
         json.title title

data/lib/log_topic_wrapper.rb

@@ -0,0 +1,160 @@
+module RTALogger
+  class LogTopicWrapper
+    def initialize(context_id, topic, level = 0)
+      @context_id = context_id
+      @topic = topic
+      level = level - 1
+      level = 0 if level.negative?
+      level = 5 if level > 5
+      self.level = level
+    end
+
+    attr_accessor :progname
+    attr_accessor :context_id
+
+    # Logging severity.
+    module Severity
+      # Low-level information, mostly for developers.
+      DEBUG = 0
+      # Generic (useful) information about system operation.
+      INFO = 1
+      # A warning.
+      WARN = 2
+      # A handleable error condition.
+      ERROR = 3
+      # An unhandleable error that results in a program crash.
+      FATAL = 4
+      # An unknown message that should always be logged.
+      UNKNOWN = 5
+    end
+    include Severity
+
+    # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+    attr_reader :level
+
+    # Set logging severity threshold.
+    #
+    # +severity+:: The Severity of the log message.
+    def level=(severity)
+      if severity.is_a?(Integer)
+        severity = 0 if severity.negative?
+        severity = 5 if severity > 5
+        @level = severity
+      else
+        case severity.to_s.downcase
+        when 'debug'
+          @level = DEBUG
+        when 'info'
+          @level = INFO
+        when 'warn'
+          @level = WARN
+        when 'error'
+          @level = ERROR
+        when 'fatal'
+          @level = FATAL
+        when 'unknown'
+          @level = UNKNOWN
+        else
+          raise ArgumentError, "invalid log level: #{severity}"
+        end
+      end
+    end
+
+    # Returns +true+ iff the current severity level allows for the printing of
+    # +DEBUG+ messages.
+    def debug?;
+      @level <= DEBUG;
+    end
+
+    # Returns +true+ iff the current severity level allows for the printing of
+    # +INFO+ messages.
+    def info?;
+      @level <= INFO;
+    end
+
+    # Returns +true+ iff the current severity level allows for the printing of
+    # +WARN+ messages.
+    def warn?;
+      @level <= WARN;
+    end
+
+    # Returns +true+ iff the current severity level allows for the printing of
+    # +ERROR+ messages.
+    def error?;
+      @level <= ERROR;
+    end
+
+    # Returns +true+ iff the current severity level allows for the printing of
+    # +FATAL+ messages.
+    def fatal?;
+      @level <= FATAL;
+    end
+
+    def add(severity, message = nil, progname = nil)
+      severity ||= UNKNOWN
+
+      if progname.nil?
+        progname = @progname
+      end
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+
+      rta_logger_topic_log(severity, message)
+
+      true
+    end
+
+    alias log add
+
+    def debug(progname = nil, &block)
+      add(DEBUG, nil, progname, &block)
+    end
+
+    def info(progname = nil, &block)
+      add(INFO, nil, progname, &block)
+    end
+
+    def warn(progname = nil, &block)
+      add(WARN, nil, progname, &block)
+    end
+
+    def error(progname = nil, &block)
+      add(ERROR, nil, progname, &block)
+    end
+
+    def fatal(progname = nil, &block)
+      add(FATAL, nil, progname, &block)
+    end
+
+    def unknown(progname = nil, &block)
+      add(UNKNOWN, nil, progname, &block)
+    end
+
+    private
+
+    def rta_logger_topic_log(severity, message)
+      return if @topic.nil?
+
+      case severity
+      when DEBUG
+        @topic.debug(@context_id, message)
+      when INFO
+        @topic.info(@context_id, message)
+      when WARN
+        @topic.warning(@context_id, message)
+      when ERROR
+        @topic.error(@context_id, message)
+      when FATAL
+        @topic.fatal(@context_id, message)
+      when UNKNOWN
+        @topic.unknown(@context_id, message)
+      end
+    end
+  end
+end

data/lib/rta_logger_config.json

@@ -20,18 +20,21 @@
             "formatter":
             {
               "type": "text",
-              "delimiter": "|"
+              "delimiter": "|",
+              "colorize": true
             },
             "filters":
             [
               {
                 "type": "topic",
+                "action" : "ignore",
                 "title": "topic_filter_1",
-                "enable": true,
-                "default_regex" : "^test$"
+                "enable": false,
+                "default_regex" : "^test$",
               },
               {
                 "type": "message",
+                "action" : "accept",
                 "title": "message_filter_1",
                 "enable": false,
                 "default_regex" : "error"
@@ -52,9 +55,9 @@
             }
           },
           {
-            "enable": false,
             "title": "fluentd_repo_1",
             "type": "fluentd",
+            "enable": false,
             "host": "localhost",
             "port": "8888",
             "formatter":

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

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.1.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger
@@ -91,6 +91,7 @@ files:
 - lib/log_repository_fluentd.rb
 - lib/log_repository_udp.rb
 - lib/log_topic.rb
+- lib/log_topic_wrapper.rb
 - lib/rta_logger_config.json
 - lib/sample.rb
 - lib/severity_level.rb