RTALogger 1.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4c558e31bfbc739d0ad9ebb218c96c61fdcc354b6ae9a9c0daa3ea4743786c3
-  data.tar.gz: b00ec909d9a8791671e29e949fb19cfb31e59d7fbf353532a70bfb216e6b4e45
+  metadata.gz: f8fb5a3e4e0c67b6e485cf932ab274fc5a55539fb6432e76e119c0877d786c23
+  data.tar.gz: 57c69c4601f00d24c395fd42b8a75fe74020a5f9b5222b14e38fe9c673134c97
 SHA512:
-  metadata.gz: c6296831235e737111217cf51f4e3d477620d588319fb0540760b948028b26f87361e03cc7c453dd00ab3c4553a26ad045791e2d9e64d1153017246e664348bd
-  data.tar.gz: 39885f5f4f039199748d9201f632ac4e745bd41cced49971ddc70b9599281c556a2d85e3fb13332a76cb0b01d78f1efb88d510331071332ccfdcbd26528543a7
+  metadata.gz: 22b65c1867090cadd8aaff4f735ef401be30fe890e3164b7a45b5df40979ee0d5439d5c2fae66273c929e4c821abaa928b208b2e7c6ad535908be48b2923bea2
+  data.tar.gz: 191367dfa21447a54f6ad218ed0f66d0615297b126e6a9aeda446c82900f05fbd457fbe0f200d860885be4f2760dd04a62e008634bc525c2e8554d5784883fc5

data/Gemfile.lock

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

data/README.md

@@ -7,26 +7,24 @@ All log manager's main features are configable through a json config file.
 
 Main purposes of developing this gem are:
 - Creating standard logging API to seperate application from existing variety of loggers.
-- Wrapping around existing loggers so get advantage of different loggers at the same time.
-- Make it possible to easily replace a logger component with a new one. (for example Rails standard Logger with Fluentd)
-  without any changes in the consumer application. 
-- Creating easy to use logger interface.
-- Apply some rules and restrictions about log structure and data format, which prevents chaos in application log information.
-- No interrupt or wait time for log consumer modules.
+- Wrapping around existing loggers to get advantage of different loggers at the same time.
+- Make it possible to easily replace a logger component with new one without any changes in the consumer application.(for example Rails standard Logger with Fluentd)
+- Creating easy to use logger interface for developers.
+- Apply some rules and restrictions about log structure and data format, which prevents chaos in application's log information.
+- No interrupt, wait time or overhead for log consumer modules.
 - Utilize multiple log repositories at the same time in background (Console, File, UDP, FluentD, etc.) 
-- Make it possible to implement customized log repositories.
+- Make it possible to implement customize log repositories.
 
 Main Features:
 - Creating multiple log manager instances with different configuration is possible entire application.
 - Each log manager instance could be configured via a json file.
 - Each log manager instance could be config to use multiple log repositories such as Console, File, UDP, Fluentd.
 - Runtime configurations could be applied through log manager APIs.
-- By using multi threading techniques and also buffering techniques, 
-  all logging process will handled in seperated thread.
+- By using multi threading and buffering techniques, all logging process will handled in seperated thread.
   So the log consumer modules should not be wait for log manager to finish the logging task.
 - Multiple standard log severity levels are available through topic APIs (debug, info, warning, error, fatal, unknown)
 - Main features could be set and manipulate through json configuration file.
-- And at the end, it is easy to use for ruby backend developers. 
+- And at the end, it is easy to use for ruby developers. 
 
 ## Installation
 
