RTALogger 0.1.0 → 1.0.0

data/RTALogger.gemspec

@@ -27,5 +27,6 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.add_dependency "fluentd", "~> 1.11", ">= 1.11.4"
+  spec.add_dependency "fluent-logger", "~> 0.9"
+  spec.add_dependency "jbuilder", "~> 2.10"
 end

data/lib/RTALogger.rb

@@ -1,6 +1,4 @@
-require "RTALogger/version"
-
+require 'RTALogger/version'
+# main namespace of the log manager
 module RTALogger
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/RTALogger/version.rb

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

data/lib/log_factory_log_formatter.rb

@@ -0,0 +1,35 @@
+module RTALogger
+  # Log factory to get new instance of log formatter
+  module LogFactory
+    def self.log_formatter_default
+      create_formatter(:json)
+    end
+
+    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.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/{factory/origin/log_factory_manager.rb → log_factory_manager.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../log_manager'
+require_relative 'log_manager'
 
 module RTALogger
   # this module generates object instance
@@ -8,7 +8,5 @@ module RTALogger
     def self.log_manager_instance
       RTALogger::LogManager.instance
     end
-
-
   end
 end

data/lib/{factory/origin/log_factory_propagator.rb → log_factory_propagator.rb}

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../log_propagator'
-#require_relative './log_repository_console'
+require_relative 'log_propagator'
 
 module RTALogger
   # this module generates object instance

data/lib/{factory/origin/log_factory_record.rb → log_factory_record.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../log_record'
+require_relative 'log_record'
 
 module RTALogger
   # this module generates object instance

data/lib/log_factory_repository.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    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?
+
+      begin
+        load lib_file
+      rescue
+        raise "unable to load repository class file: #{lib_file}"
+      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
+
+      # 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.register_log_repository(type, class_file_name)
+      @log_repositories[type.to_sym] = class_file_name
+    end
+
+    @log_repositories = {:console => 'log_repository_console.rb',
+                          :file =>  'log_repository_file.rb',
+                          :udp =>  'log_repository_upd.rb',
+                          :fluentd => 'log_repository_fluetnd.rb'}
+  end
+end

data/lib/log_factory_topic.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'log_topic'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_log_topic(log_manager, title, level = WARN, enable = true)
+      LogTopic.new(log_manager, title, level, enable)
+    end
+  end
+end

data/lib/log_formatter.rb

@@ -1,8 +1,18 @@
+# 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
-

data/lib/log_formatter_json.rb

@@ -2,12 +2,14 @@ require 'jbuilder'
 require_relative 'log_formatter'
 
 module RTALogger
-  class LogFormatterJSON
+  # json formatter which receive log_record and
+  # returns it's data as json string
+  class LogFormatterJson < LogFormatter
     def format(log_record)
       return '' unless log_record
 
       jb = Jbuilder.new do |json|
-        json.occurred_at log_record.occurred_at.strftime("%F %H:%M:%S:%3N")
+        json.occurred_at log_record.occurred_at.strftime('%F %H:%M:%S:%3N')
         json.app_name log_record.app_name
         json.topic_title log_record.topic_title
         json.context_id log_record.context_id

data/lib/log_formatter_text.rb

@@ -1,16 +1,18 @@
 require_relative 'log_formatter'
 
 module RTALogger
+  # text formatter which receive log_record and
+  # returns it's data as delimited text string
   class LogFormatterText < LogFormatter
     def format(log_record)
       return '' unless log_record
 
-      result = log_record.occurred_at.strftime("%F %H:%M:%S:%3N")
-      result << '|' << log_record.app_name
-      result << '|' << log_record.topic_title
-      result << '|' << log_record.context_id
-      result << '|' << log_record.severity
-      result << '|' << log_record.message.join(' ').gsub('|' , '$<$')
+      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
     end

data/lib/log_manager.rb

@@ -1,28 +1,34 @@
 require 'date'
 require 'thread'
 require 'singleton'
-require_relative 'factory/origin/log_factory_propagator'
-require_relative 'factory/origin/log_factory_repository'
-require_relative 'factory/origin/log_factory_topic'
-require_relative './log_severity'
+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 'severity_level'
+require 'jbuilder'
 
 # the module will contain all logger requirements
 module RTALogger
   # the class is the main class
   class LogManager
     include Singleton
-    include LogSeverity
+    include SeverityLevel
     include RTALogger::LogFactory
 
     def initialize
       @enable = true
-      @app_name = ENV.fetch('RTALogger_App_Name', 'unknownApp')
-      @default_log_level = ENV.fetch('RTALogger_Log_Severity', ::RTALogger::LogSeverity::WARN)
+      @name = 'default_log_manager'
+      @app_name = ENV.fetch('RTA_LOGGER_APP_NAME', 'unknown_app')
+      @severity_level = ENV.fetch('RTA_LOGGER_SEVERITY_LEVEL', WARN)
+      @config_file_name = ''
       @topic_semaphore = Mutex.new
       @log_semaphore = Mutex.new
-      @buffer_size = ENV.fetch('RTALogger_Buffer_Size', 100)
+      @buffer_size = ENV.fetch('RTA_LOGGER_BUFFER_SIZE', 100)
       @flush_size = @buffer_size * 20 / 100
-      @flush_wait_time = ENV.fetch('RTALogger_Flush_Wait_Seconds', 15)
+      @flush_wait_time = ENV.fetch('RTA_LOGGER_FLUSH_WAIT_SECONDS', 15)
       @topics = {}
       @log_records = []
       @propagator = LogFactory.new_log_propagator
@@ -36,33 +42,42 @@ module RTALogger
       @flush_scheduler.run
     end
 
-    def config(config_file_name)
-      config_json = load_config_from_file(config_file_name)
-      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?
-      @propagator.drop_all_repositories
-      config_json['Repos']&.each { |item| @propagator.load_log_repository(item) }
+    attr_reader :name
+    attr_accessor :enable
+    attr_accessor :app_name
+    attr_reader :propagator
+    attr_accessor :default_severity_level
+    attr_accessor :buffer_size
+    attr_reader :flush_size
+    attr_accessor :flush_wait_time
+    attr_reader :topics
+    attr_reader :config_file_name
+
+    def config_use_json_file(file_name, manager_name = '')
+      config_json = load_config_from_json_file(file_name, manager_name)
+      @config_file_name = file_name if config_json
+      apply_config(config_json)
     rescue StandardError => e
       puts e.message
       @propagator.drop_all_repositories
-      @propagator.add_log_repository(LogFactory.new_log_repository_console)
+      @propagator.add_log_repository(LogFactory.create_repository(:console))
     end
 
-    attr_accessor :enable
-    attr_accessor :app_name
-    attr_reader :propagator
+    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.create_repository(:console))
+    end
 
-    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)
@@ -71,32 +86,102 @@ module RTALogger
       check_for_flush
     end
 
