RTALogger 0.1.1 → 1.1.0

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
 

data/lib/log_repository_console.rb

@@ -6,10 +6,14 @@ module RTALogger
   class LogRepositoryConsole < LogRepository
     def initialize
       super
+    end
 
-      @formatter = RTALogger::LogFactory.log_formatter_default
+    def load_config(config_json)
+      super
     end
 
+    # register :console
+
     protected
 
     def flush_and_clear

data/lib/log_repository_file.rb

@@ -1,6 +1,5 @@
 require 'logger'
 require_relative 'log_repository'
-require_relative 'log_factory_file_logger'
 require_relative 'log_factory_log_formatter'
 
 module RTALogger
@@ -8,12 +7,43 @@ module RTALogger
   class LogRepositoryFile < LogRepository
     def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
       super()
-      @file_logger = RTALogger::LogFactory.new_file_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)
+      super
+
+      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
+      @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
 
+    def create_ruby_logger(file_path, period, shift_size)
+      ruby_logger = Logger.new(file_path, period, shift_size)
+      ruby_logger.level = Logger::Severity::DEBUG
+      ruby_logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
+      ruby_logger
+    end
+
     def flush_and_clear
       semaphore.synchronize do
         @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }

data/lib/log_repository_fluentd.rb

@@ -0,0 +1,58 @@
+require 'fluent-logger'
+require_relative 'log_repository'
+
+module RTALogger
+  class LogRepositoryFluentd < LogRepository
+    def initialize(host = 'localhost', port = 24224, tls_options = nil)
+      super()
+      @host = host
+      @port = port
+      @fluent_logger = create_fluentd_logger(host, port, tls_options)
+    end
+
+    def load_config(config_json)
+      super
+
+      host = config_json['host'].to_s
+      port = config_json['port'].to_s
+      tls_options = config_json['tls_options']
+
+      @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
+
+    def create_fluentd_logger(host, port, tls_options)
+      unless tls_options
+        fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :use_nonblock => true, :wait_writeable => false)
+      else
+        fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :tls_options => tls_options, :use_nonblock => true, :wait_writeable => false)
+      end
+
+      fluent_logger
+    end
+
+    def flush_and_clear
+      semaphore.synchronize do
+        @log_records.each do |log_record|
+          fluent_tag = log_record.app_name + '.' + log_record.topic_title
+          log_json_string = @formatter.format(log_record)
+          log_json = JSON.parse(log_json_string)
+
+          @fluent_logger.post(fluent_tag, log_json)
+        end
+      end
+      super
+    end
+  end
+end

data/lib/log_repository_udp.rb

@@ -5,18 +5,26 @@ module RTALogger
   class LogRepositoryUDP < LogRepository
     def initialize(host = '127.0.0.1', port = 4913)
       super()
-      @host = host
-      @port = port
+      @udp_socket = UDPSocket.new
+      @udp_socket.bind(host, port)
     end
 
+    def load_config(config_json)
+      super
+
+      host = config_json['host'].to_s
+      port = config_json['port'].nil? ? 4913 : config_json['port'].to_i
+      @udp_socket = UDPSocket.new
+      @udp_socket.bind(host, port)
+    end
+
+    # register :udp
+
     protected
 
     def flush_and_clear
       semaphore.synchronize do
-        u1 = UDPSocket.new
-        u1.bind(@host, @port)
-        @log_records.each { |log_record| u1.send log_record.to_s, 0, @host, @port }
-        u1.close
+        @log_records.each { |log_record| @udp_socket.send @formatter.format(log_record), 0, @host, @port }
       end
       super
     end

data/lib/log_topic.rb

@@ -1,49 +1,59 @@
-require_relative 'log_severity'
+require_relative 'severity_level'
 require_relative 'log_factory_record'
+require 'jbuilder'
 
 module RTALogger
   # the main class to logging data as topic
   class LogTopic
-    include LogSeverity
+    include SeverityLevel
     include RTALogger::LogFactory
 
-    def initialize(log_manager, topic_title, log_level = WARN)
+    def initialize(log_manager, title, severity_level = WARN, enable = true)
       #  Logger logger = Logger.new(Logger::DEBUG)
-      @enable = true
+      @enable = enable
       @log_manager = log_manager
-      @topic_title = topic_title.to_s.dup
-      @log_level = log_level
+      @title = title.to_s.dup
+      @severity_level = severity_level
     end
 
     attr_accessor :enable
     attr_reader :log_manager
-    attr_reader :topic_title
-    attr_accessor :log_level
+    attr_reader :title
+    attr_accessor :severity_level
 
     def debug(context_id, *message)