@@ -36,11 +34,11 @@ Add this line to your application's Gemfile:
 gem 'RTALogger'
 ```
 
-And then execute:
+Then execute:
 
     $ bundle install
 
-Or install it yourself as:
+Or install it yourself via following command:
 
     $ gem install RTALogger
 
@@ -51,21 +49,22 @@ To add gem to your rails application:
 ## Usage
 #### RTA Log Data Structure
 To use log manager APIs, first step is to have a quick review on Log Data Structure
-- Application: The root of each log data record is Application, which specify the log data owner application.
+- Application: The root of each log data record is the Application name, which specify the log data owner application.
 - Topic: By adding multiple topics to log manager you can categorize log data in logical topics.
 - Context: Under each topic, one or multiple contexts (in one level) could be defined. 
-- As an instance the Application could by 'MyEShopApp', one of Topics could be 'Authentication' and 
-  Contexts could be 'uer_name' which attend in application authorization process.
-- The next step is log severity level, which determines that the log record severity (debug, information, warning, error, fatal, unknown)
+- As an instance for Application 'MyEShopApp', one of Topics could be 'Authentication' and 
+  Context could be 'uer_name' which attend in application authorization process.
+- The next step is log severity level, which determines the log record severity (debug, information, warning, error, fatal, unknown)
 - At last the final element is log message, which contains log message data.
 
 ### Which Log Severity Levels to use
-- DEBUG = 0 : Low-level information, mostly for developers.
-- INFO = 1 : Generic (useful) information about system operation.
-- WARN = 2 : A warning, which it does NOT cause crashing the process.
-- ERROR = 3 : A handleable error condition.
-- FATAL = 4 : An un-handleable error that results in a program crash.
-- UNKNOWN = 5 : An unknown message that should always be logged.
+- TRACE = 0 : all information that helps us to trace the processing of an incoming request through our application.
+- DEBUG = 1  : Low-level information, mostly for developers.
+- INFO = 2 : Generic (useful) information about system operation.
+- WARN = 3 : A warning, which it does NOT cause crashing the process.
+- ERROR = 4 : A handleable error condition.
+- FATAL = 5 : An un-handleable error that results in a program crash.
+- UNKNOWN = 6 : An unknown message that should always be logged.
     
 ### Time for coding
 - create log manager instance:
@@ -88,41 +87,61 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
   {
     "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"
-                    }
-                  ]
-        }
-      ]
+    [
+      {
+        "title": "develop",
+        "enable": true,
+        "app_name": "TestApp",
+        "severity_level": "trace",
+        "buffer_size": 100,
+        "flush_wait_seconds": 10,
+        "repositories":
+        [
+          {
+            "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
+          },
+          {
+            "type": "file",
+            "title": "file_repo_1",
+            "enable": true,
+            "file_path": "log.txt",
+            "roll_period": "daily",
+            "roll_size": "1048576",
+            "formatter":
+            {
+              "type": "json",
+              "delimiter": "|"
+            }
+          },
+          {
+            "enable": true,
+            "title": "console_repo_1",
+            "type": "fluentd",
+            "host": "localhost",
+            "port": "8888",
+            "formatter":
+            {
+              "type": "json"
+            }
+          }
+        ],
+        "topics":
+        [
+          {
+            "title": "test",
+            "enable": true,
+            "severity_level": "WARN"
+          }
+        ]
+      }
+    ]
   }
 }
 ``` 
@@ -138,21 +157,25 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
     # Assume user 'Tom' is trying to authenticate we will use user_name as log Context_id
     user_name = 'Tom'
     topic = log_manager.add_topic('Authentication')
+    topic.trace(user_name, 'Authentication process began for:', user_name)
     topic.debug(user_name, 'use_id is nil for user:', user_name)
     topic.info(user_name, 'User ', user_name , ' is trying to login.')
     topic.warning(user_name, 'Authentication failed for user ', user_name)
     topic.error(user_name, 'Error connecting to data base for user ', user_name)
     topic.fatal(user_name, 'Authentication service has been stopped working')
     topic.unknown(user_name, 'An unknown error occured during authentication. user name:', user_name)
