RTALogger 1.1.0 → 2.1.0

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.
@@ -16,6 +16,10 @@ module RTALogger
16
16
  attr_reader :message
17
17
  attr_reader :occurred_at
18
18
 
19
+ def full_message
20
+ message.join(' ')
21
+ end
22
+
19
23
  def app_name
20
24
  @log_topic.log_manager.app_name
21
25
  end
@@ -1,4 +1,5 @@
1
1
  require_relative 'string'
2
+ require_relative 'log_factory_filter'
2
3
 
3
4
  module RTALogger
4
5
  # base log repository class
@@ -6,8 +7,10 @@ module RTALogger
6
7
  def initialize
7
8
  @semaphore = Mutex.new
8
9
  @log_records = []
10
+ @title = self.class.to_s.split('::').last.underscore
9
11
  @enable = true
10
12
  @formatter = RTALogger::LogFactory.log_formatter_default
13
+ @filters = {}
11
14
  end
12
15
 
13
16
  # @@sub_classes = {}
@@ -25,24 +28,30 @@ module RTALogger
25
28
  # @@sub_classes[repository_name] = self
26
29
  # end
27
30
 
31
+ attr_accessor :title
28
32
  attr_accessor :enable
29
33
  attr_accessor :formatter
30
34
 
31
35
  def add_log_records(items)
32
36
  return 0 unless @enable
33
37
  @semaphore.synchronize do
34
- items.each { |item| @log_records.push(item.dup) }
38
+ items.each do |item|
39
+ @log_records.push(item.dup) if filters_accept(item)
40
+ end
35
41
  end
42
+
36
43
  flush_and_clear
37
44
  end
38
45
 
39
46
  def load_config(config_json)
40
47
  @enable = config_json['enable'].nil? ? true : config_json['enable']
41
-
48
+ @title = config_json['title'].nil? ? self.class.to_s.split('::').last.underscore : config_json['title']
42
49
  formatter_config = config_json['formatter']
43
50
  if formatter_config && formatter_config['type']
44
51
  @formatter = LogFactory.create_formatter(formatter_config['type'], formatter_config)
45
52
  end
53
+
54
+ apply_config_filters(config_json)
46
55
  end
47
56
 
48
57
  def to_builder
@@ -50,6 +59,9 @@ module RTALogger
50
59
  json.type self.class.to_s.split('::').last.underscore.sub('log_repository_', '')
51
60
  json.enable enable
52
61
  json.formatter @formatter.to_builder.attributes!
62
+ json.filters do
63
+ json.array! @filters.keys.collect { |filter_key| @filters[filter_key].to_builder.attributes! }
64
+ end
53
65
  end
54
66
 
55
67
  jb
@@ -59,12 +71,63 @@ module RTALogger
59
71
  to_builder.target!
60
72
  end
61
73
 
74
+ def filter_by_title(title)
75
+ result = nil
76
+ @semaphore.synchronize do
77
+ @filters.keys.each do |filter_key|
78
+ result = @filters[filter_key.to_sym] if filter_key.to_s.casecmp(title).zero?
79
+ break if result
80
+ end
81
+ end
82
+
83
+ return result
84
+ end
85
+
86
+ def apply_run_time_config(config_json)
87
+ return unless config_json
88
+ @enable = config_json['enable'] unless config_json['enable'].nil?
89
+ apply_run_time_config_filters(config_json)
90
+ end
91
+
62
92
  protected
63
93
 
94
+ def apply_config_filters(config_json)
95
+ config_json['filters']&.each do |filter_config|
96
+ next if filter_config['type'].nil? || filter_config['title'].nil?
97
+ filter = LogFactory.create_filter(filter_config['type'], filter_config)
98
+ @filters[filter_config['title'].to_sym] = filter if filter.present?
99
+ end
100
+ end
101
+
102
+ def apply_run_time_config_filters(config_json)
103
+ return unless config_json
104
+
105
+ config_json['filters']&.each do |filter_config|
106
+ next if filter_config['title'].nil?
107
+ filter = filter_by_title(filter_config['title'])
108
+ if filter.present?
109
+ filter.apply_run_time_config(filter_config)
110
+ else
111
+ filter = LogFactory.create_filter(filter_config['type'], filter_config)
112
+ @semaphore.synchronize { @filters[filter_config['title'].to_sym] = filter if filter.present? }
113
+ end
114
+ end
115
+ end
116
+
64
117
  def flush_and_clear