-    def update_topic_log_level(topic, log_level = WARN)
-      @topic_semaphore.synchronize { @topics[topic].log_level = log_level if @topics[topic] }
+    def update_topic_enable(topic, enable = true)
+      @topic_semaphore.synchronize { @topics[topic.to_sym].enable = enable if @topics[topic.to_sym] }
+    end
+
+    def update_all_topics_enable(enable = true)
+      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].enable = enable } }
+    end
+
+    def update_topic_severity_level(topic, severity_level = WARN)
+      @topic_semaphore.synchronize { @topics[topic.to_sym].severity_level = severity_level if @topics[topic.to_sym] }
     end
 
-    def update_all_topics_log_level(log_level = WARN)
-      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].log_level = log_level } }
+    def update_all_topics_severity_level(severity_level = WARN)
+      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].severity_level = severity_level } }
+    end
+
+    def to_builder
+      @topic_semaphore.synchronize do
+        jb = Jbuilder.new do |json|
+          json.name name
+          json.enable enable
+          json.app_name app_name
+          json.config_file_name config_file_name
+          json.default_severity_level default_severity_level
+          json.buffer_size buffer_size
+          json.flush_size flush_size
+          json.flush_wait_time flush_wait_time
+          json.topics do
+            json.array! topics.keys.collect { |topic_key| @topics[topic_key].to_builder.attributes! }
+          end
+        end
+
+        jb
+      end
+    end
+
+    def reveal_config
+      to_builder.target!
     end
 
     private
 
