Class: Fluent::Log

Inherits:
Object
  • Object
show all
Defined in:
lib/fluent/log.rb

Direct Known Subclasses

PluginLogger

Defined Under Namespace

Modules: TTYColor

Constant Summary collapse

LEVEL_TRACE = 
0
LEVEL_DEBUG = 
1
LEVEL_INFO = 
2
LEVEL_WARN = 
3
LEVEL_ERROR = 
4
LEVEL_FATAL = 
5
LEVEL_TEXT = 
%w(trace debug info warn error fatal)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(logger, opts = {}) ⇒ Log

Returns a new instance of Log.



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/fluent/log.rb', line 57

def initialize(logger, opts={})
  # overwrites logger.level= so that config reloading resets level of Fluentd::Log
  orig_logger_level_setter = logger.class.public_instance_method(:level=).bind(logger)
  me = self
  # The original ruby logger sets the number as each log level like below.
  # DEBUG = 0
  # INFO  = 1
  # WARN  = 2
  # ERROR = 3
  # FATAL = 4
  # Serverengine use this original log number. In addition to this, serverengine sets -1 as TRACE level.
  # TRACE = -1
  #
  # On the other hand, in fluentd side, it sets the number like below.
  # TRACE = 0
  # DEBUG = 1
  # INFO  = 2
  # WARN  = 3
  # ERROR = 4
  # FATAL = 5
  #
  # Then fluentd's level is set as serverengine's level + 1.
  # So if serverengine's logger level is changed, fluentd's log level will be changed to that + 1.
  logger.define_singleton_method(:level=) {|level| orig_logger_level_setter.call(level); me.level = self.level + 1 }

  @logger = logger
  @out = logger.instance_variable_get(:@logdev)
  @level = logger.level + 1
  @debug_mode = false
  @self_event = false
  @tag = 'fluent'
  @time_format = '%Y-%m-%d %H:%M:%S %z '
  @depth_offset = 1
  enable_color out.tty?
  # TODO: This variable name is unclear so we should change to better name.
  @threads_exclude_events = []

  # Fluent::Engine requires Fluent::Log, so we must take that object lazily
  @engine = Fluent.const_get('Engine')
  @optional_header = nil
  @optional_attrs = nil

  @suppress_repeated_stacktrace = opts[:suppress_repeated_stacktrace]
end

Instance Attribute Details

#level ⇒ Object

Returns the value of attribute level.



114
115
116
 
# File 'lib/fluent/log.rb', line 114

def level
  @level
end

#optional_attrs ⇒ Object

Returns the value of attribute optional_attrs.



117
118
119
 
# File 'lib/fluent/log.rb', line 117

def optional_attrs
  @optional_attrs
end

#optional_header ⇒ Object

Returns the value of attribute optional_header.



117
118
119
 
# File 'lib/fluent/log.rb', line 117

def optional_header
  @optional_header
end

#out ⇒ Object

Returns the value of attribute out.



113
114
115
 
# File 'lib/fluent/log.rb', line 113

def out
  @out
end

#tag ⇒ Object

Returns the value of attribute tag.



115
116
117
 
# File 'lib/fluent/log.rb', line 115

def tag
  @tag
end

#time_format ⇒ Object

Returns the value of attribute time_format.



116
117
118
 
# File 'lib/fluent/log.rb', line 116

def time_format
  @time_format
end

Class Method Details

.str_to_level(log_level_str) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/fluent/log.rb', line 45

def self.str_to_level(log_level_str)
  case log_level_str.downcase
  when "trace" then LEVEL_TRACE
  when "debug" then LEVEL_DEBUG
  when "info"  then LEVEL_INFO
  when "warn"  then LEVEL_WARN
  when "error" then LEVEL_ERROR
  when "fatal" then LEVEL_FATAL
  else raise "Unknown log level: level = #{log_level_str}"
  end
end

Instance Method Details

#debug(*args, &block) ⇒ Object Also known as: DEBUG 



196
197
198
199
200
201
202
 
# File 'lib/fluent/log.rb', line 196