65
118
  @semaphore.synchronize { @log_records.clear }
66
119
  end
67
120
 
121
+ def filters_accept(log_record)
122
+ result = true
123
+ @filters&.keys.each do |filter_key|
124
+ result = @filters[filter_key.to_sym]&.match_conditions(log_record)
125
+ break unless result
126
+ end
127
+
128
+ return result
129
+ end
130
+
68
131
  attr_reader :log_records
69
132
  attr_reader :semaphore
70
133
  end
@@ -17,7 +17,7 @@ module RTALogger
17
17
  protected
18
18
 
19
19
  def flush_and_clear
20
- semaphore.synchronize do
20
+ @semaphore.synchronize do
21
21
  @log_records.each { |log_record| puts @formatter.format(log_record) }
22
22
  end
23
23
  super
@@ -31,8 +31,13 @@ module RTALogger
31
31
 
32
32
  json
33
33
  end
34
+
34
35
  # register :file
35
36
 
37
+ def apply_run_time_config(config_json)
38
+ super config_json
39
+ end
40
+
36
41
  protected
37
42
 
38
43
  def create_ruby_logger(file_path, period, shift_size)
@@ -45,7 +50,7 @@ module RTALogger
45
50
  end
46
51
 
47
52
  def flush_and_clear
48
- semaphore.synchronize do
53
+ @semaphore.synchronize do
49
54
  @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }
50
55
  end
51
56
  super
@@ -7,43 +7,85 @@ module RTALogger
7
7
  super()
8
8
  @host = host
9
9
  @port = port
10
- @fluent_logger = create_fluentd_logger(host, port, tls_options)
10
+ @tls_options = tls_options
11
+ @fluent_logger = nil
11
12
  end
12
13
 
13
14
  def load_config(config_json)
14
15
  super
15
16
 
16
- host = config_json['host'].to_s
17
- port = config_json['port'].to_s
18
- tls_options = config_json['tls_options']
17
+ @host = config_json['host'].to_s
18
+ @port = config_json['port'].to_i
19
+ @tls_options = config_json['tls_options']
19
20
 
20
- @fluent_logger = create_fluentd_logger(host, port, tls_options)
21
+ @semaphore.synchronize { @fluent_logger = nil }
22
+ end
23
+
24
+ def host=(host)
25
+ if @host != host
26
+ @host = host ? host : 'localhost'
27
+ @semaphore.synchronize { @fluent_logger = nil }
28
+ end
29
+ end
30
+
31
+ def host
32
+ @host
33
+ end
34
+
35
+ def port=(port)
36
+ if @port != port
37
+ @port = port ? port : 24224
38
+ @semaphore.synchronize { @fluent_logger = nil }
39
+ end
40
+ end
41
+
42
+ def port
43
+ @port
21
44
  end
22
45
 
23
46
  def to_builder
24
47
  json = super
25
- json.enable enable
48
+ json.enable @enable
26
49
  json.host @host
27
50
  json.port @port
51
+ json.tls_options @tls_options
28
52
 
29
53
  json
30
54
  end
55
+
31
56
  # register :fluentd
32
57
 
58
+ def apply_run_time_config(config_json)
59
+ super config_json
60
+
61
+ @host = config_json['host'] unless config_json['host'].nil?
62
+ @port = config_json['port'] unless config_json['port'].nil?
63
+ @tls_options = config_json['tls_options'] unless config_json['tls_options'].nil?
64
+ @semaphore.synchronize { @fluent_logger = nil }
65
+ end
66
+
33
67
  protected