+    topic.trace(user_name, 'Authentication process end for:', user_name)
 ```
 the result will be:
 ```
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":0,"message":"user_id is nil for user: Tom"}
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":1,"message":"User Tom is trying to login"}
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":2,"message":"Authentication failed for user Tom"}
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":3,"message":"Error connecting to data base for user Tom"}
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":4,"message":"Authentication service has been stopped working"}
-    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":5,"message":"An unknown error occured during authentication. user name: Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"TRACE","message"Authentication process began for: Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"DEBUG","message":"user_id is nil for user: Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"INFO","message":"User Tom is trying to login"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"WARN","message":"Authentication failed for user Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"ERROR","message":"Error connecting to data base for user Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"FATAL","message":"Authentication service has been stopped working"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"UNKNOWN","message":"An unknown error occured during authentication. user name: Tom"}
+    {"occurred_at":"2020-11-04 15:56:58:785","app_name":"TestApp","topic_title":"Authentication","context_id":"Tom","severity":"TRACE","message"Authentication process end for: Tom"}
 ```
 - json config file sample
 ```json
@@ -163,17 +186,18 @@ the result will be:
     "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,
-        "repos":
+        "flush_wait_seconds": 10,
+        "repositories":
         [
           {
-            "enable": true,
             "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
             "formatter":
             {
               "type": "text",
@@ -181,19 +205,21 @@ the result will be:
             }
           },
           {
-            "enable": false,
             "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": false,
+            "enable": true,
+            "title": "console_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",
@@ -208,7 +234,7 @@ the result will be:
           {
             "title": "test",
             "enable": true,
-            "severity_level": "info"
+            "severity_level": "WARN"
           }
         ]
       }
@@ -216,7 +242,7 @@ the result will be:
   }
 }
 ```
-- json config file structure 
+### json config file structure 
 ```comment
   As we described you cap apply RTA log manager using a json config file.
   
@@ -228,16 +254,16 @@ the result will be:
       multiple log manager configuration in Log_Managers array.
     - log_managers : the array of LogManagers with different configuration.
       It is possible to define multiple log manager configurations for differen usages.
-      - manager_name: the name of log manager. It will be used to define the default log manager.
+      - title: 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 
+      - buffer_size: Minimune possible value for this attribute is 100 and defines 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: Minimum possible value for this attribure is 10 seconds and defines time in soconds which log managers wait to flush buffered log records
         to log repository.
-      - repos: Array of log repositories. It is possible to define multiple log repositories to
+      - repositories: 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 
@@ -282,7 +308,7 @@ the result will be:
           - 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
+###Some useful features
 ```ruby
     # change log manager app name at run time
     log_manager.app_name = 'myTestApp'
@@ -298,8 +324,32 @@ the result will be:
 
     # enable or disable all topic if necessary
     log_manager.update_all_topics_enable([true/false])
+
+    # to get log manager configuration as json object use to_builder method
+    log_manager.to_builder
+    
+    # to get log manager configuration as json string use reveal_config method
+    log_manager.reveal_config
+    
+    # to apply some limited changes on log manager functionality at run time
+    # config_json parameter should carry a json object which contains the configuration
+    # structure described before in 'json configuration file structure' section.
+    # Attention: these changes will apply to manager but will not save. 
+    # So during next load these changes will be lost. Save changes will be available in
+    # next version.
+    # Attention: only following attributes could be change at run time:
+    # log_manager.enable
+    # log_manager.default_severity_level    
+    # log_manager.buffer_size (minimum is 100)
+    # log_manager.flush_wait_time (minimum 15 second)
+    # repository.enable
+    # topic.enable
+    # topic.severity_level
+    # Other attributes could only change via config file via manager config_use_json_file 
+    log_manager.apply_run_time_config(config_json) 
 ```
-- Implement and Expand
+### Implement and Expand
+#### Implement new log repository
   It is possible to implement new log repositories. There will be fue rules to implement and
   integrate new customized log repository with RTALogger LogManager.
   
@@ -309,7 +359,7 @@ the result will be:
   
   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
