RTALogger 0.1.4 → 2.0.1

data/lib/RTALogger/version.rb

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

data/lib/log_factory_log_formatter.rb

@@ -1,20 +1,36 @@
-require_relative 'log_formatter_text'
-require_relative 'log_formatter_json'
+require_relative 'log_formatter_base'
 
 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_fluentd.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_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
+  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,18 +1,21 @@
-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
-    def format(log_record, delimiter = '|')
+  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.message.join(' ').gsub(delimiter, '$<$')
+      result << @delimiter << log_record.app_name
+      result << @delimiter << log_record.topic_title
+      result << @delimiter << log_record.context_id.to_s
+      result << @delimiter << parse_severity_level_to_s(log_record.severity)
+      result << @delimiter << log_record.message.join(' ').gsub(delimiter, '$<$')
 
       result
     end

data/lib/log_manager.rb

@@ -1,28 +1,33 @@
 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)
+      @title = 'default_log_manager'
+      @app_name = ENV.fetch('RTA_LOGGER_APP_NAME', 'unknown_app')
+      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', INFO)
+      @config_file_name = ''
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
-      @buffer_size = ENV.fetch('RTALogger_Buffer_Size', 100)
-      @flush_size = @buffer_size * 20 / 100
-      @flush_wait_time = ENV.fetch('RTALogger_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
@@ -36,36 +41,55 @@ 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 :title
+    attr_accessor :enable
+    attr_accessor :app_name
+    attr_reader :propagator
+    attr_accessor :default_severity_level
+    attr_reader :flush_size
+    attr_reader :topics
+    attr_reader :config_file_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.new_log_repository_console)
+      @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.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,59 +98,139 @@ 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_log_level(log_level = WARN)
-      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].log_level = log_level } }
+    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 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.title title
+          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.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
+        end
+
+        jb
+      end
+    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?
+      @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 = ::JSON.load(config_file)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def load_config_from_json_string(config_string, manager_name = '')
-      config_json = JSON.parse(config_string)
-      config_json = extract_config(config_json, manager_name)
+    def load_config_from_json_string(config_string, title = '')
+      config_json = ::JSON.parse(config_string)
+      config_json = extract_config(config_json, title)
       config_json
     end
 
-    def extract_config(json_data, manager_name = '')
-      config_json = json_data['RTALogger']
+    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.blank?
-      unless manager_name.to_s.strip.empty?
-        config_json = config_json['Log_Managers'].find { |item| item['Manager_Name'] == manager_name }
+      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?
+      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]
+      config_json ||= config_json['log_managers'][0]
       raise 'Unable to extract RTA Log Manager configuration!' unless config_json
+      @title = title 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']
+      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
-      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['repositories']&.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
       @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
@@ -153,7 +257,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 +266,6 @@ module RTALogger
     def propagate(log_record)
       @propagator.add_log(log_record)
     end
+
   end
 end