34
68
 
35
69
  def create_fluentd_logger(host, port, tls_options)
70
+ return nil unless @enable
71
+
36
72
  unless tls_options
37
73
  fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :use_nonblock => true, :wait_writeable => false)
38
74
  else
39
- fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host, :port => port, :tls_options => tls_options, :use_nonblock => true, :wait_writeable => false)
75
+ fluent_logger = ::Fluent::Logger::FluentLogger.new(nil, :host => host,
76
+ :port => port,
77
+ :tls_options => tls_options,
78
+ :use_nonblock => true,
79
+ :wait_writeable => false)
40
80
  end
41
81
 
42
82
  fluent_logger
43
83
  end
44
84
 
45
85
  def flush_and_clear
46
- semaphore.synchronize do
86
+ @semaphore.synchronize do
87
+ @fluent_logger = create_fluentd_logger(@host, @port, @tls_options) unless @fluent_logger.present?
88
+
47
89
  @log_records.each do |log_record|
48
90
  fluent_tag = log_record.app_name + '.' + log_record.topic_title
49
91
  log_json_string = @formatter.format(log_record)
@@ -52,6 +94,7 @@ module RTALogger
52
94
  @fluent_logger.post(fluent_tag, log_json)
53
95
  end
54
96
  end
97
+
55
98
  super
56
99
  end
57
100
  end
@@ -21,6 +21,10 @@ module RTALogger
21
21
  attr_reader :title
22
22
  attr_accessor :severity_level
23
23
 
24
+ def trace(context_id, *message)
25
+ add(context_id, TRACE, message) if @severity_level.to_i <= TRACE.to_i
26
+ end
27
+
24
28
  def debug(context_id, *message)
25
29
  add(context_id, DEBUG, message) if @severity_level.to_i <= DEBUG.to_i
26
30
  end
@@ -54,6 +58,13 @@ module RTALogger
54
58
 
55
59
  jb
56
60
  end
61
+
62
+ def apply_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?
66
+ end
67
+
57
68
  private
58
69
 
59
70
  def add(context_id, severity, *message)
@@ -5,37 +5,55 @@
5
5
  "log_managers":
