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.


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


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) 

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) 

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 


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


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


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


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


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

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