RTALogger 0.1.2 → 1.1.1

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,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)
+      self.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)
+      self.flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -36,36 +42,54 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    def config_use_json_file(config_file_name)
-      config_json = load_config_from_json_file(config_file_name)
+    attr_reader :name
+    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
+    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, 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)
-      config_json = load_config_from_json_string(config_file_name)
+    def config_use_json_string(config_string, manager_name = '')
+      config_json = load_config_from_json_string(config_string, manager_name)
       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,110 @@ 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 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.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
 
     private
 
-    def load_config_from_json_file(config_file_name)
+    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 = extract_config(config_json)
+      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)
-      config_json = JSON.parse(config_string)
-      config_json = extract_config(config_json)
+    def load_config_from_json_string(config_string, manager_name = '')
+      config_json = ::JSON.parse(config_string)
+      config_json = extract_config(config_json, manager_name)
       config_json
     end
 
-    def extract_config(json_data)
-      config_json = json_data['RTALogger']
+    def extract_config(json_data, manager_name = '')
+      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']
+      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']
+      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 +228,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 +237,6 @@ module RTALogger
     def propagate(log_record)
       @propagator.add_log(log_record)
     end
+
   end
 end

data/lib/log_propagator.rb

@@ -5,39 +5,41 @@ 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)
-      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)
-      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 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_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

@@ -1,3 +1,5 @@
+require_relative 'string'
+
 module RTALogger
   # base log repository class
   class LogRepository
@@ -5,8 +7,27 @@ module RTALogger
       @semaphore = Mutex.new
       @log_records = []
       @enable = true
+      @formatter = RTALogger::LogFactory.log_formatter_default
     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
+    attr_accessor :formatter
+
     def add_log_records(items)
       return 0 unless @enable
       @semaphore.synchronize do
@@ -15,7 +36,28 @@ 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
+
+    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
 
     protected