6
6
  [
7
7
  {
8
- "manager_name": "develop",
8
+ "title": "develop",
9
9
  "enable": true,
10
10
  "app_name": "TestApp",
11
- "severity_level": "debug",
11
+ "severity_level": "trace",
12
12
  "buffer_size": 100,
13
- "flush_wait_seconds": 15,
13
+ "flush_wait_seconds": 10,
14
14
  "repositories":
15
15
  [
16
16
  {
17
- "enable": true,
18
17
  "type": "console",
18
+ "title": "console_repo_1",
19
+ "enable": true,
19
20
  "formatter":
20
21
  {
21
22
  "type": "text",
22
23
  "delimiter": "|"
23
- }
24
+ },
25
+ "filters":
26
+ [
27
+ {
28
+ "type": "topic",
29
+ "title": "topic_filter_1",
30
+ "enable": true,
31
+ "default_regex" : "^test$"
32
+ },
33
+ {
34
+ "type": "message",
35
+ "title": "message_filter_1",
36
+ "enable": false,
37
+ "default_regex" : "error"
38
+ }
39
+ ]
24
40
  },
25
41
  {
26
- "enable": true,
27
42
  "type": "file",
43
+ "title": "file_repo_1",
44
+ "enable": true,
28
45
  "file_path": "log.txt",
29
46
  "roll_period": "daily",
30
47
  "roll_size": "1048576",
31
48
  "formatter":
32
49
  {
33
- "type": "text",
50
+ "type": "json",
34
51
  "delimiter": "|"
35
52
  }
36
53
  },
37
54
  {
38
- "enable": true,
55
+ "enable": false,
56
+ "title": "fluentd_repo_1",
39
57
  "type": "fluentd",
40
58
  "host": "localhost",
41
59
  "port": "8888",
@@ -28,6 +28,7 @@ test_topic = log_manager.add_topic('test')
28
28
  # test_topic.enable = false
29
29
 
30
30
  # add log information to log topic
31
+ topic.trace(userID, 'Controller Name=', controller_name, 'trace')
31
32
  topic.debug(userID, 'Controller Name=', controller_name, 'debug')
32
33
  topic.info(userID, 'Controller Name=', controller_name, 'information')
33
34
  topic.warning(userID, 'Controller Name=', controller_name, 'warning')
@@ -38,7 +39,7 @@ topic.unknown(userID, 'Controller Name=', controller_name, 'unknown')
38
39
  test_topic.error(userID, 'test_topic', 'error')
39
40
  test_topic.fatal(userID, 'test_topic', 'fatal')
40
41
 
41
- puts log_manager.reveal_config
42
+ # puts log_manager.reveal_config
42
43
 
43
44
  # update specific topic log level if necessary
44
45
  # log_manager.update_topic_level(controller_name, RTALogger::SeverityLevel::INFO)
@@ -1,60 +1,68 @@
1
1
  module RTALogger
2
2
  # Logging severity.
3
3
  module SeverityLevel
4
+ # all information that helps us to trace the processing of an incoming request through our application
5
+ TRACE = 0
4
6
  # Low-level information, mostly for developers.
5
- DEBUG = 0
7
+ DEBUG = 1
6
8
  # Generic (useful) information about system operation.
7
- INFO = 1
9
+ INFO = 2
8
10
  # A warning.
9
- WARN = 2
11
+ WARN = 3
10
12
  # A handleable error condition.
11
- ERROR = 3
13
+ ERROR = 4
12
14
  # An un-handleable error that results in a program crash.
13
- FATAL = 4
15
+ FATAL = 5
14
16
  # An unknown message that should always be logged.
15
- UNKNOWN = 5
17
+ UNKNOWN = 6
16
18
 
17
19
 
18
20
  def parse_severity_level_to_i(severity_level)
19
21
  return severity_level if severity_level.is_a? ::Integer
20
22
 
21
23
  case severity_level.upcase
22
- when 'DEBUG'
24
+ when 'TRACE'
23
25
  0
24
- when 'INFO'
26
+ when 'DEBUG'
25
27
  1
28
+ when 'INFO'
29
+ 2
26
30
  when 'INFORMATIONّٔ'
27
- 1
28
- when 'WARN'
29
31
  2
32
+ when 'WARN'
33
+ 3
30
34
  when 'WARNING'
31
- 2
35
+ 5
32
36
  when 'ERROR'
33
- 3
34
- when 'FATAL'
35
37
  4
36
- when 'UNKNOWN'
38
+ when 'FATAL'
37
39
  5
40
+ when 'UNKNOWN'
41
+ 6
42
+ else
43
+ 2
38
44
  end
39
- end
45
+ end
40
46
 
41
- def parse_severity_level_to_s(severity_level)
42
- return severity_level if severity_level.is_a? ::String
47
+ def parse_severity_level_to_s(severity_level)
48
+ return severity_level if severity_level.is_a? ::String
43
49
 
44
- case severity_level.to_i
45
- when 0
46
- 'DEBUG'
47
- when 1
48
- 'INFO'
49
- when 2
50
- 'WARN'
51
- when 3
52
- 'ERROR'
53
- when 4
54
- 'FATAL'
55
- when 5
56
- 'UNKNOWN'
57
- end
50
+ case severity_level.to_i
51
+ when 0
52
+ 'TRACE'
53
+ when 1
54
+ 'DEBUG'
55
+ when 2
56
+ 'INFO'
57
+ when 3
58
+ 'WARN'
59
+ when 4
60
+ 'ERROR'
61
+ when 5
62
+ 'FATAL'
63
+ when 6
64
+ 'UNKNOWN'
58
65
  end
59
66
  end
60
67
  end
68
+ end