Class: OpenTrace::Logger

Inherits:
Logger
  • Object
show all
Defined in:
lib/opentrace/logger.rb

Constant Summary collapse

SEVERITY_MAP = 
{
  ::Logger::DEBUG   => "DEBUG",
  ::Logger::INFO    => "INFO",
  ::Logger::WARN    => "WARN",
  ::Logger::ERROR   => "ERROR",
  ::Logger::FATAL   => "FATAL",
  ::Logger::UNKNOWN => "UNKNOWN"
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(wrapped_logger, metadata: {}) ⇒ Logger

Returns a new instance of Logger.



18
19
20
21
22
23
24
 
# File 'lib/opentrace/logger.rb', line 18

def initialize(wrapped_logger, metadata: {})
  @wrapped_logger = wrapped_logger
  @default_metadata = metadata
  # Initialize with nil logdev - we override #add to handle output
  super(nil)
  self.level = wrapped_logger.level if wrapped_logger.respond_to?(:level)
end

Instance Attribute Details

#wrapped_logger ⇒ Object (readonly)

Returns the value of attribute wrapped_logger.



16
17
18
 
# File 'lib/opentrace/logger.rb', line 16

def wrapped_logger
  @wrapped_logger
end

Instance Method Details

#add(severity, message = nil, progname = nil, &block) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/opentrace/logger.rb', line 26

def add(severity, message = nil, progname = nil, &block)
  if block && message.nil?
    evaluated = false
    resolved_message = nil
    cached_block = proc do
      unless evaluated
        resolved_message = block.call
        evaluated = true
      end
      resolved_message
    end

    # Delegate to wrapped logger first (synchronous, as required)
    @wrapped_logger.add(severity, message, progname, &cached_block)

    # If the wrapped logger filtered this level, Ruby Logger never
    # evaluates the block. Match that behavior for forwarding.
    return true unless evaluated

    forward_to_opentrace(severity, resolved_message, nil)
  else
    # Delegate to wrapped logger first (synchronous, as required)
    @wrapped_logger.add(severity, message, progname)

    # Forward to OpenTrace, never raise
    forward_to_opentrace(severity, message, progname)
  end

  true
rescue StandardError
  # Never raise to the host app
  true
end

#close ⇒ Object 



78
79
80
 
# File 'lib/opentrace/logger.rb', line 78

def close
  @wrapped_logger.close if @wrapped_logger.respond_to?(:close)
end

#flush ⇒ Object 



74
75
76
 
# File 'lib/opentrace/logger.rb', line 74

def flush
  @wrapped_logger.flush if @wrapped_logger.respond_to?(:flush)
end

#formatter ⇒ Object

Proxy formatter to wrapped logger



83
84
85
86
87
88
89
 
# File 'lib/opentrace/logger.rb', line 83

def formatter
  if @wrapped_logger.respond_to?(:formatter)
    @wrapped_logger.formatter
  else
    super
  end
end

#formatter=(f) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/opentrace/logger.rb', line 91

def formatter=(f)
  if @wrapped_logger&.respond_to?(:formatter=)
    @wrapped_logger.formatter = f
  else
    super
  end
end

#tagged(*tags, &block) ⇒ Object

Support TaggedLogging if the wrapped logger uses it



61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/opentrace/logger.rb', line 61

def tagged(*tags, &block)
  if @wrapped_logger.respond_to?(:tagged)
    @wrapped_logger.tagged(*tags) do
      @current_tags = current_tags_from_wrapped
      block.call(self)
    end
  else
    block.call(self)
  end
rescue StandardError
  block.call(self)
end