-      add(context_id, DEBUG, message) if @log_level.to_i <= DEBUG.to_i
+      add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
     end
 
     def info(context_id, *message)
-      add(context_id, INFO, message) if @log_level.to_i <= INFO.to_i
+      add(context_id, INFO, message) if @severity_level.to_i <= INFO.to_i
     end
 
     def warning(context_id, *message)
-      add(context_id, WARN, message) if @log_level.to_i <= WARN.to_i
+      add(context_id, WARN, message) if @severity_level.to_i <= WARN.to_i
     end
 
     def error(context_id, *message)
-      add(context_id, ERROR, message) if @log_level.to_i <= ERROR.to_i
+      add(context_id, ERROR, message) if @severity_level.to_i <= ERROR.to_i
     end
 
     def fatal(context_id, *message)
-      add(context_id, FATAL, message) if @log_level.to_i <= FATAL.to_i
+      add(context_id, FATAL, message) if @severity_level.to_i <= FATAL.to_i
     end
 
     def unknown(context_id, *message)
-      add(context_id, UNKNOWN, message) if @log_level.to_i <= UNKNOWN.to_i
+      add(context_id, UNKNOWN, message) if @severity_level.to_i <= UNKNOWN.to_i
     end
 
+    def to_builder
+      jb = Jbuilder.new do |json|
+        json.title title
+        json.severity_level parse_severity_level_to_s(severity_level)
+        json.enable enable
+      end
+
+      jb
+    end
     private
 
     def add(context_id, severity, *message)

data/lib/rta_logger_config.json

@@ -1,29 +1,56 @@
 {
-  "RTALogger":
+  "rta_logger":
   {
-    "Default_Manager": "Develop",
-    "Log_Managers":
+    "default_manager": "develop",
+    "log_managers":
     [
       {
-        "Manager_Name": "Develop",
-        "Enable": true,
-        "App_Name": "TestApp",
-        "Log_Severity": 2,
-        "Buffer_Size": 100,
-        "Flush_Wait_Seconds": 15,
-        "Formatter" : "JSON",
-        "Repos":
+        "manager_name": "develop",
+        "enable": true,
+        "app_name": "TestApp",
+        "severity_level": "debug",
+        "buffer_size": 100,
+        "flush_wait_seconds": 15,
+        "repositories":
         [
           {
-            "Enable": true,
-            "Type": "Console"
+            "enable": true,
+            "type": "console",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
           },
           {
-            "Enable": false,
-            "Type": "File",
-            "File_Path": "../../log/log.txt",
-            "Roll_Period": "daily",
-            "Roll_Size": "1048576"
+            "enable": true,
+            "type": "file",
+            "file_path": "log.txt",
+            "roll_period": "daily",
+            "roll_size": "1048576",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
+          },
+          {
+            "enable": true,
+            "type": "fluentd",
+            "host": "localhost",
+            "port": "8888",
+            "formatter":
+            {
+              "type": "json"
+            }
+          }
+        ],
+        "topics":
+        [
+          {
+            "title": "test",
+            "enable": true,
+            "severity_level": "WARN"
           }
         ]
       }

data/lib/sample.rb

@@ -4,6 +4,8 @@ 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
 # this could be a global variable declared in application level
 log_manager = RTALogger::LogFactory.log_manager_instance
@@ -21,6 +23,9 @@ log_manager.config_use_json_file('rta_logger_config.json')
 # use this api to get a new log topic instance
 # this api could be called in entry point of each service or class initialize method
 topic = log_manager.add_topic(controller_name)
+test_topic = log_manager.add_topic('test')
+# test_topic.severity_level = ::RTALogger::SeverityLevel::FATAL
+# test_topic.enable = false
 
 # add log information to log topic
 topic.debug(userID, 'Controller Name=', controller_name, 'debug')
@@ -30,8 +35,13 @@ topic.error(userID, 'Controller Name=', controller_name, 'error')
 topic.fatal(userID, 'Controller Name=', controller_name, 'fatal')
 topic.unknown(userID, 'Controller Name=', controller_name, 'unknown')
 
+test_topic.error(userID, 'test_topic', 'error')
+test_topic.fatal(userID, 'test_topic', 'fatal')
+
+puts log_manager.reveal_config
+
 # update specific topic log level if necessary
-# log_manager.update_topic_level(controller_name, RTALogger::LogSeverity::INFO)
+# log_manager.update_topic_level(controller_name, RTALogger::SeverityLevel::INFO)
 
 # update all topics log level if necessary
-# log_manager.update_all_topics_log_level(RTALogger::LogSeverity::INFO)
+# log_manager.update_all_topics_severity_level(RTALogger::SeverityLevel::INFO)