RTALogger 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b037c1dbb6f51228afd43cfc7e576e86a7e46e711b96cedaaeb9a5b3e5f3f1ec
-  data.tar.gz: d1e2fb9ee4cddf0b221b0ec9c471117953387c502337e3d438b82348ce4111ae
+  metadata.gz: '09e2fc76df63cc28bd810dd7632c40e1fb7401a98ac21f3f9b837139a9a0c7a5'
+  data.tar.gz: 267c71efd35367fa4e70cdff396d7f9d0e9443c78963368db19b06da1cd61f07
 SHA512:
-  metadata.gz: 1fe26e02fcdb17eb44f56644469f7061a925f5dfdc25afcde968b1d910eb5f25a13a49e25afeec8898e78eb7398bbcabe53fca3b7ca98dc85afdeae304ba12a0
-  data.tar.gz: 11fdcff4f789f1eb739cd307c9f60c52b7f6a2816caa60699b0d1f607fba0a3cf7619e58dd17d6817b4711ba35f4998585e64a8d0f099142f8c3009210220759
+  metadata.gz: 9dfec223a98f1ccdaaf7c569179630698cb94d67d1554a403d5e06833dcbf90677fd1dee37aeec0c732afa9c23e931abee54cf2335f1f78b910b35593b42e1d3
+  data.tar.gz: 602f91b5eb2ef9b764a963727c9177e6e5ff62d8ff21d52745816b00bdd13173bdbfe40f33e3eca7374f50ca3b7e6f84809a4efbc4af70ec0247de6b2cf78b1d

data/Gemfile.lock

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

data/README.md

@@ -58,12 +58,13 @@ To use log manager APIs, first step is to have a quick review on Log Data Struct
 - 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:
@@ -86,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,
-          "repositories":
-                  [
-                    {
-                      "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"
+          }
+        ]
+      }
+    ]
   }
 }
 ``` 
@@ -136,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":"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
@@ -161,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,
+        "flush_wait_seconds": 10,
         "repositories":
         [
           {
-            "enable": true,
             "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
             "formatter":
             {
               "type": "text",
@@ -179,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",
@@ -206,7 +234,7 @@ the result will be:
           {
             "title": "test",
             "enable": true,
-            "severity_level": "info"
+            "severity_level": "WARN"
           }
         ]
       }
@@ -214,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.
   
@@ -226,7 +254,7 @@ 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.
@@ -280,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'
@@ -296,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.
   
@@ -307,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
@@ -344,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.1.1'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/log_manager.rb

@@ -20,14 +20,13 @@ 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
       self.buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
-      @flush_size = @buffer_size * 20 / 100
       self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
@@ -42,7 +41,7 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    attr_reader :name
+    attr_reader :title
     attr_accessor :enable
     attr_accessor :app_name
     attr_reader :propagator
@@ -57,6 +56,7 @@ module RTALogger
 
     def buffer_size=(size)
       @buffer_size = size < 100 ? 100 : size
+      @flush_size = @buffer_size * 20 / 100
     end
 
     def flush_wait_time
@@ -67,8 +67,8 @@ module RTALogger
       @flush_wait_time = time_in_seconds < 10 ? 10 : time_in_seconds
     end
 
-    def config_use_json_file(file_name, manager_name = '')
-      config_json = load_config_from_json_file(file_name, manager_name)
+    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
@@ -76,8 +76,8 @@ module RTALogger
       @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
       @propagator.drop_all_repositories
@@ -114,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.each do |topic|
+          result = topic if topic.title.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
@@ -141,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
 

data/lib/log_propagator.rb

@@ -34,6 +34,30 @@ module RTALogger
       @semaphore.synchronize { @repositories.clear }
     end
 
+    def repository_by_title(title)
+      result = nil
+      @semaphore.synchronize do
+        @repositories.each do |repository|
+          result = repository if repository.title.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
         @repositories.each do |repository|

data/lib/log_repository.rb

@@ -6,6 +6,7 @@ module RTALogger
     def initialize
       @semaphore = Mutex.new
       @log_records = []
+      @title = self.class.to_s.split('::').last.underscore
       @enable = true
       @formatter = RTALogger::LogFactory.log_formatter_default
     end
@@ -25,6 +26,7 @@ module RTALogger
     #   @@sub_classes[repository_name] = self
     # end
 
+    attr_accessor :title
     attr_accessor :enable
     attr_accessor :formatter
 
@@ -38,7 +40,7 @@ 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)
@@ -59,6 +61,11 @@ module RTALogger
       to_builder.target!
     end
 
+    def appy_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_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 appy_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": 10,
         "repositories":
         [
           {
-            "enable": true,
             "type": "console",
+            "title": "console_repo_1",
+            "enable": true,
             "formatter":
             {
               "type": "text",
@@ -23,8 +24,9 @@
             }
           },
           {
-            "enable": true,
             "type": "file",
+            "title": "file_repo_1",
+            "enable": true,
             "file_path": "log.txt",
             "roll_period": "daily",
             "roll_size": "1048576",
@@ -36,6 +38,7 @@
           },
           {
             "enable": true,
+            "title": "console_repo_1",
             "type": "fluentd",
             "host": "localhost",
             "port": "8888",

data/lib/sample.rb

@@ -28,6 +28,7 @@ test_topic = log_manager.add_topic('test')
 # test_topic.enable = false
 
 # add log information to log topic
+topic.trace(userID, 'Controller Name=', controller_name, 'trace')
 topic.debug(userID, 'Controller Name=', controller_name, 'debug')
 topic.info(userID, 'Controller Name=', controller_name, 'information')
 topic.warning(userID, 'Controller Name=', controller_name, 'warning')

data/lib/severity_level.rb

@@ -1,60 +1,68 @@
 module RTALogger
   # Logging severity.
   module SeverityLevel
+    # all information that helps us to trace the processing of an incoming request through our application
+    TRACE = 0
     # Low-level information, mostly for developers.
-    DEBUG = 0
+    DEBUG = 1
     # Generic (useful) information about system operation.
-    INFO = 1
+    INFO = 2
     # A warning.
-    WARN = 2
+    WARN = 3
     # A handleable error condition.
-    ERROR = 3
+    ERROR = 4
     # An un-handleable error that results in a program crash.
-    FATAL = 4
+    FATAL = 5
     # An unknown message that should always be logged.
-    UNKNOWN = 5
+    UNKNOWN = 6
 
 
     def parse_severity_level_to_i(severity_level)
       return severity_level if severity_level.is_a? ::Integer
 
       case severity_level.upcase
-      when 'DEBUG'
+      when 'TRACE'
         0
-      when 'INFO'
+      when 'DEBUG'
         1
+      when 'INFO'
+        2
       when 'INFORMATIONّٔ'
-        1
-      when 'WARN'
         2
+      when 'WARN'
+        3
       when 'WARNING'
-        2
+        5
       when 'ERROR'
-        3
-      when 'FATAL'
         4
-      when 'UNKNOWN'
+      when 'FATAL'
         5
+      when 'UNKNOWN'
+        6
+      else
+        2
       end
-    end
+  end
 
-    def parse_severity_level_to_s(severity_level)
-      return severity_level if severity_level.is_a? ::String
+  def parse_severity_level_to_s(severity_level)
+    return severity_level if severity_level.is_a? ::String
 
-      case severity_level.to_i
-      when 0
-        'DEBUG'
-      when 1
-        'INFO'
-      when 2
-        'WARN'
-      when 3
-        'ERROR'
-      when 4
-        'FATAL'
-      when 5
-        'UNKNOWN'
-      end
+    case severity_level.to_i
+    when 0
+      'TRACE'
+    when 1
+      'DEBUG'
+    when 2
+      'INFO'
+    when 3
+      'WARN'
+    when 4
+      'ERROR'
+    when 5
+      'FATAL'
+    when 6
+      'UNKNOWN'
     end
   end
 end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: RTALogger
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Babak Bahreini, RTA Backend Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-26 00:00:00.000000000 Z
+date: 2020-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluent-logger