RTALogger 0.1.2 → 1.1.1

data/lib/log_repository_console.rb

@@ -6,10 +6,14 @@ module RTALogger
   class LogRepositoryConsole < LogRepository
     def initialize
       super
+    end
 
-      @formatter = RTALogger::LogFactory.log_formatter_default
+    def load_config(config_json)
+      super
     end
 
+    # register :console
+
     protected
 
     def flush_and_clear

data/lib/log_repository_file.rb

@@ -1,6 +1,5 @@
 require 'logger'
 require_relative 'log_repository'
-require_relative 'log_factory_file_logger'
 require_relative 'log_factory_log_formatter'
 
 module RTALogger
@@ -8,12 +7,43 @@ module RTALogger
   class LogRepositoryFile < LogRepository
     def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
       super()
-      @file_logger = RTALogger::LogFactory.new_file_logger(file_path, period, shift_size)
-      @formatter = RTALogger::LogFactory.log_formatter_default
+      @file_path = file_path
+      @period = period
+      @shift_size = shift_size
+      @file_logger = create_ruby_logger(@file_path, @period, @shift_size)
     end
 
+    def load_config(config_json)
+      super
+
+      file_path = config_json['file_path'].to_s
+      period = config_json['roll_period'].to_s
+      shift_size = config_json['roll_size'].nil? ? 1_048_576 : config_json['roll_size'].to_i
+      @file_logger = create_ruby_logger(file_path, period, shift_size)
+    end
+
+    def to_builder
+      json = super
+      json.enable enable
+      json.file_path @file_path
+      json.period @period
+      json.shift_size @shift_size
+
+      json
+    end
+    # register :file
+
     protected
 
+    def create_ruby_logger(file_path, period, shift_size)
+      ruby_logger = Logger.new(file_path, period, shift_size)
+      ruby_logger.level = Logger::Severity::DEBUG
+      ruby_logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
+      ruby_logger
+    end
+
     def flush_and_clear
       semaphore.synchronize do
         @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }

data/lib/log_repository_fluentd.rb

@@ -0,0 +1,58 @@
+require 'fluent-logger'
+require_relative 'log_repository'
+
+module RTALogger
+  class LogRepositoryFluentd < LogRepository
+    def initialize(host = 'localhost', port = 24224, tls_options = nil)
+      super()
+      @host = host
+      @port = port
+      @fluent_logger = create_fluentd_logger(host, port, tls_options)
+    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']
+
+      @fluent_logger = create_fluentd_logger(host, port, tls_options)
+    end
+
+    def to_builder
+      json = super
+      json.enable enable
+      json.host @host
+      json.port @port
+
+      json
+    end
+    # register :fluentd
+
+    protected
+
+    def create_fluentd_logger(host, port, tls_options)
+      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)
+      end
+
+      fluent_logger
+    end
+
+    def flush_and_clear
+      semaphore.synchronize do
+        @log_records.each do |log_record|
+          fluent_tag = log_record.app_name + '.' + log_record.topic_title
+          log_json_string = @formatter.format(log_record)
+          log_json = JSON.parse(log_json_string)
+
+          @fluent_logger.post(fluent_tag, log_json)
+        end
+      end
+      super
+    end
+  end
+end

data/lib/log_repository_udp.rb

@@ -5,18 +5,26 @@ module RTALogger
   class LogRepositoryUDP < LogRepository
     def initialize(host = '127.0.0.1', port = 4913)
       super()
-      @host = host
-      @port = port
+      @udp_socket = UDPSocket.new
+      @udp_socket.bind(host, port)
     end
 
+    def load_config(config_json)
+      super
+
+      host = config_json['host'].to_s
+      port = config_json['port'].nil? ? 4913 : config_json['port'].to_i
+      @udp_socket = UDPSocket.new
+      @udp_socket.bind(host, port)
+    end
+
+    # register :udp
+
     protected
 
     def flush_and_clear
       semaphore.synchronize do
