RTALogger 0.1.0 → 1.0.0

data/lib/log_record.rb

@@ -1,28 +1,27 @@
-require 'date'
-
-module RTALogger
-  # log data structure
-  class LogRecord
-    def initialize(log_topic, context_id, severity, *message)
-      @log_topic = log_topic
-      @context_id = context_id
-      @severity = severity
-      @message = message
-      @occurred_at = DateTime.now
-    end
-
-    attr_reader :context_id
-    attr_reader :severity
-    attr_reader :message
-    attr_reader :occurred_at
-
-    def app_name
-      @log_topic.log_manager.app_name
-    end
-
-    def topic_title
-      @log_topic.topic_title
-    end
-  end
-end
-
+require 'date'
+
+module RTALogger
+  # log data structure
+  class LogRecord
+    def initialize(log_topic, context_id, severity, *message)
+      @log_topic = log_topic
+      @context_id = context_id
+      @severity = severity
+      @message = message
+      @occurred_at = DateTime.now
+    end
+
+    attr_reader :context_id
+    attr_reader :severity
+    attr_reader :message
+    attr_reader :occurred_at
+
+    def app_name
+      @log_topic.log_manager.app_name
+    end
+
+    def topic_title
+      @log_topic.title
+    end
+  end
+end

data/lib/log_repository.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module RTALogger
   # base log repository class
   class LogRepository
@@ -9,6 +7,23 @@ module RTALogger
       @enable = true
     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
+
     def add_log_records(items)
       return 0 unless @enable
       @semaphore.synchronize do
@@ -17,7 +32,14 @@ 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
 
     protected
 
@@ -28,4 +50,4 @@ module RTALogger
     attr_reader :log_records
     attr_reader :semaphore
   end
-end
+end

data/lib/log_repository_console.rb

@@ -1,5 +1,5 @@
 require_relative 'log_repository'
-require_relative 'factory/origin/log_factory_log_formatter'
+require_relative 'log_factory_log_formatter'
 
 module RTALogger
   # show log items on console out put
@@ -7,9 +7,15 @@ module RTALogger
     def initialize
       super
 
-      @formatter = RTALogger::LogFactory::log_formatter_default
+      @formatter = RTALogger::LogFactory.log_formatter_default
     end
 
+    def load_config(config_json)
+      super
+    end
+
+    # register :console
+
     protected
 
     def flush_and_clear
@@ -18,6 +24,5 @@ module RTALogger
       end
       super
     end
-
   end
 end

data/lib/log_repository_file.rb

@@ -1,25 +1,43 @@
 require 'logger'
 require_relative 'log_repository'
-require_relative 'factory/origin/log_factory_file_logger'
-require_relative 'factory/origin/log_factory_log_formatter'
+require_relative 'log_factory_log_formatter'
 
 module RTALogger
   # show log items on console out put
   class LogRepositoryFile < LogRepository
-    def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1048576)
+    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_logger = create_ruby_logger(file_path, period, shift_size)
+      @formatter = RTALogger::LogFactory.log_formatter_default
     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
+
+    # 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)) }
       end
       super
     end
-
   end
 end

data/lib/log_repository_fluent.rb

@@ -0,0 +1,49 @@
+require 'fluent-logger'
+require_relative 'log_repository'
+
+module RTALogger
+  class LogRepositoryFluent < LogRepository
+    def initialize(host = 'localhost', port = 24224, tls_options = nil)
+      super()
+      @formatter = RTALogger::LogFactory.log_formatter_json
+      @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
+
+    # 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,21 +5,28 @@ 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
-
   end
 end

data/lib/log_topic.rb

@@ -1,51 +1,59 @@
-# topic
-
-require_relative './log_severity'
-require_relative 'factory/origin/log_factory_record'
+require_relative 'severity_level'
+require_relative 'log_factory_record'
+require 'jbuilder'
 
 module RTALogger
-  # the main class to logging data
+  # 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

@@ -0,0 +1,59 @@
+{
+  "rta_logger":
+  {
+    "default_manager": "develop",
+    "log_managers":
+    [
+      {
+        "manager_name": "develop",
+        "enable": true,
+        "app_name": "TestApp",
+        "severity_level": "debug",
+        "buffer_size": 100,
+        "flush_wait_seconds": 15,
+        "repos":
+        [
+          {
+            "enable": true,
+            "type": "console",
+            "formatter":
+            {
+              "type": "text",
+              "delimiter": "|"
+            }
+          },
+          {
+            "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

@@ -0,0 +1,48 @@
+require_relative 'log_factory_manager'
+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
+
+# set log manage application name (hard code)
+log_manager.app_name = 'myTestApp'
+
+# load log manager configuration from a json config file
+log_manager.config_use_json_file('rta_logger_config.json')
+
+# add log repository to log manager
+#log_manager.propagator.add_log_repository(RTALogger::LogFactory.new_log_repository_console)
+
+# add new topic to log manager
+# 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')
+topic.info(userID, 'Controller Name=', controller_name, 'information')
+topic.warning(userID, 'Controller Name=', controller_name, 'warning')
+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::SeverityLevel::INFO)
+
+# update all topics log level if necessary
+# log_manager.update_all_topics_severity_level(RTALogger::SeverityLevel::INFO)