RTALogger 0.1.4 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -5,39 +5,65 @@ module RTALogger
5
5
  class LogPropagator
6
6
  def initialize
7
7
  @semaphore = Mutex.new
8
- @log_records = []
9
- @log_repositories = []
8
+ @records = []
9
+ @repositories = []
10
10
  end
11
11
 
12
- def add_log(log_record)
13
- @semaphore.synchronize { @log_records.push(log_record.dup) }
12
+ attr_reader :repositories
13
+
14
+ def add_log(record)
15
+ @semaphore.synchronize { @records.push(record.dup) }
14
16
  end
15
17
 
16
- def add_log_repository(log_repository)
17
- return unless log_repository.is_a? RTALogger::LogRepository
18
- @log_repositories.push(log_repository) unless @log_repositories.include?(log_repository)
18
+ def add_log_repository(repository)
19
+ return unless repository.is_a? RTALogger::LogRepository
20
+ @repositories.push(repository) unless @repositories.include?(repository)
19
21
  end
20
22
 
21
23
  def load_log_repository(config_json)
22
- type = config_json['Type']
24
+ type = config_json['type']
23
25
  return if type.to_s.strip.empty?
24
- enable = config_json['Enable'].nil? ? true : config_json['Enable']
26
+ enable = config_json['enable'].nil? ? true : config_json['enable']
25
27
  return unless enable
26
28
 
27
- log_repository = ::RTALogger::LogFactory.create_repository(type, config_json)
28
- add_log_repository(log_repository)
29
+ repository = ::RTALogger::LogFactory.create_repository(type, config_json)
30
+ add_log_repository(repository)
29
31
  end
30
32
 
31
33
  def drop_all_repositories
32
- @semaphore.synchronize { @log_repositories.clear }
34
+ @semaphore.synchronize { @repositories.clear }
35
+ end
36
+
37
+ def repository_by_title(title)
38
+ result = nil
39
+ @semaphore.synchronize do
40
+ @repositories.keys.each do |repository_key|
41
+ result = @repositories[repository_key.to_sym] if repository_key.to_s.casecmp(title).zero?
42
+ break if result
43
+ end
44
+ end
45
+
46
+ return result
47
+ end
48
+
49
+ def apply_run_time_config(config_json)
50
+ return unless config_json
51
+
52
+ if config_json['repositories']
53
+ config_json['repositories'].each do |repository_config|
54
+ next if repository_config['title'].nil?
55
+ repository = repository_by_title(repository_config['title'])
56
+ repository.apply_run_time_config(repository_config) if repository
57
+ end
58
+ end
33
59
  end
34
60
 
35
61
  def propagate
36
62
  @semaphore.synchronize do
37
- @log_repositories.each do |log_repository|
38
- log_repository.add_log_records(@log_records)
63
+ @repositories.each do |repository|
64
+ repository.add_log_records(@records)
39
65
  end
40
- @log_records.clear
66
+ @records.clear
41
67
  end
42
68
  end
43
69
  end
@@ -21,7 +21,7 @@ module RTALogger
21
21
  end
22
22
 
23
23
  def topic_title
24
- @log_topic.topic_title
24
+ @log_topic.title
25
25
  end
26
26
  end
27
27
  end
@@ -1,12 +1,35 @@
1
+ require_relative 'string'
2
+
1
3
  module RTALogger
2
4
  # base log repository class
3
5
  class LogRepository
4
6
  def initialize
5
7
  @semaphore = Mutex.new
6
8
  @log_records = []
9
+ @title = self.class.to_s.split('::').last.underscore
7
10
  @enable = true
11
+ @formatter = RTALogger::LogFactory.log_formatter_default
8
12
  end
9
13
 
14
+ # @@sub_classes = {}
15
+
16
+ # def self.create type
17
+ # requested_class = @@sub_classes[type]
18
+ # if requested_class
19
+ # requested_class.new
20
+ # else
21
+ # raise "Bad log repository type: #{type}"
22
+ # end
23
+ # end
24
+ #
25
+ # def self.register repository_name
26
+ # @@sub_classes[repository_name] = self
27
+ # end
28
+
29
+ attr_accessor :title
30
+ attr_accessor :enable
31
+ attr_accessor :formatter
32
+
10
33
  def add_log_records(items)