-        u1 = UDPSocket.new
-        u1.bind(@host, @port)
-        @log_records.each { |log_record| u1.send log_record.to_s, 0, @host, @port }
-        u1.close
+        @log_records.each { |log_record| @udp_socket.send @formatter.format(log_record), 0, @host, @port }
       end
       super
     end

data/lib/log_topic.rb

@@ -1,49 +1,59 @@
-require_relative 'log_severity'
+require_relative 'severity_level'
 require_relative 'log_factory_record'
+require 'jbuilder'
 
 module RTALogger
   # the main class to logging data as topic
   class LogTopic
-    include LogSeverity
+    include SeverityLevel
     include RTALogger::LogFactory
 
-    def initialize(log_manager, topic_title, log_level = WARN)
+    def initialize(log_manager, title, severity_level = WARN, enable = true)
       #  Logger logger = Logger.new(Logger::DEBUG)
-      @enable = true
+      @enable = enable
       @log_manager = log_manager
-      @topic_title = topic_title.to_s.dup
-      @log_level = log_level
+      @title = title.to_s.dup
+      @severity_level = severity_level
     end
 
     attr_accessor :enable
     attr_reader :log_manager
-    attr_reader :topic_title
-    attr_accessor :log_level
+    attr_reader :title
+    attr_accessor :severity_level
 
     def debug(context_id, *message)
-      add(context_id, DEBUG, message) if @log_level.to_i <= DEBUG.to_i
+      add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
     end
 
     def info(context_id, *message)
-      add(context_id, INFO, message) if @log_level.to_i <= INFO.to_i
+      add(context_id, INFO, message) if @severity_level.to_i <= INFO.to_i
     end
 
     def warning(context_id, *message)
-      add(context_id, WARN, message) if @log_level.to_i <= WARN.to_i
+      add(context_id, WARN, message) if @severity_level.to_i <= WARN.to_i
     end
 
     def error(context_id, *message)
-      add(context_id, ERROR, message) if @log_level.to_i <= ERROR.to_i
+      add(context_id, ERROR, message) if @severity_level.to_i <= ERROR.to_i
     end
 
     def fatal(context_id, *message)
-      add(context_id, FATAL, message) if @log_level.to_i <= FATAL.to_i
+      add(context_id, FATAL, message) if @severity_level.to_i <= FATAL.to_i
     end
 
     def unknown(context_id, *message)
-      add(context_id, UNKNOWN, message) if @log_level.to_i <= UNKNOWN.to_i
+      add(context_id, UNKNOWN, message) if @severity_level.to_i <= UNKNOWN.to_i
     end
 
+    def to_builder
+      jb = Jbuilder.new do |json|
+        json.title title
+        json.severity_level parse_severity_level_to_s(severity_level)
+        json.enable enable
+      end
+
+      jb
+    end
     private
 
     def add(context_id, severity, *message)

data/lib/rta_logger_config.json