+     your source code should be placed 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
@@ -346,17 +396,10 @@ module RTALogger
 end
 ```
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/BBahrainy/RTALogger.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/RTALogger/version.rb

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

data/lib/log_factory_log_formatter.rb

@@ -1,3 +1,5 @@
+require_relative 'log_formatter_base'
+
 module RTALogger
   # Log factory to get new instance of log formatter
   module LogFactory
@@ -8,7 +10,6 @@ module RTALogger
     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
@@ -30,6 +31,6 @@ module RTALogger
     end
 
     @log_formatters = {:text => 'log_formatter_text.rb',
-                          :json =>  'log_formatter_json.rb'}
+                       :json =>  'log_formatter_json.rb'}
   end
 end

data/lib/log_factory_repository.rb

@@ -32,6 +32,6 @@ module RTALogger
     @log_repositories = {:console => 'log_repository_console.rb',
                           :file =>  'log_repository_file.rb',
                           :udp =>  'log_repository_upd.rb',
-                          :fluentd => 'log_repository_fluetnd.rb'}
+                          :fluentd => 'log_repository_fluentd.rb'}
   end
 end

data/lib/log_formatter_base.rb

@@ -0,0 +1,33 @@
+require 'jbuilder'
+require_relative 'string'
+
+module RTALogger
+  class LogFormatterBase
+    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
+
+    def to_builder
+      jb = Jbuilder.new do |json|
+        json.type self.class.to_s.split('::').last.underscore.sub('log_formatter_', '')
+        json.delimiter delimiter
+      end
+
+      jb
+    end
+
+    def reveal_config
+      to_builder.target!
+    end
+  end
+end

data/lib/log_formatter_json.rb

@@ -1,10 +1,13 @@
 require 'jbuilder'
-require_relative 'log_formatter'
+require_relative 'log_formatter_base'
+require_relative 'severity_level'
 
 module RTALogger
   # json formatter which receive log_record and
   # returns it's data as json string
-  class LogFormatterJson < LogFormatter
+  class LogFormatterJson < LogFormatterBase
+    include SeverityLevel
+
     def format(log_record)
       return '' unless log_record
 
@@ -13,7 +16,7 @@ module RTALogger
         json.app_name log_record.app_name
         json.topic_title log_record.topic_title
         json.context_id log_record.context_id
-        json.severity log_record.severity
+        json.severity parse_severity_level_to_s(log_record.severity)
         json.message log_record.message.flatten.join(' ')
       end
 

data/lib/log_formatter_text.rb

@@ -1,17 +1,20 @@
-require_relative 'log_formatter'
+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 < LogFormatter
+  class LogFormatterText < LogFormatterBase
+    include SeverityLevel
+
     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.context_id.to_s
+      result << @delimiter << parse_severity_level_to_s(log_record.severity)
       result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
 
       result

data/lib/log_manager.rb

@@ -20,15 +20,14 @@ module RTALogger
 
     def initialize
       @enable = true
-      @name = 'default_log_manager'
+      @title = 'default_log_manager'
       @app_name = ENV.fetch('RTA_LOGGER_APP_NAME', 'unknown_app')
-      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', WARN)
+      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', INFO)
       @config_file_name = ''
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
-      @buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
-      @flush_size = @buffer_size * 20 / 100
-      @flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
+      self.buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
+      self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -42,32 +41,45 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    attr_reader :name
+    attr_reader :title
     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)
+    def buffer_size
+      @buffer_size
+    end
+
+    def buffer_size=(size)
+      @buffer_size = size < 100 ? 100 : size
+      @flush_size = @buffer_size * 20 / 100
+    end
+
+    def flush_wait_time
+      @flush_wait_time
+    end
+
+    def flush_wait_time=(time_in_seconds)
+      @flush_wait_time = time_in_seconds < 10 ? 10 : time_in_seconds
+    end
+
+    def config_use_json_file(file_name, title = '')
+      config_json = load_config_from_json_file(file_name, title)
       @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.create_repository(:console))
     end
 
-    def config_use_json_string(config_string, manager_name = '')
-      config_json = load_config_from_json_string(config_string, manager_name)
+    def config_use_json_string(config_string,  title = '')
+      config_json = load_config_from_json_string(config_string, title)
       apply_config(config_json)
     rescue StandardError => e
-      puts e.message
       @propagator.drop_all_repositories
       @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
@@ -102,10 +114,22 @@ module RTALogger
       @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].severity_level = severity_level } }
     end
 
+    def topic_by_title(title)
+      result = nil
+      @topic_semaphore.synchronize do
+        @topics.keys.each do |topic_key|
+          result = @topics[topic_key.to_sym] if topic_key.to_s.casecmp(title).zero?
+          break if result
+        end
+      end
+
+      return result
+    end
+
     def to_builder
       @topic_semaphore.synchronize do
         jb = Jbuilder.new do |json|
-          json.name name
+          json.title title
           json.enable enable
           json.app_name app_name
           json.config_file_name config_file_name
@@ -113,6 +137,9 @@ module RTALogger
           json.buffer_size buffer_size
           json.flush_size flush_size
           json.flush_wait_time flush_wait_time
+          json.repositories do
+            json.array! @propagator.repositories.collect { |repository| repository.to_builder.attributes! }
+          end
           json.topics do
             json.array! topics.keys.collect { |topic_key| @topics[topic_key].to_builder.attributes! }
           end
@@ -126,33 +153,50 @@ module RTALogger
       to_builder.target!
     end
 
+    def apply_run_time_config(config_json)
+      return unless config_json
+      @enable = config_json['enable'] unless config_json['enable'].nil?
+      @default_severity_level = parse_severity_level_to_i(config_json['severity_level']) unless config_json['severity_level'].nil?
+      self.buffer_size = config_json['buffer_size'] unless config_json['buffer_size'].nil?
+      self.flush_wait_time = config_json['flush_wait_time'] unless config_json['flush_wait_time'].nil?
+      @propagator.apply_run_time_config(config_json)
+
+      if config_json['topics']
+        config_json['topics'].each do |topic_config|
+          next if topic_config['title'].nil?
+          topic = topic_by_title(topic_config['title'])
+          topic.apply_run_time_config(topic_config) if topic
+        end
+      end
+    end
+
     private
 
-    def load_config_from_json_file(config_file_name, manager_name = '')
+    def load_config_from_json_file(config_file_name, title = '')
       config_file = File.open config_file_name
       config_json = ::JSON.load(config_file)
-      config_json = extract_config(config_json, manager_name)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def load_config_from_json_string(config_string, manager_name = '')
+    def load_config_from_json_string(config_string, title = '')
       config_json = ::JSON.parse(config_string)
-      config_json = extract_config(config_json, manager_name)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def extract_config(json_data, manager_name = '')
+    def extract_config(json_data, title = '')
       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.empty?
-      unless manager_name.to_s.strip.empty?
-        config_json = config_json['log_managers'].find { |item| item['manager_name'] == manager_name }
+      title = config_json['default_manager'] if title.empty?
+      unless title.to_s.strip.empty?
+        config_json = config_json['log_managers'].find { |item| item['title'] == title }
       end
       config_json ||= config_json['log_managers'][0]
       raise 'Unable to extract RTA Log Manager configuration!' unless config_json
-      @name = manager_name if config_json
+      @title = title if config_json
       config_json
     end
 
@@ -161,15 +205,15 @@ module RTALogger
       @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']
+      self.buffer_size = config_json['buffer_size'] if config_json['buffer_size']
+      self.flush_wait_time = config_json['flush_wait_seconds'] if config_json['flush_wait_seconds']
       @propagator.drop_all_repositories
       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) }
+      config_json['repositories']&.each { |item| @propagator.load_log_repository(item) }
     end
 
     def apply_config_topics(config_json)
@@ -186,7 +230,7 @@ module RTALogger
       @flush_scheduler = Thread.new do
         loop do
           elapsed_seconds = ((DateTime.now - @last_flush_time) * 24 * 60 * 60).to_i
-          flush if elapsed_seconds > @flush_wait_time
+          flush if elapsed_seconds > flush_wait_time
           sleep(1)
           break if @exit_flush_scheduler
         end

data/lib/log_propagator.rb

@@ -5,17 +5,19 @@ module RTALogger
   class LogPropagator
     def initialize
       @semaphore = Mutex.new
-      @log_records = []
-      @log_repositories = []
+      @records = []
+      @repositories = []
     end
 
-    def add_log(log_record)
-      @semaphore.synchronize { @log_records.push(log_record.dup) }
+    attr_reader :repositories
+
+    def add_log(record)
+      @semaphore.synchronize { @records.push(record.dup) }
     end
 
-    def add_log_repository(log_repository)
-      return unless log_repository.is_a? RTALogger::LogRepository
-      @log_repositories.push(log_repository) unless @log_repositories.include?(log_repository)
+    def add_log_repository(repository)
+      return unless repository.is_a? RTALogger::LogRepository
+      @repositories.push(repository) unless @repositories.include?(repository)
     end
 
     def load_log_repository(config_json)
@@ -24,20 +26,44 @@ module RTALogger
       enable = config_json['enable'].nil? ? true : config_json['enable']
       return unless enable
 
-      log_repository = ::RTALogger::LogFactory.create_repository(type, config_json)
-      add_log_repository(log_repository)
+      repository = ::RTALogger::LogFactory.create_repository(type, config_json)
+      add_log_repository(repository)
     end
 
     def drop_all_repositories
-      @semaphore.synchronize { @log_repositories.clear }
+      @semaphore.synchronize { @repositories.clear }
+    end
+
+    def repository_by_title(title)
+      result = nil
+      @semaphore.synchronize do
+        @repositories.keys.each do |repository_key|
+          result = @repositories[repository_key.to_sym] if repository_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
+
+      if config_json['repositories']
+        config_json['repositories'].each do |repository_config|
+          next if repository_config['title'].nil?
+          repository = repository_by_title(repository_config['title'])
+          repository.apply_run_time_config(repository_config) if repository
+        end
+      end
     end
 
     def propagate
       @semaphore.synchronize do
-        @log_repositories.each do |log_repository|
-          log_repository.add_log_records(@log_records)
+        @repositories.each do |repository|
+          repository.add_log_records(@records)
         end
-        @log_records.clear
+        @records.clear
       end
     end
   end

data/lib/log_repository.rb

@@ -1,10 +1,14 @@
+require_relative 'string'
+
 module RTALogger
   # base log repository class
   class LogRepository
     def initialize
       @semaphore = Mutex.new
       @log_records = []
+      @title = self.class.to_s.split('::').last.underscore
       @enable = true
+      @formatter = RTALogger::LogFactory.log_formatter_default
     end
 
     # @@sub_classes = {}
@@ -22,7 +26,9 @@ 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
@@ -34,13 +40,32 @@ module RTALogger
 
     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
     end
 
+    def to_builder
+      jb = Jbuilder.new do |json|
+        json.type self.class.to_s.split('::').last.underscore.sub('log_repository_', '')
+        json.enable enable
+        json.formatter @formatter.to_builder.attributes!
+      end
+
+      jb
+    end
+
+    def reveal_config
+      to_builder.target!
+    end
+
+    def apply_run_time_config(config_json)
+      return unless config_json
+      @enable = config_json['enable'] unless config_json['enable'].nil?
+    end
+
     protected
 
     def flush_and_clear

data/lib/log_repository_console.rb

@@ -6,8 +6,6 @@ module RTALogger
   class LogRepositoryConsole < LogRepository
     def initialize
       super
-
-      @formatter = RTALogger::LogFactory.log_formatter_default
     end
 
     def load_config(config_json)

data/lib/log_repository_file.rb

@@ -7,8 +7,10 @@ module RTALogger
   class LogRepositoryFile < LogRepository
     def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
       super()
-      @file_logger = create_ruby_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)
@@ -20,6 +22,15 @@ module RTALogger
       @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

data/lib/{log_repository_fluent.rb → log_repository_fluentd.rb}

@@ -2,10 +2,11 @@ require 'fluent-logger'
 require_relative 'log_repository'
 
 module RTALogger
-  class LogRepositoryFluent < LogRepository
+  class LogRepositoryFluentd < LogRepository
     def initialize(host = 'localhost', port = 24224, tls_options = nil)
       super()
-      @formatter = RTALogger::LogFactory.log_formatter_json
+      @host = host
+      @port = port
       @fluent_logger = create_fluentd_logger(host, port, tls_options)
     end
 
@@ -19,6 +20,14 @@ module RTALogger
       @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

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,17 +5,18 @@
     "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,
-        "repos":
+        "flush_wait_seconds": 10,
+        "repositories":
         [
           {
-            "enable": true,
             "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
             "formatter":
             {
               "type": "text",
@@ -23,19 +24,21 @@
             }
           },
           {
-            "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,
+            "title": "console_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",

data/lib/sample.rb

@@ -4,7 +4,6 @@ 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
@@ -29,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')

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

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: 1.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-22 00:00:00.000000000 Z
+date: 2020-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger
@@ -74,7 +74,7 @@ files:
 - 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
@@ -83,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_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

data/lib/log_formatter.rb

@@ -1,18 +0,0 @@
-# Log Formatter base class
-module RTALogger
-  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
-  end
-end