11
34
  return 0 unless @enable
12
35
  @semaphore.synchronize do
@@ -15,7 +38,33 @@ module RTALogger
15
38
  flush_and_clear
16
39
  end
17
40
 
18
- attr_accessor :enable
41
+ def load_config(config_json)
42
+ @enable = config_json['enable'].nil? ? true : config_json['enable']
43
+ @title = config_json['title'].nil? ? self.class.to_s.split('::').last.underscore : config_json['title']
44
+ formatter_config = config_json['formatter']
45
+ if formatter_config && formatter_config['type']
46
+ @formatter = LogFactory.create_formatter(formatter_config['type'], formatter_config)
47
+ end
48
+ end
49
+
50
+ def to_builder
51
+ jb = Jbuilder.new do |json|
52
+ json.type self.class.to_s.split('::').last.underscore.sub('log_repository_', '')
53
+ json.enable enable
54
+ json.formatter @formatter.to_builder.attributes!
55
+ end
56
+
57
+ jb
58
+ end
59
+
60
+ def reveal_config
61
+ to_builder.target!
62
+ end
63
+
64
+ def appy_run_time_config(config_json)
65
+ return unless config_json
66
+ @enable = config_json['enable'] unless config_json['enable'].nil?
67
+ end
19
68
 
20
69
  protected
21
70
 
@@ -6,10 +6,14 @@ module RTALogger
6
6
  class LogRepositoryConsole < LogRepository
7
7
  def initialize
8
8
  super
9
+ end
9
10
 
10
- @formatter = RTALogger::LogFactory.log_formatter_default
11
+ def load_config(config_json)
12
+ super
11
13
  end
12
14
 
15
+ # register :console
16
+
13
17
  protected
14
18
 
15
19
  def flush_and_clear
@@ -1,6 +1,5 @@
1
1
  require 'logger'
2
2
  require_relative 'log_repository'
3
- require_relative 'log_factory_file_logger'
4
3
  require_relative 'log_factory_log_formatter'
5
4
 
6
5
  module RTALogger
@@ -8,12 +7,43 @@ module RTALogger
8
7
  class LogRepositoryFile < LogRepository
9
8
  def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1_048_576)
10
9
  super()
11
- @file_logger = RTALogger::LogFactory.new_file_logger(file_path, period, shift_size)
12
- @formatter = RTALogger::LogFactory.log_formatter_default
10
+ @file_path = file_path
11
+ @period = period
12
+ @shift_size = shift_size
13
+ @file_logger = create_ruby_logger(@file_path, @period, @shift_size)
13
14
  end
14
15
 
16
+ def load_config(config_json)
17
+ super
18
+
19
+ file_path = config_json['file_path'].to_s
20
+ period = config_json['roll_period'].to_s
21
+ shift_size = config_json['roll_size'].nil? ? 1_048_576 : config_json['roll_size'].to_i
22
+ @file_logger = create_ruby_logger(file_path, period, shift_size)
23
+ end
24
+
25
+ def to_builder
26
+ json = super
27
+ json.enable enable
28
+ json.file_path @file_path
29
+ json.period @period
30
+ json.shift_size @shift_size
31
+
32
+ json
33
+ end
34
+ # register :file
35
+
15
36
  protected
16
37
 
38
+ def create_ruby_logger(file_path, period, shift_size)
39
+ ruby_logger = Logger.new(file_path, period, shift_size)
40
+ ruby_logger.level = Logger::Severity::DEBUG
41
+ ruby_logger.formatter = proc do |_severity, _datetime, _progname, msg|
42
+ "#{msg}\n"
43
+ end
44
+ ruby_logger
45
+ end
46
+
17
47
  def flush_and_clear
18
48
  semaphore.synchronize do
19
49
  @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }
@@ -0,0 +1,58 @@
1
+ require 'fluent-logger'
2
+ require_relative 'log_repository'
3
+
4
+ module RTALogger
5
+ class LogRepositoryFluentd < LogRepository
6
+ def initialize(host = 'localhost', port = 24224, tls_options = nil)
7
+ super()
8
+ @host = host
9
+ @port = port
10
+ @fluent_logger = create_fluentd_logger(host, port, tls_options)
11
+ end
12
+
13
+ def load_config(config_json)
14
+ super
15
+
16
+ host = config_json['host'].to_s
17
+ port = config_json['port'].to_s
18
+ tls_options = config_json['tls_options']
19
+
20
+ @fluent_logger = create_fluentd_logger(host, port, tls_options)
21
+ end
22
+
23
+ def to_builder
24
+ json = super
25
+ json.enable enable
26
+ json.host @host
27
+ json.port @port
28
+
29
+ json
30
+ end
31
+ # register :fluentd
32
+
33
+ protected
34
+
35
+ def create_fluentd_logger(host, port, tls_options)
36
+ unless tls_options
37
+ fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :use_nonblock => true, :wait_writeable => false)
38
+ else
39
+ fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :tls_options => tls_options, :use_nonblock => true, :wait_writeable => false)
40
+ end
41
+
42
+ fluent_logger
43
+ end
44
+
45
+ def flush_and_clear
46
+ semaphore.synchronize do
47
+ @log_records.each do |log_record|
48
+ fluent_tag = log_record.app_name + '.' + log_record.topic_title
49
+ log_json_string = @formatter.format(log_record)
50
+ log_json = JSON.parse(log_json_string)
51
+
52
+ @fluent_logger.post(fluent_tag, log_json)
53
+ end
54
+ end
55
+ super
56
+ end
57
+ end
58
+ end
@@ -5,18 +5,26 @@ module RTALogger
5
5
  class LogRepositoryUDP < LogRepository
6
6
  def initialize(host = '127.0.0.1', port = 4913)
7
7
  super()
8
- @host = host
9
- @port = port
8
+ @udp_socket = UDPSocket.new
9
+ @udp_socket.bind(host, port)
10
10
  end
11
11
 
12
+ def load_config(config_json)
13
+ super
14
+
15
+ host = config_json['host'].to_s
16
+ port = config_json['port'].nil? ? 4913 : config_json['port'].to_i
17
+ @udp_socket = UDPSocket.new
18
+ @udp_socket.bind(host, port)
19
+ end
20
+
21
+ # register :udp
22
+
12
23
  protected
13
24
 
14
25
  def flush_and_clear
15
26
  semaphore.synchronize do
16
- u1 = UDPSocket.new
17
- u1.bind(@host, @port)
18
- @log_records.each { |log_record| u1.send log_record.to_s, 0, @host, @port }
19
- u1.close
27
+ @log_records.each { |log_record| @udp_socket.send @formatter.format(log_record), 0, @host, @port }
20
28
  end
21
29
  super
22
30
  end
@@ -1,47 +1,68 @@
1
- require_relative 'log_severity'
1
+ require_relative 'severity_level'
2
2
  require_relative 'log_factory_record'
3
+ require 'jbuilder'
3
4
 
4
5
  module RTALogger
5
6
  # the main class to logging data as topic
6
7
  class LogTopic
7
- include LogSeverity
8
+ include SeverityLevel
8
9
  include RTALogger::LogFactory
9
10
 
10
- def initialize(log_manager, topic_title, log_level = WARN)
11
+ def initialize(log_manager, title, severity_level = WARN, enable = true)
11
12
  # Logger logger = Logger.new(Logger::DEBUG)
12
- @enable = true
13
+ @enable = enable
13
14
  @log_manager = log_manager
14
- @topic_title = topic_title.to_s.dup
15
- @log_level = log_level
15
+ @title = title.to_s.dup
16
+ @severity_level = severity_level
16
17
  end
17
18
 
18
19
  attr_accessor :enable
19
20
  attr_reader :log_manager
20
- attr_reader :topic_title
21
- attr_accessor :log_level
21
+ attr_reader :title
22
+ attr_accessor :severity_level
23
+
24
+ def trace(context_id, *message)
25
+ add(context_id, TRACE, message) if @severity_level.to_i <= TRACE.to_i
26
+ end
22
27
 
23
28
  def debug(context_id, *message)
24
- add(context_id, DEBUG, message) if @log_level.to_i <= DEBUG.to_i
29
+ add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
25
30
  end
26
31
 
27
32
  def info(context_id, *message)
