Class: RrxLogging::Logger

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

Instance Method Summary collapse

Constructor Details

#initialize(mode = :json, name: nil, tags: nil, progname: nil) ⇒ Logger

Returns a new instance of Logger.

[View source]

7
8
9
10
11
12
 
# File 'lib/rrx_logging/logger.rb', line 7

def initialize(mode = :json, name: nil, tags: nil, progname: nil)
  super($stdout, progname: name || progname)
  self.formatter = Formatter.new(mode, tags:)
  @silencers     = []
  @filters       = []
end

Instance Method Details

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

This completely overrites the Activesupport::LoggerThreadSafeLevel implementation since the logic we want to change isn’t separated out in any convenient way

[View source]

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/rrx_logging/logger.rb', line 18

def add(severity, message = nil, progname = nil)
  severity ||= UNKNOWN
  progname ||= @progname

  return true if @logdev.nil? || severity < level

  if message.nil?
    if block_given?
      message = yield
    else
      message  = progname
      progname = @progname
    end
  end

  return true if noise?(message)

  write format_message(format_severity(severity), Time.zone.now, progname, message)
end

#exception(message, exception) ⇒ Object

Parameters:

  • message (String)
  • exception (Exception)
[View source]

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/rrx_logging/logger.rb', line 101

def exception(message, exception)
  backtrace = exception.backtrace
  if backtrace.present?
    cleaned   = Rails.backtrace_cleaner.clean(backtrace)
    backtrace = cleaned unless cleaned.empty?
  else
    backtrace = nil
  end

  error("%s: %s\n%s" % [
    message,
    exception.message,
    backtrace&.join("\n") || 'No backtrace'
  ])
end

#noise?(message) ⇒ Boolean

Returns:

  • (Boolean)
[View source]

71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/rrx_logging/logger.rb', line 71

def noise?(message)
  Rails.configuration.log_noise_filters.any? do |filter|
    case filter
    when Regexp
      filter.match?(message.to_s)
    when String
      message.include? filter
    when Proc
      filter.call(message)
    else
      # Ignore
      false
    end
  end
end

#scoped(name: nil, tags: nil) ⇒ Object

[View source]

38
39
40
41
42
 
# File 'lib/rrx_logging/logger.rb', line 38

def scoped(name: nil, tags: nil)
  Logger.new formatter.mode,
             name: name || progname,
             tags: formatter.default_tags.merge(tags || {})
end

#silence(level, &block) ⇒ Object

Temporarily ignore log statements below the specified level for the scope of the block

[View source]

63
64
65
66
67
68
69
 
# File 'lib/rrx_logging/logger.rb', line 63

def silence(level, &block)
  if level > self.level
    log_at(level, &block)
  else
    block.call
  end
end

#silence_debug(&block) ⇒ Object

Silence logs of debug level or below

[View source]

52
53
54
 
# File 'lib/rrx_logging/logger.rb', line 52

def silence_debug(&block)
  silence(Logger::INFO, &block)
end

#silence_info(&block) ⇒ Object

Silence logs of info level or below

[View source]

57
58
59
 
# File 'lib/rrx_logging/logger.rb', line 57

def silence_info(&block)
  silence(Logger::WARN, &block)
end

#with_tags(**tags) ⇒ Object

Note:

Deliberately not named “tagged” as multiple Rails

classes assume if the logger has a method with that name then call it with an array of text tags

[View source]

47
48
49
 
# File 'lib/rrx_logging/logger.rb', line 47

def with_tags(**tags)
  formatter.with_tags(**tags) { yield self }
end