@@ -1,35 +1,56 @@
 {
-  "RTALogger":
+  "rta_logger":
   {
-    "Default_Manager": "Develop",
-    "Log_Managers":
+    "default_manager": "develop",
+    "log_managers":
     [
       {
-        "Manager_Name": "Develop",
-        "Enable": true,
-        "App_Name": "TestApp",
-        "Log_Severity": 2,
-        "Buffer_Size": 100,
-        "Flush_Wait_Seconds": 15,
-        "Formatter" : "JSON",
-        "Repos":
+        "manager_name": "develop",
+        "enable": true,
+        "app_name": "TestApp",
+        "severity_level": "debug",
+        "buffer_size": 100,
+        "flush_wait_seconds": 10,
+        "repositories":
         [
           {
-            "Enable": true,
-            "Type": "Console"
+            "enable": true,
+            "type": "console",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
           },
           {
-            "Enable": false,
-            "Type": "File",
-            "File_Path": "../../log/log.txt",
-            "Roll_Period": "daily",
-            "Roll_Size": "1048576"
+            "enable": true,
+            "type": "file",
+            "file_path": "log.txt",
+            "roll_period": "daily",
+            "roll_size": "1048576",
+            "formatter":
+            {
+              "type": "json",
+              "delimiter": "|"
+            }
           },
           {
-            "Enable": true,
-            "Type": "Fluentd",
-            "Host": "localhost",
-            "Port": "8888"
+            "enable": true,
+            "type": "fluentd",
+            "host": "localhost",
+            "port": "8888",
+            "formatter":
+            {
+              "type": "json"
+            }
+          }
+        ],
+        "topics":
+        [
+          {
+            "title": "test",
+            "enable": true,
+            "severity_level": "WARN"
           }
         ]
       }

data/lib/sample.rb

@@ -4,6 +4,8 @@ require_relative 'log_factory_repository'
 controller_name = 'test_controller'
 userID = 5
 
+# RTALogger::LogFactory.register_log_repository :console, 'log_repository_console.rb'
+
 # create log manager instance
 # this could be a global variable declared in application level
 log_manager = RTALogger::LogFactory.log_manager_instance
@@ -21,6 +23,9 @@ log_manager.config_use_json_file('rta_logger_config.json')
 # use this api to get a new log topic instance
 # this api could be called in entry point of each service or class initialize method
 topic = log_manager.add_topic(controller_name)
+test_topic = log_manager.add_topic('test')
+# test_topic.severity_level = ::RTALogger::SeverityLevel::FATAL
+# test_topic.enable = false
 
 # add log information to log topic
 topic.debug(userID, 'Controller Name=', controller_name, 'debug')
@@ -30,8 +35,13 @@ topic.error(userID, 'Controller Name=', controller_name, 'error')
 topic.fatal(userID, 'Controller Name=', controller_name, 'fatal')
 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
+
 # update specific topic log level if necessary
-# log_manager.update_topic_level(controller_name, RTALogger::LogSeverity::INFO)
+# log_manager.update_topic_level(controller_name, RTALogger::SeverityLevel::INFO)
 
 # update all topics log level if necessary
-# log_manager.update_all_topics_log_level(RTALogger::LogSeverity::INFO)
+# log_manager.update_all_topics_severity_level(RTALogger::SeverityLevel::INFO)

data/lib/severity_level.rb

@@ -0,0 +1,60 @@
+module RTALogger
+  # Logging severity.
+  module SeverityLevel
+    # 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 un-handleable error that results in a program crash.
+    FATAL = 4
+    # An unknown message that should always be logged.
+    UNKNOWN = 5
+
+
+    def parse_severity_level_to_i(severity_level)
+      return severity_level if severity_level.is_a? ::Integer
+
+      case severity_level.upcase
+      when 'DEBUG'
+        0
+      when 'INFO'
+        1
+      when 'INFORMATIONّٔ'
+        1
+      when 'WARN'
+        2
+      when 'WARNING'
+        2
+      when 'ERROR'
+        3
+      when 'FATAL'
+        4
+      when 'UNKNOWN'
+        5
+      end
+    end
+
+    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
+    end
+  end
+end

data/lib/string.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 1.1.1
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-08 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger
@@ -68,14 +68,13 @@ files:
 - bin/setup
 - lib/RTALogger.rb
 - lib/RTALogger/version.rb
-- lib/log_factory_file_logger.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_formatter.rb
+- lib/log_formatter_base.rb
 - lib/log_formatter_json.rb
 - lib/log_formatter_text.rb
 - lib/log_manager.rb
@@ -84,12 +83,13 @@ files:
 - lib/log_repository.rb
 - lib/log_repository_console.rb
 - lib/log_repository_file.rb
-- lib/log_repository_fluent.rb
+- lib/log_repository_fluentd.rb
 - lib/log_repository_udp.rb
-- lib/log_severity.rb
 - lib/log_topic.rb
 - lib/rta_logger_config.json
 - lib/sample.rb
+- lib/severity_level.rb
+- lib/string.rb
 homepage: https://github.com/BBahrainy/RTALogger.git
 licenses:
 - MIT