RTALogger 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbb273e7ee1ae08716218cd1338f233c0b5af1d652934cae575b319f7a4f5c66
-  data.tar.gz: 010d8cc58971fa3252875c245d6b4deea9e5183ef122f17b6e403621e223f17c
+  metadata.gz: d4c558e31bfbc739d0ad9ebb218c96c61fdcc354b6ae9a9c0daa3ea4743786c3
+  data.tar.gz: b00ec909d9a8791671e29e949fb19cfb31e59d7fbf353532a70bfb216e6b4e45
 SHA512:
-  metadata.gz: c91009d62b8810a5f2930c43e16a132673fa31487bd81c8843a4072244ea893f52d542364587fc94c9c3cf6de49e90351b72d9074491e740a395466400e4a722
-  data.tar.gz: 0bd9f95d1a89cd1d0341f18f90e42e8fb0f1cffe11637d2f558e29a14a371e0380f18111ce2be208b7e8854ce9df1e2fb1d3e6da0b34ea5476090a9fdd97833a
+  metadata.gz: c6296831235e737111217cf51f4e3d477620d588319fb0540760b948028b26f87361e03cc7c453dd00ab3c4553a26ad045791e2d9e64d1153017246e664348bd
+  data.tar.gz: 39885f5f4f039199748d9201f632ac4e745bd41cced49971ddc70b9599281c556a2d85e3fb13332a76cb0b01d78f1efb88d510331071332ccfdcbd26528543a7

data/Gemfile.lock

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

data/README.md

@@ -81,6 +81,51 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
     # the parameter is the json config file
     log_manager.config_use_json_file('rta_logger_config.json')
 ```
+- Sample configuration json file
+```
+{
+  "rta_logger":
+  {
+    "default_manager": "develop",
+    "log_managers":
+      [
+        {
+          "manager_name": "develop",
+          "enable": true,
+          "app_name": "TestApp",
+          "severity_level": "debug",
+          "buffer_size": 100,
+          "flush_wait_seconds": 15,
+          "repos":
+                  [
+                    {
+                      "enable": true,
+                      "type": "console",
+                      "formatter": "delimited_text",
+                      "delimiter": "|"
+                    },
+                    {
+                      "enable": true,
+                      "type": "File",
+                      "file_path": "./log/log.txt",
+                      "roll_period": "daily",
+                      "roll_size": "1048576",
+                      "formatter": "delimited_text",
+                      "delimiter": "|"
+                    },
+                    {
+                      "enable": true,
+                      "type": "fluentd",
+                      "host": "localhost",
+                      "port": "8888",
+                      "formatter": "json"
+                    }
+                  ]
+        }
+      ]
+  }
+}
+``` 
 - Add new topic to log manager and get the topic instance
 ```ruby
     # the parameter is the topic name
