Class: Legion::Logging::TaggedLogger

Inherits:
Object
  • Object
show all
Defined in:
lib/legion/logging/tagged_logger.rb

Constant Summary collapse

LEVELS = 
{ debug: 0, info: 1, warn: 2, error: 3, fatal: 4, unknown: 5 }.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(segments:, level: Legion::Logging::Settings.default[:level], trace: Legion::Logging::Settings.default[:trace], trace_size: Legion::Logging::Settings.default[:trace_size], extended: Legion::Logging::Settings.default[:extended], **_opts) ⇒ TaggedLogger

Returns a new instance of TaggedLogger.



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/legion/logging/tagged_logger.rb', line 10

def initialize(
  segments:,
  level: Legion::Logging::Settings.default[:level],
  trace: Legion::Logging::Settings.default[:trace],
  trace_size: Legion::Logging::Settings.default[:trace_size],
  extended: Legion::Logging::Settings.default[:extended],
  **_opts
)
  @segments = segments
  @level_value =
    if level.is_a?(Integer)
      level
    else
      default_level = Legion::Logging::Settings.default[:level].to_s.downcase.to_sym
      LEVELS.fetch(level.to_s.downcase.to_sym, LEVELS.fetch(default_level, LEVELS[:info]))
    end
  @trace_enabled = trace
  @trace_size = trace_size
  @extended = extended
end

Instance Attribute Details

#extended ⇒ Object (readonly)

Returns the value of attribute extended.



8
9
10
 
# File 'lib/legion/logging/tagged_logger.rb', line 8

def extended
  @extended
end

#segments ⇒ Object (readonly)

Returns the value of attribute segments.



8
9
10
 
# File 'lib/legion/logging/tagged_logger.rb', line 8

def segments
  @segments
end

#trace_enabled ⇒ Object (readonly)

Returns the value of attribute trace_enabled.



8
9
10
 
# File 'lib/legion/logging/tagged_logger.rb', line 8

def trace_enabled
  @trace_enabled
end

Instance Method Details

#debug(message = nil) ⇒ Object 



35
36
37
38
39
40
 
# File 'lib/legion/logging/tagged_logger.rb', line 35

def debug(message = nil)
  return unless @level_value < 1

  message = yield if message.nil? && block_given?
  with_segments { dispatch(:debug, message) }
end

#error(message = nil) ⇒ Object 



56
57
58
59
60
61
 
# File 'lib/legion/logging/tagged_logger.rb', line 56

def error(message = nil)
  return unless @level_value < 4

  message = yield if message.nil? && block_given?
  with_segments { dispatch(:error, message) }
end

#fatal(message = nil) ⇒ Object 



63
64
65
66
67
68
 
# File 'lib/legion/logging/tagged_logger.rb', line 63

def fatal(message = nil)
  return unless @level_value < 5

  message = yield if message.nil? && block_given?
  with_segments { dispatch(:fatal, message) }
end

#info(message = nil) ⇒ Object 



42
43
44
45
46
47
 
# File 'lib/legion/logging/tagged_logger.rb', line 42

def info(message = nil)
  return unless @level_value < 2

  message = yield if message.nil? && block_given?
  with_segments { dispatch(:info, message) }
end

#level ⇒ Object 



31
32
33
 
# File 'lib/legion/logging/tagged_logger.rb', line 31

def level
  @level_value
end

#thread(kvl: false, **_opts) ⇒ Object 



87
88
89
90
91
92
93
 
# File 'lib/legion/logging/tagged_logger.rb', line 87

def thread(kvl: false, **_opts)
  if kvl
    "thread=#{Thread.current.object_id}"
  else
    Thread.current.object_id.to_s
  end
end

#trace(raw_message = nil, size: @trace_size, log_caller: true) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/legion/logging/tagged_logger.rb', line 75

def trace(raw_message = nil, size: @trace_size, log_caller: true)
  return unless @trace_enabled

  raw_message = yield if raw_message.nil? && block_given?
  message = "Tracing: #{raw_message} "
  if log_caller
    frames = size ? caller_locations(2, size) : caller_locations(2)
    message.concat(frames&.join(', ').to_s)
  end
  with_segments { Legion::Logging.unknown(message) }
end

#unknown(message = nil) ⇒ Object 



70
71
72
73
 
# File 'lib/legion/logging/tagged_logger.rb', line 70

def unknown(message = nil)
  message = yield if message.nil? && block_given?
  with_segments { dispatch(:unknown, message) }
end

#warn(message = nil) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/legion/logging/tagged_logger.rb', line 49

def warn(message = nil)
  return unless @level_value < 3

  message = yield if message.nil? && block_given?
  with_segments { dispatch(:warn, message) }
end