def debug(*args, &block)
  return if @level > LEVEL_DEBUG
  args << block.call if block
  time, msg = event(:debug, args)
  puts [@color_debug, caller_line(time, @depth_offset, LEVEL_DEBUG), msg, @color_reset].join
rescue
end

#debug_backtrace(backtrace = $!.backtrace) ⇒ Object 



205
206
207
 
# File 'lib/fluent/log.rb', line 205

def debug_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_DEBUG)
end

#disable_events(thread) ⇒ Object

If you want to suppress event emitting in specific thread, please use this method. Events in passed thread are never emitted.



168
169
170
 
# File 'lib/fluent/log.rb', line 168

def disable_events(thread)
  @threads_exclude_events.push(thread) unless @threads_exclude_events.include?(thread)
end

#dup ⇒ Object 



102
103
104
105
106
107
108
109
110
111
 
# File 'lib/fluent/log.rb', line 102

def dup
  dl_opts = {}
  dl_opts[:log_level] = @level - 1
  logger = ServerEngine::DaemonLogger.new(@out, dl_opts)
  clone = self.class.new(logger, suppress_repeated_stacktrace: @suppress_repeated_stacktrace)
  clone.tag = @tag
  clone.time_format = @time_format
  # optional headers/attrs are not copied, because new PluginLogger should have another one of it
  clone
end

#enable_color(b = true) ⇒ Object 



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/fluent/log.rb', line 145

def enable_color(b=true)
  if b
    @color_trace = TTYColor::BLUE
    @color_debug = TTYColor::WHITE
    @color_info  = TTYColor::GREEN
    @color_warn  = TTYColor::YELLOW
    @color_error = TTYColor::MAGENTA
    @color_fatal = TTYColor::RED
    @color_reset = TTYColor::NORMAL
  else
    @color_trace = ''
    @color_debug = ''
    @color_info  = ''
    @color_warn  = ''
    @color_error = ''
    @color_fatal = ''
    @color_reset = ''
  end
  self
end

#enable_color? ⇒ Boolean

Returns:

  • (Boolean) 


141
142
143
 
# File 'lib/fluent/log.rb', line 141

def enable_color?
  !@color_reset.empty?
end

#enable_debug(b = true) ⇒ Object 



131
132
133
134
 
# File 'lib/fluent/log.rb', line 131

def enable_debug(b=true)
  @debug_mode = b
  self
end

#enable_event(b = true) ⇒ Object 



136
137
138
139
 
# File 'lib/fluent/log.rb', line 136

def enable_event(b=true)
  @self_event = b
  self
end

#error(*args, &block) ⇒ Object Also known as: ERROR 



250
251
252
253
254
255
256
 
# File 'lib/fluent/log.rb', line 250

def error(*args, &block)
  return if @level > LEVEL_ERROR
  args << block.call if block
  time, msg = event(:error, args)
  puts [@color_error, caller_line(time, @depth_offset, LEVEL_ERROR), msg, @color_reset].join
rescue
end

#error_backtrace(backtrace = $!.backtrace) ⇒ Object 



259
260
261
 
# File 'lib/fluent/log.rb', line 259

def error_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_ERROR)
end

#fatal(*args, &block) ⇒ Object Also known as: FATAL 



268
269
270
271
272
273
274
 
# File 'lib/fluent/log.rb', line 268

def fatal(*args, &block)
  return if @level > LEVEL_FATAL
  args << block.call if block
  time, msg = event(:fatal, args)
  puts [@color_fatal, caller_line(time, @depth_offset, LEVEL_FATAL), msg, @color_reset].join
rescue
end

#fatal_backtrace(backtrace = $!.backtrace) ⇒ Object 



277
278
279
 
# File 'lib/fluent/log.rb', line 277

def fatal_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_FATAL)
end

#flush ⇒ Object 



294
295
296
 
# File 'lib/fluent/log.rb', line 294

def flush
  @out.flush
end

#info(*args, &block) ⇒ Object Also known as: INFO 



214
215
216
217
218
219
220
 
# File 'lib/fluent/log.rb', line 214