@@ -112,50 +157,58 @@ the result will be:
 - json config file sample
 ```json
 {
-  "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": 15,
+        "repos":
         [
           {
-            "Enable": true,
-            "Type": "Console"
-          },
-          {
-            "Enable": true,
-            "Type": "UDP",
-            "Host": "localhost",
-            "Port": 8888
+            "enable": true,
+            "type": "console",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
           },
           {
-            "Enable": false,
-            "Type": "File",
-            "File_Path": "../../log/log.txt",
-            "Roll_Period": "daily",
-            "Roll_Size": "1048576"
+            "enable": false,
+            "type": "file",
+            "file_path": "log.txt",
+            "roll_period": "daily",
+            "roll_size": "1048576",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
           },
           {
-            "Enable": true,
-            "Type": "Fluentd",
-            "Host": "localhost",
-            "Port": "24442",
-            "TLS_Options": 
+            "enable": false,
+            "type": "fluentd",
+            "host": "localhost",
+            "port": "8888",
+            "formatter":
             {
-              "ca":",/path/to/cacert.pem",
-              "cert":"/path/to/client-cert.pem",
-              "key":"/path/to/client-key.pem",
-              "key_passphrase":"test"
-             }
+              "type": "json"
+            }
+          }
+        ],
+        "topics":
+        [
+          {
+            "title": "test",
+            "enable": true,
+            "severity_level": "info"
           }
         ]
       }
@@ -170,47 +223,64 @@ the result will be:
   log_manager.config_use_json_file('rta_logger_config.json')
      
   The file structure:
-  - RTALogger : the root element of RTALogger json configuration.
-    - Default_Manager: the name of default log manager config, when there is 
+  - rta_logger : the root element of rta_logger json configuration.
+    - default_manager: the name of default log manager config, when there is 
       multiple log manager configuration in Log_Managers array.
-    - Log_Managers : the array of LogManagers with different configuration.
+    - log_managers : the array of LogManagers with different configuration.
       It is possible to define multiple log manager configurations for differen usages.
-      - Name: the name of log manager. It will be used to define the default log manager.
-      - Enable: (true/false) The value of this property activate or deactivate entire log manager.
-      - App_Name: Application name as the owner of log data.
-      - Log_Severity: Defines which level of log data will be stored in log repositories.
-      - BufferSize: The memory buffer size (number of buffered log objects) to 
+      - manager_name: the name of log manager. It will be used to define the default log manager.
+      - enable: (true/false) The value of this property activate or deactivate entire log manager.
+      - app_name: Application name as the owner of log data.
+      - severity_level: Defines which level of log data will be stored in log repositories.
+      - buffer_size: The memory buffer size (number of buffered log objects) to 
         decread api consumers wait time. when the buffer is full the flush operation will
         save buffered logs to log repositoies.
-      - Flush_Wait_Seconds: Time in soconds which log managers wait to flush buffered log objects
+      - flush_wait_seconds: Time in soconds which log managers wait to flush buffered log objects
         to log repository.
-      - Formatter: (JSON/TEXT) declare log format when it's required to converrt log object to text.
-      - Repos: Array of log repositories. It is possible to define multiple log repositories to
+      - repos: Array of log repositories. It is possible to define multiple log repositories to
         store log data. there are variaty of log repositories and it is possible to
         add new ones. Each item in Repos array will configure a log repository.
+        Pre-defined types are described below, also it's possible to implement your custome repo type 
+        and register it to RTALogger.
         - Log repository types and config:
-          1- Console: Show log data in text format on standard out put
-             - "Type":"Console"
-             - "Enable": [true/false] this will activate or deactivate log repository.
-          2- File: Store log data in a file.
-             - "Type":"Console"
-             - "Enable": [true/false] this will activate or deactivate log repository.
-             - "File_Path": [file path and file name] the path and the name to store log data.
-             - "Roll_Period": ["daily"/"weekly"/"monthly"] the period to generate new log file.
-             - "Roll_Size": [bytes]  the maximum size of log file to 
+          1- console: Show log data in text format on standard out put
+             - "type": "console"
+             - "enable": [true/false] this will activate or deactivate log repository.
+             - "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 "|")]
+                if formatter not defined then the json formatter will be used
+          2- file: Store log data in a file.
+             - "type": "console"
+             - "enable": [true/false] this will activate or deactivate log repository.
+             - "file_path": [file path and file name] the path and the name to store log data.
+             - "roll_period": ["daily"/"weekly"/"monthly"] the period to generate new log file.
+             - "roll_size": [bytes]  the maximum size of log file to 
                 roll file and create the new log file
-          3- UDP: Send log data over UDP on network. 
-             - "Type":"Console"
-             - "Enable": [true/false] this will activate or deactivate log repository.
-             - "Host": IP of the server to send log data.
-             - "Port": Port of server to send log data.
-          4- Fluentd: send log data to Fluentd Log collector over network using TCP/IP protocol.
-             - "Type":"Console"
-             - "Enable": [true/false] this will activate or deactivate log repository.
-             - "Host": IP of the server to send log data.
-             - "Port": Port of server to send log data.
-             - "TLS_Options": TLS configuration to stablish a secure TCP connection to Fluentd Server.
- 
+             - "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 "|")]
+                if formatter not defined then the json formatter will be used
+          3- udp: Send log data over UDP on network. 
+             - "type": "udp"
+             - "enable": [true/false] this will activate or deactivate log repository.
+             - "host": IP of the server to send log data.
+             - "port": Port of server to send log data.
+          4- fluentd: send log data to Fluentd Log collector over network using TCP/IP protocol.
+             - "type": "fluentd"
+             - "enable": [true/false] this will activate or deactivate log repository.
+             - "host": IP of the server to send log data.
+             - "port": Port of server to send log data.
+             - "tls_options": TLS configuration to stablish a secure TCP connection to Fluentd Server.
+             - "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 "|")]
+                if formatter not defined then the json formatter will be used
+        - 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).
+          - severity_level: Defines which level of log data will be stored in log repositories.
+          - enable: [true/false] to enable or disable logging process of the topic.
 ```
 - Some useful features
 ```ruby
@@ -218,14 +288,38 @@ the result will be:
     log_manager.app_name = 'myTestApp'
 
     # update specific topic log level if necessary
-    log_manager.update_topic_level(controller_name, RTALogger::LogSeverity::INFO)
+    log_manager.update_topic_severity_level(topic_title, RTALogger::SeverityLevel::INFO)
+
+    # update all topics severity level if necessary
+    log_manager.update_all_topics_severity_level(RTALogger::SeverityLevel::INFO)
 
-    # update all topics log level if necessary
-    log_manager.update_all_topics_log_level(RTALogger::LogSeverity::INFO)
+    # enable or disable specific topic if necessary
+    log_manager.update_topic_enable(topic_title, [true/false])
+
+    # enable or disable all topic if necessary
+    log_manager.update_all_topics_enable([true/false])
 ```
 - Implement and Expand