28
- add(context_id, INFO, message) if @log_level.to_i <= INFO.to_i
33
+ add(context_id, INFO, message) if @severity_level.to_i <= INFO.to_i
29
34
  end
30
35
 
31
36
  def warning(context_id, *message)
32
- add(context_id, WARN, message) if @log_level.to_i <= WARN.to_i
37
+ add(context_id, WARN, message) if @severity_level.to_i <= WARN.to_i
33
38
  end
34
39
 
35
40
  def error(context_id, *message)
36
- add(context_id, ERROR, message) if @log_level.to_i <= ERROR.to_i
41
+ add(context_id, ERROR, message) if @severity_level.to_i <= ERROR.to_i
37
42
  end
38
43
 
39
44
  def fatal(context_id, *message)
40
- add(context_id, FATAL, message) if @log_level.to_i <= FATAL.to_i
45
+ add(context_id, FATAL, message) if @severity_level.to_i <= FATAL.to_i
41
46
  end
42
47
 
43
48
  def unknown(context_id, *message)
44
- add(context_id, UNKNOWN, message) if @log_level.to_i <= UNKNOWN.to_i
49
+ add(context_id, UNKNOWN, message) if @severity_level.to_i <= UNKNOWN.to_i
50
+ end
51
+
52
+ def to_builder
53
+ jb = Jbuilder.new do |json|
54
+ json.title title
55
+ json.severity_level parse_severity_level_to_s(severity_level)
56
+ json.enable enable
57
+ end
58
+
59
+ jb
60
+ end
61
+
62
+ def appy_run_time_config(config_json)
63
+ return unless config_json
64
+ @enable = config_json['enable'] unless config_json['enable'].nil?
65
+ @severity_level = parse_severity_level_to_i(config_json['severity_level']) unless config_json['severity_level'].nil?
45
66
  end
46
67
 
47
68
  private
@@ -1,35 +1,59 @@
1
1
  {
2
- "RTALogger":
2
+ "rta_logger":
3
3
  {
4
- "Default_Manager": "Develop",
5
- "Log_Managers":
4
+ "default_manager": "develop",
5
+ "log_managers":
6
6
  [
7
7
  {
8
- "Manager_Name": "Develop",
9
- "Enable": true,
10
- "App_Name": "TestApp",
11
- "Log_Severity": 2,
12
- "Buffer_Size": 100,
13
- "Flush_Wait_Seconds": 15,
14
- "Formatter" : "JSON",
15
- "Repos":
8
+ "title": "develop",
9
+ "enable": true,
10
+ "app_name": "TestApp",
11
+ "severity_level": "trace",
12
+ "buffer_size": 100,
13
+ "flush_wait_seconds": 10,
14
+ "repositories":
16
15
  [
17
16
  {
18
- "Enable": true,
19
- "Type": "Console"
17
+ "type": "console",
18
+ "title": "console_repo_1",
19
+ "enable": true,
20
+ "formatter":
21
+ {
22
+ "type": "text",
23
+ "delimiter": "|"
24
+ }
20
25
  },
21
26
  {
22
- "Enable": false,
23
- "Type": "File",
24
- "File_Path": "../../log/log.txt",
25
- "Roll_Period": "daily",
26
- "Roll_Size": "1048576"
27
+ "type": "file",
28
+ "title": "file_repo_1",
29
+ "enable": true,
30
+ "file_path": "log.txt",
31
+ "roll_period": "daily",
32
+ "roll_size": "1048576",
33
+ "formatter":
34
+ {
35
+ "type": "json",
36
+ "delimiter": "|"
37
+ }
27
38
  },
28
39
  {
29
- "Enable": true,
30
- "Type": "Fluentd",
31
- "Host": "localhost",
32
- "Port": "8888"
40
+ "enable": true,
41
+ "title": "console_repo_1",
42
+ "type": "fluentd",
43
+ "host": "localhost",
44
+ "port": "8888",
45
+ "formatter":
46
+ {
47
+ "type": "json"
48
+ }
49
+ }
50
+ ],
51
+ "topics":
52
+ [
53
+ {
54
+ "title": "test",
55
+ "enable": true,
56
+ "severity_level": "WARN"
33
57
  }
34
58
  ]
35
59
  }