def info(*args, &block)
  return if @level > LEVEL_INFO
  args << block.call if block
  time, msg = event(:info, args)
  puts [@color_info, caller_line(time, @depth_offset, LEVEL_INFO), msg, @color_reset].join
rescue
end

#info_backtrace(backtrace = $!.backtrace) ⇒ Object 



223
224
225
 
# File 'lib/fluent/log.rb', line 223

def info_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_INFO)
end

#logdev=(logdev) ⇒ Object 



119
120
121
122
123
 
# File 'lib/fluent/log.rb', line 119

def logdev=(logdev)
  @out = logdev
  @logger.instance_variable_set(:@logdev, logdev)
  nil
end

#on_debug(&block) ⇒ Object 



191
192
193
194
 
# File 'lib/fluent/log.rb', line 191

def on_debug(&block)
  return if @level > LEVEL_DEBUG
  block.call if block
end

#on_error(&block) ⇒ Object 



245
246
247
248
 
# File 'lib/fluent/log.rb', line 245

def on_error(&block)
  return if @level > LEVEL_ERROR
  block.call if block
end

#on_fatal(&block) ⇒ Object 



263
264
265
266
 
# File 'lib/fluent/log.rb', line 263

def on_fatal(&block)
  return if @level > LEVEL_FATAL
  block.call if block
end

#on_info(&block) ⇒ Object 



209
210
211
212
 
# File 'lib/fluent/log.rb', line 209

def on_info(&block)
  return if @level > LEVEL_INFO
  block.call if block
end

#on_trace(&block) ⇒ Object 



172
173
174
175
 
# File 'lib/fluent/log.rb', line 172

def on_trace(&block)
  return if @level > LEVEL_TRACE
  block.call if block
end

#on_warn(&block) ⇒ Object 



227
228
229
230
 
# File 'lib/fluent/log.rb', line 227

def on_warn(&block)
  return if @level > LEVEL_WARN
  block.call if block
end

#puts(msg) ⇒ Object 



281
282
283
284
285
286
287
288
 
# File 'lib/fluent/log.rb', line 281

def puts(msg)
  @logger << msg + "\n"
  @out.flush
  msg
rescue
  # FIXME
  nil
end

#reopen! ⇒ Object 



125
126
127
128
129
 
# File 'lib/fluent/log.rb', line 125

def reopen!
  # do nothing in @logger.reopen! because it's already reopened in Supervisor.load_config
  @logger.reopen! if @logger
  nil
end

#reset ⇒ Object 



298
299
300
 
# File 'lib/fluent/log.rb', line 298

def reset
  @out.reset if @out.respond_to?(:reset)
end

#trace(*args, &block) ⇒ Object Also known as: TRACE 



177
178
179
180
181
182
183
184
 
# File 'lib/fluent/log.rb', line 177

def trace(*args, &block)
  return if @level > LEVEL_TRACE
  args << block.call if block
  time, msg = event(:trace, args)
  puts [@color_trace, caller_line(time, @depth_offset, LEVEL_TRACE), msg, @color_reset].join
rescue
  # logger should not raise an exception. This rescue prevents unexpected behaviour.
end

#trace_backtrace(backtrace = $!.backtrace) ⇒ Object 



187
188
189
 
# File 'lib/fluent/log.rb', line 187

def trace_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_TRACE)
end

#warn(*args, &block) ⇒ Object Also known as: WARN 



232
233
234
235
236
237
238
 
# File 'lib/fluent/log.rb', line 232

def warn(*args, &block)
  return if @level > LEVEL_WARN
  args << block.call if block
  time, msg = event(:warn, args)
  puts [@color_warn, caller_line(time, @depth_offset, LEVEL_WARN), msg, @color_reset].join
rescue
end

#warn_backtrace(backtrace = $!.backtrace) ⇒ Object 



241
242
243
 
# File 'lib/fluent/log.rb', line 241

def warn_backtrace(backtrace=$!.backtrace)
  dump_stacktrace(backtrace, LEVEL_WARN)
end

#write(data) ⇒ Object 



290
291
292
 
# File 'lib/fluent/log.rb', line 290

def write(data)
  @out.write(data)
end