-  It is possible to implement new log repositories.
-  All repository classes should inherit from 'RTALogger::LogRepository'
+  It is possible to implement new log repositories. There will be fue rules to implement and
+  integrate new customized log repository with RTALogger LogManager.
+  
+  1- Define you class inside RTALogger module.
+  
+  2- The class should be inherited from 'RTALogger::LogRepository'.
+  
+  3- Also appropriate naming convention is necessary. 
+     As an example if you are implementing a Console Repo, your class name should be LogRepositoryConsole and 
+     your source code in a ruby file and name it log_repository_console.rb
+  
+  4- After implementing your own log repository, you should register the class at run-time using the following syntax:
+  ```ruby
+  RTALogger::LogFactory.register_log_repository :console, 'log_repository_console.rb'
+  ```
+  Another example: LogRepositoryMyCustomizedUdp
+
+  ```ruby
+  RTALogger::LogFactory.register_log_repository :my_customized_udp, 'log_repository_my_customized_udp.rb'
+  ```
   Here is 'LogRepositoryConsole' implementation:
 ```ruby
 require_relative 'log_repository'

data/lib/RTALogger/version.rb

@@ -1,3 +1,3 @@
 module RTALogger
-  VERSION = '0.1.4'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/log_factory_log_formatter.rb

@@ -1,20 +1,35 @@
-require_relative 'log_formatter_text'
-require_relative 'log_formatter_json'
-
 module RTALogger
   # Log factory to get new instance of log formatter
   module LogFactory
     def self.log_formatter_default
-      RTALogger::LogFormatterJSON.new
-      # RTALogger::LogFormatterText.new
+      create_formatter(:json)
     end
 
-    def self.log_formatter_json
-      RTALogger::LogFormatterJSON.new
+    def self.create_formatter(type, config_json = '')
+      lib_file = @log_formatters[type.to_sym]
+      raise "unregistered formatter 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
+
+      formatter_class_name = 'RTALogger::' + ('log_formatter_' + type.to_s).split('_').map(&:capitalize).join
+      formatter_class = Object.const_get(formatter_class_name)
+      return nil unless formatter_class
+      result = formatter_class.new
+
+      return result if config_json.empty?
+      result.load_config(config_json) if result.present?
+      return result
     end
 
-    def self.log_formatter_text
-      RTALogger::LogFormatterText.new
+    def self.register_log_formatter(type, class_file_name)
+      @log_formatters[type.to_sym] = class_file_name
     end
+
+    @log_formatters = {:text => 'log_formatter_text.rb',
+                          :json =>  'log_formatter_json.rb'}
   end
 end

data/lib/log_factory_repository.rb

@@ -1,56 +1,37 @@
 # frozen_string_literal: true
 
-require_relative 'log_repository_console'
-require_relative 'log_repository_file'
-require_relative 'log_repository_udp'
-require_relative 'log_repository_fluent'
-
 module RTALogger
   # this module generates object instance
   module LogFactory
-    def self.new_log_repository_console
-      LogRepositoryConsole.new
-    end
+    def self.create_repository(type, config_json = '')
+      lib_file = @log_repositories[type.to_sym]
+      raise "unregistered repository class: #{type.to_s}" if lib_file.nil? || lib_file.empty?
 
-    def self.new_log_repository_file(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
-      LogRepositoryFile.new(file_path, period, shift_size)
-    end
+      begin
+        load lib_file
+      rescue
+        raise "unable to load repository class file: #{lib_file}"
+      end
 
-    def self.load_log_repository_file(config_json)
-      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
-      ::RTALogger::LogFactory.new_log_repository_file(file_path, period, shift_size)
-    end
+      # repo_class_name = 'RTALogger::' + type.split('_').map(&:capitalize).join
+      repo_class_name = 'RTALogger::' + ('log_repository_' + type.to_s).split('_').map(&:capitalize).join
+      repo_class = Object.const_get(repo_class_name)
+      return nil unless repo_class
+      result = repo_class.new
 
-    def self.new_log_repository_udp(host = '127.0.0.1', port = 4913)
-      LogRepositoryUDP.new(host, port)
+      # result = LogRepository.create type.to_sym
+      return result if config_json.empty?
+      result.load_config(config_json) if result.present?
+      return result
     end
 
-    def self.load_log_repository_udp(config_json)
-      host = config_json['Host'].to_s
-      port = config_json['Port'].nil? ? 4913 : config_json['Port'].to_i
-      ::RTALogger::LogFactory.new_log_repository_udp(host, port)
+    def self.register_log_repository(type, class_file_name)
+      @log_repositories[type.to_sym] = class_file_name
     end
 
-    def self.new_log_repository_fluent(host = 'localhost', port = '24224', tls_options = nil)
-      LogRepositoryFluent.new(host, port, tls_options)
-    end
-
-    def self.load_log_repository_fluent(config_json)
-      host = config_json['Host'].to_s
-      port = config_json['Port'].to_s
-      tls_options = config_json['TLS_Options']
-      ::RTALogger::LogFactory.new_log_repository_fluent(host, port, tls_options)
-    end
-
-    def self.create_repository(type, config_json)
-      result = nil
-      result = new_log_repository_console if type.to_s.casecmp('Console').zero?
-      result = load_log_repository_file(config_json) if type.to_s.casecmp('File').zero?
-      result = load_log_repository_udp(config_json) if type.to_s.casecmp('UDP').zero?
-      result = load_log_repository_fluent(config_json) if type.to_s.casecmp('Fluentd').zero?
-      result
-    end
+    @log_repositories = {:console => 'log_repository_console.rb',
+                          :file =>  'log_repository_file.rb',
+                          :udp =>  'log_repository_upd.rb',
+                          :fluentd => 'log_repository_fluetnd.rb'}
   end
 end

data/lib/log_factory_topic.rb

@@ -5,8 +5,8 @@ require_relative 'log_topic'
 module RTALogger
   # this module generates object instance
   module LogFactory
-    def self.new_log_topic(log_manager, topic_title, level = WARN)
-      LogTopic.new(log_manager, topic_title, level)
+    def self.new_log_topic(log_manager, title, level = WARN, enable = true)
+      LogTopic.new(log_manager, title, level, enable)
     end
   end
 end

data/lib/log_formatter.rb

@@ -1,6 +1,16 @@
+# Log Formatter base class
 module RTALogger
-  # Log Formatter base class
   class LogFormatter
+    def initialize
+      @delimiter = '|'
+    end
+
+    attr_accessor :delimiter
+
+    def load_config(config_json)
+      @delimiter = config_json['delimiter'].nil? ? true : config_json['delimiter']
+    end
+
     def format(log_record)
       log_record.to_s
     end

data/lib/log_formatter_json.rb

@@ -4,7 +4,7 @@ require_relative 'log_formatter'
 module RTALogger
   # json formatter which receive log_record and
   # returns it's data as json string
-  class LogFormatterJSON
+  class LogFormatterJson < LogFormatter
     def format(log_record)
       return '' unless log_record
 

data/lib/log_formatter_text.rb

@@ -4,15 +4,15 @@ module RTALogger
   # text formatter which receive log_record and
   # returns it's data as delimited text string
   class LogFormatterText < LogFormatter
-    def format(log_record, delimiter = '|')
+    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
-      result << delimiter << log_record.severity
-      result << delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
+      result << @delimiter << log_record.app_name
+      result << @delimiter << log_record.topic_title
+      result << @delimiter << log_record.context_id
+      result << @delimiter << log_record.severity
+      result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
 
       result
     end

data/lib/log_manager.rb

@@ -1,28 +1,34 @@
 require 'date'
 require 'thread'
 require 'singleton'
+require 'json'
+require 'json/version'
+require 'json/generic_object'
 require_relative 'log_factory_propagator'
 require_relative 'log_factory_repository'
 require_relative 'log_factory_topic'
-require_relative 'log_severity'
+require_relative 'severity_level'
+require 'jbuilder'
 
 # the module will contain all logger requirements
 module RTALogger
   # the class is the main class
   class LogManager
     include Singleton
-    include LogSeverity
+    include SeverityLevel
     include RTALogger::LogFactory
 
     def initialize
       @enable = true
-      @app_name = ENV.fetch('RTALogger_App_Name', 'unknownApp')
-      @default_log_level = ENV.fetch('RTALogger_Log_Severity', ::RTALogger::LogSeverity::WARN)
+      @name = 'default_log_manager'
+      @app_name = ENV.fetch('RTA_LOGGER_APP_NAME', 'unknown_app')
+      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', WARN)
+      @config_file_name = ''
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
-      @buffer_size = ENV.fetch('RTALogger_Buffer_Size', 100)
+      @buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
       @flush_size = @buffer_size * 20 / 100
-      @flush_wait_time = ENV.fetch('RTALogger_Flush_Wait_Seconds', 15)
+      @flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -36,13 +42,25 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    def config_use_json_file(config_file_name, manager_name = '')
-      config_json = load_config_from_json_file(config_file_name, manager_name)
+    attr_reader :name
+    attr_accessor :enable
+    attr_accessor :app_name
+    attr_reader :propagator
+    attr_accessor :default_severity_level
+    attr_accessor :buffer_size
+    attr_reader :flush_size
+    attr_accessor :flush_wait_time
+    attr_reader :topics
+    attr_reader :config_file_name
+
+    def config_use_json_file(file_name, manager_name = '')
+      config_json = load_config_from_json_file(file_name, manager_name)
+      @config_file_name = file_name if config_json
       apply_config(config_json)
     rescue StandardError => e
       puts e.message
       @propagator.drop_all_repositories
-      @propagator.add_log_repository(LogFactory.new_log_repository_console)
+      @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
 
     def config_use_json_string(config_string, manager_name = '')
@@ -51,21 +69,15 @@ module RTALogger
     rescue StandardError => e
       puts e.message
       @propagator.drop_all_repositories
-      @propagator.add_log_repository(LogFactory.new_log_repository_console)
+      @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
 
-    attr_accessor :enable
-    attr_accessor :app_name
-    attr_reader :propagator
-    attr_reader :default_log_level
-
-    def add_topic(topic_title, log_level = @default_log_level)
+    def add_topic(title, severity_level = @default_severity_level, enable = true)
       @topic_semaphore.synchronize {
-        @topics[topic_title.to_sym] ||= LogFactory.new_log_topic(self, topic_title, log_level)
+        @topics[title.to_sym] ||= LogFactory.new_log_topic(self, title, severity_level, enable)
       }
 
-      @topics[topic_title.to_sym].enable = @enable
-      @topics[topic_title.to_sym]
+      @topics[title.to_sym]
     end
 
     def add_log(log_record)
@@ -74,52 +86,100 @@ module RTALogger
       check_for_flush
     end
 
-    def update_topic_log_level(topic, log_level = WARN)
-      @topic_semaphore.synchronize { @topics[topic].log_level = log_level if @topics[topic] }
+    def update_topic_enable(topic, enable = true)
+      @topic_semaphore.synchronize { @topics[topic.to_sym].enable = enable if @topics[topic.to_sym] }
+    end
+
+    def update_all_topics_enable(enable = true)
+      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].enable = enable } }
+    end
+
+    def update_topic_severity_level(topic, severity_level = WARN)
+      @topic_semaphore.synchronize { @topics[topic.to_sym].severity_level = severity_level if @topics[topic.to_sym] }
+    end
+
+    def update_all_topics_severity_level(severity_level = WARN)
+      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].severity_level = severity_level } }
+    end
+
+    def to_builder
+      @topic_semaphore.synchronize do
+        jb = Jbuilder.new do |json|
+          json.name name
+          json.enable enable
+          json.app_name app_name
+          json.config_file_name config_file_name
+          json.default_severity_level default_severity_level
+          json.buffer_size buffer_size
+          json.flush_size flush_size
+          json.flush_wait_time flush_wait_time
+          json.topics do
+            json.array! topics.keys.collect { |topic_key| @topics[topic_key].to_builder.attributes! }
+          end
+        end
+
+        jb
+      end
     end
 
-    def update_all_topics_log_level(log_level = WARN)
-      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].log_level = log_level } }
+    def reveal_config
+      to_builder.target!
     end
 
     private
 
     def load_config_from_json_file(config_file_name, manager_name = '')
       config_file = File.open config_file_name
-      config_json = JSON.load config_file
+      config_json = ::JSON.load(config_file)
       config_json = extract_config(config_json, manager_name)
       config_json
     end
 
     def load_config_from_json_string(config_string, manager_name = '')
-      config_json = JSON.parse(config_string)
+      config_json = ::JSON.parse(config_string)
       config_json = extract_config(config_json, manager_name)
       config_json
     end
 
     def extract_config(json_data, manager_name = '')
-      config_json = json_data['RTALogger']
+      config_json = json_data['rta_logger']
       raise 'RTALogger configuration not found!' unless config_json
-      raise 'Log_Managers section does not exists json configuration' unless config_json['Log_Managers']
-      raise 'No config manager defined in json configuration' unless config_json['Log_Managers'].count.positive?
-      manager_name = config_json['Default_Manager'] if manager_name.blank?
+      raise 'Log_Managers section does not exists json configuration' unless config_json['log_managers']
+      raise 'No config manager defined in json configuration' unless config_json['log_managers'].count.positive?
+      manager_name = config_json['default_manager'] if manager_name.empty?
       unless manager_name.to_s.strip.empty?
-        config_json = config_json['Log_Managers'].find { |item| item['Manager_Name'] == manager_name }
+        config_json = config_json['log_managers'].find { |item| item['manager_name'] == manager_name }
       end
-      config_json ||= config_json['Log_Managers'][0]
+      config_json ||= config_json['log_managers'][0]
       raise 'Unable to extract RTA Log Manager configuration!' unless config_json
+      @name = manager_name if config_json
       config_json
     end
 
     def apply_config(config_json)
       raise 'json config not available' unless config_json
-      @enable = config_json['Enable'].nil? ? true : config_json['Enable']
-      @app_name = config_json['App_Name'] if config_json['App_Name'].present?
-      @default_log_level = config_json['Log_Severity'] if config_json['Log_Severity'].present?
-      @buffer_siz = config_json['Buffer_Size'] if config_json['Buffer_Size'].present?
-      @flush_wait_time = config_json['Flush_Wait_Seconds'] if config_json['Flush_Wait_Seconds'].present?
+      @enable = config_json['enable'].nil? ? true : config_json['enable']
+      @app_name = config_json['app_name'] unless config_json['app_name'].empty?
+      @default_severity_level = parse_severity_level_to_i(config_json['severity_level']) if config_json['severity_level']
+      @buffer_size = config_json['buffer_size'] if config_json['buffer_size']
+      @flush_wait_time = config_json['flush_wait_seconds'] if config_json['flush_wait_seconds']
       @propagator.drop_all_repositories
-      config_json['Repos']&.each { |item| @propagator.load_log_repository(item) }
+      apply_config_repos(config_json)
+      apply_config_topics(config_json)
+    end
+
+    def apply_config_repos(config_json)
+      config_json['repos']&.each { |item| @propagator.load_log_repository(item) }
+    end
+
+    def apply_config_topics(config_json)
+      config_json['topics']&.each do |topic|
+        next unless topic['title']
+        result_topic = add_topic(topic['title'])
+        next unless result_topic
+        result_topic.severity_level = parse_severity_level_to_i topic['severity_level'] if topic['severity_level']
+        result_topic.enable = topic['enable'] if topic['enable']
+      end
     end
 
     def initialize_flush_scheduler
@@ -153,7 +213,7 @@ module RTALogger
 
     def flush_all
       @log_semaphore.synchronize do
-        @log_records[0...@log_records.count].each { |log|  propagate(log) }
+        @log_records[0...@log_records.count].each { |log| propagate(log) }
         @log_records.clear
       end
       @propagator.propagate
@@ -162,5 +222,6 @@ module RTALogger
     def propagate(log_record)
       @propagator.add_log(log_record)
     end
+
   end
 end

data/lib/log_propagator.rb

@@ -19,9 +19,9 @@ module RTALogger
     end
 
     def load_log_repository(config_json)
-      type = config_json['Type']
+      type = config_json['type']
       return if type.to_s.strip.empty?
-      enable = config_json['Enable'].nil? ? true : config_json['Enable']
+      enable = config_json['enable'].nil? ? true : config_json['enable']
       return unless enable
 
       log_repository = ::RTALogger::LogFactory.create_repository(type, config_json)

data/lib/log_record.rb

@@ -21,7 +21,7 @@ module RTALogger
     end
 
     def topic_title
-      @log_topic.topic_title
+      @log_topic.title
     end
   end
 end

data/lib/log_repository.rb

@@ -7,6 +7,23 @@ module RTALogger
       @enable = true
     end
 
+    # @@sub_classes = {}
+
+    # def self.create type
+    #   requested_class = @@sub_classes[type]
+    #   if requested_class
+    #     requested_class.new
+    #   else
+    #     raise "Bad log repository type: #{type}"
+    #   end
+    # end
+    #
+    # def self.register repository_name
+    #   @@sub_classes[repository_name] = self
+    # end
+
+    attr_accessor :enable
+
     def add_log_records(items)
       return 0 unless @enable
       @semaphore.synchronize do
@@ -15,7 +32,14 @@ module RTALogger
       flush_and_clear
     end
 
-    attr_accessor :enable
+    def load_config(config_json)
+      @enable = config_json['enable'].nil? ? true : config_json['enable']
+
+      formatter_config = config_json['formatter']
+      if formatter_config && formatter_config['type']
+        @formatter = LogFactory.create_formatter(formatter_config['type'], formatter_config)
+      end
+    end
 
     protected
 

data/lib/log_repository_console.rb

@@ -10,6 +10,12 @@ module RTALogger
       @formatter = RTALogger::LogFactory.log_formatter_default
     end
 
+    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,32 @@ 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)
+      @file_logger = create_ruby_logger(file_path, period, shift_size)
       @formatter = RTALogger::LogFactory.log_formatter_default
     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
+
+    # 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_fluent.rb

@@ -5,15 +5,32 @@ module RTALogger
   class LogRepositoryFluent < LogRepository
     def initialize(host = 'localhost', port = 24224, tls_options = nil)
       super()
-      @host = host
-      @port = port
-      @tls_options = tls_options
       @formatter = RTALogger::LogFactory.log_formatter_json
-      if @tls_options
-        @fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => @host, :port => @port, :use_nonblock => true, :wait_writeable => false)
+      @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
+
+    # 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)
+        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

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": 15,
+        "repos":
         [
           {
-            "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": "text",
+              "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,9 @@ 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 +24,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 +36,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger
@@ -68,7 +68,6 @@ 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
@@ -86,10 +85,10 @@ files:
 - lib/log_repository_file.rb
 - lib/log_repository_fluent.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
 homepage: https://github.com/BBahrainy/RTALogger.git
 licenses:
 - MIT

data/lib/log_factory_file_logger.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-
-module RTALogger
-  # this module generates object instance
-  module LogFactory
-    def self.new_file_logger(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
-      @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
-  end
-end

data/lib/log_severity.rb

@@ -1,17 +0,0 @@
-module RTALogger
-  # Logging severity.
-  module LogSeverity
-    # 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
-  end
-end