-    def load_config_from_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 = config_json['RTALogger']
+      config_json = ::JSON.load(config_file)
+      config_json = extract_config(config_json, manager_name)
+      config_json
+    end
+
+    def load_config_from_json_string(config_string, manager_name = '')
+      config_json = ::JSON.parse(config_string)
+      config_json = extract_config(config_json, manager_name)
+      config_json
+    end
+
+    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'] unless config_json['app_name'].empty?
+      @default_severity_level = parse_severity_level_to_i(config_json['severity_level']) if config_json['severity_level']
+      @buffer_size = config_json['buffer_size'] if config_json['buffer_size']
+      @flush_wait_time = config_json['flush_wait_seconds'] if config_json['flush_wait_seconds']
+      @propagator.drop_all_repositories
+      apply_config_repos(config_json)
+      apply_config_topics(config_json)
+    end
+
+    def apply_config_repos(config_json)
+      config_json['repos']&.each { |item| @propagator.load_log_repository(item) }
+    end
+
+    def apply_config_topics(config_json)
+      config_json['topics']&.each do |topic|
+        next unless topic['title']
+        result_topic = add_topic(topic['title'])
+        next unless result_topic
+        result_topic.severity_level = parse_severity_level_to_i topic['severity_level'] if topic['severity_level']
+        result_topic.enable = topic['enable'] if topic['enable']
+      end
+    end
+
     def initialize_flush_scheduler
       @flush_scheduler = Thread.new do
         loop do
@@ -128,7 +213,7 @@ module RTALogger
 
     def flush_all
       @log_semaphore.synchronize do
-        @log_records[0...@log_records.count].each { |log|  propagate(log) }
+        @log_records[0...@log_records.count].each { |log| propagate(log) }
         @log_records.clear
       end
       @propagator.propagate
@@ -137,5 +222,6 @@ module RTALogger
     def propagate(log_record)
       @propagator.add_log(log_record)
     end
+
   end
 end

data/lib/log_propagator.rb

@@ -1,45 +1,44 @@
-require 'thread'
-require_relative './log_repository'
-
-module RTALogger
-  # propagate log records to multiple log repositories
-  class LogPropagator
-    def initialize
-      @semaphore = Mutex.new
-      @log_records = []
-      @log_repositories = []
-    end
-
-    def add_log(log_record)
-      @semaphore.synchronize { @log_records.push(log_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)
-    end
-
-    def load_log_repository(config_json)
-      type = config_json['Type']
-      return if type.to_s.strip.empty?
-      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)
-    end
-
-    def drop_all_repositories
-      @semaphore.synchronize { @log_repositories.clear }
-    end
-
-    def propagate
-      @semaphore.synchronize do
-        @log_repositories.each do |log_repository|
-          log_repository.add_log_records(@log_records)
-        end
-        @log_records.clear
-      end
-    end
-  end
-end
+require_relative 'log_repository'
+
+module RTALogger
+  # propagate log records to multiple log repositories
+  class LogPropagator
+    def initialize
+      @semaphore = Mutex.new
+      @log_records = []
+      @log_repositories = []
+    end
+
+    def add_log(log_record)
+      @semaphore.synchronize { @log_records.push(log_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)
+    end
+
+    def load_log_repository(config_json)
+      type = config_json['type']
+      return if type.to_s.strip.empty?
+      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)
+    end
+
+    def drop_all_repositories
+      @semaphore.synchronize { @log_repositories.clear }
+    end
+
+    def propagate
+      @semaphore.synchronize do
+        @log_repositories.each do |log_repository|
+          log_repository.add_log_records(@log_records)
+        end
+        @log_records.clear
+      end
+    end
+  end
+end