Class: Steno::Logger

Inherits:
Object show all
Defined in:
lib/steno/logger.rb

Constant Summary collapse

LEVELS = 
{
  :off    => Steno::LogLevel.new(:off,     0),
  :fatal  => Steno::LogLevel.new(:fatal,   1),
  :error  => Steno::LogLevel.new(:error,   5),
  :warn   => Steno::LogLevel.new(:warn,   10),
  :info   => Steno::LogLevel.new(:info,   15),
  :debug  => Steno::LogLevel.new(:debug,  16),
  :debug1 => Steno::LogLevel.new(:debug1, 17),
  :debug2 => Steno::LogLevel.new(:debug2, 18),
  :all    => Steno::LogLevel.new(:all,    30),
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, sinks, opts = {}) ⇒ Logger

Returns a new instance of Logger.

Parameters:

  • name (String) —

    The logger name.

  • sinks (Array<Steno::Sink::Base>)
  • opts (Hash) (defaults to: {})

Options Hash (opts):

  • :level (Symbol) —

    The minimum level for which this logger will emit log records. Defaults to :info.

  • :context (Steno::Context) 


71
72
73
74
75
76
77
 
# File 'lib/steno/logger.rb', line 71

def initialize(name, sinks, opts = {})
  @name           = name
  @min_level      = self.class.lookup_level(opts[:level] || :info)
  @min_level_lock = Mutex.new
  @sinks          = sinks
  @context        = opts[:context] || Steno::Context::Null.new
end

Instance Attribute Details

#name ⇒ Object (readonly)

Returns the value of attribute name.



63
64
65
 
# File 'lib/steno/logger.rb', line 63

def name
  @name
end

Class Method Details

.define_level_active_predicate(name) ⇒ Object 



34
35
36
 
# File 'lib/steno/logger.rb', line 34

def define_level_active_predicate(name)
  define_method(name.to_s + "?") { level_active?(name) }
end

.define_log_method(name) ⇒ Object

The following helpers are used to create a new scope for binding the log level.



26
27
28
 
# File 'lib/steno/logger.rb', line 26

def define_log_method(name)
  define_method(name) { |*args, &blk| log(name, *args, &blk) }
end

.define_logf_method(name) ⇒ Object 



30
31
32
 
# File 'lib/steno/logger.rb', line 30

def define_logf_method(name)
  define_method(name.to_s + "f") { |fmt, *args| log(name, fmt % args) }
end

.lookup_level(name) ⇒ Object 



38
39
40
41
42
43
44
45
46
 
# File 'lib/steno/logger.rb', line 38

def lookup_level(name)
  level = LEVELS[name]

  if level.nil?
    raise Steno::Error.new("Unknown level: #{name}")
  end

  level
end

Instance Method Details

#level ⇒ Symbol

Returns the name of the current log level

Returns:

  • (Symbol) 


95
96
97
 
# File 'lib/steno/logger.rb', line 95

def level
  @min_level_lock.synchronize { @min_level.name }
end

#level=(level_name) ⇒ nil

Sets the minimum level for which records will be added to sinks.

Parameters:

  • level_name (Symbol) —

    The level name

Returns:

  • (nil) 


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

def level=(level_name)
  level = self.class.lookup_level(level_name)

  @min_level_lock.synchronize { @min_level = level }

  nil
end

#level_active?(level_name) ⇒ true || false

Returns whether or not records for the given level would be forwarded to sinks.

Parameters:

  • level_name (Symbol)

Returns:

  • (true || false) 


105
106
107
108
 
# File 'lib/steno/logger.rb', line 105

def level_active?(level_name)
  level = self.class.lookup_level(level_name)
  @min_level_lock.synchronize { level <= @min_level }
end

#log(level_name, message = nil, user_data = nil, &blk) ⇒ nil

Adds a record to the configured sinks.

Parameters:

  • level_name (Symbol) —

    The level associated with the record

  • message (String) (defaults to: nil)
  • user_data (Hash) (defaults to: nil)

Returns:

  • (nil) 


126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/steno/logger.rb', line 126

def log(level_name, message = nil, user_data = nil, &blk)
  return unless level_active?(level_name)

  message = yield if block_given?

  callstack = caller
  loc = parse_record_loc(callstack)

  data = @context.data.merge(user_data || {})

  record = Steno::Record.new(@name, level_name, message, loc, data)

  @sinks.each { |sink| sink.add_record(record) }

  nil
end

#log_exception(ex, user_data = {}) ⇒ nil

Returns:

  • (nil) 


115
116
117
 
# File 'lib/steno/logger.rb', line 115

def log_exception(ex, user_data = {})
  warn("Caught exception: #{ex}", user_data.merge(:backtrace => ex.backtrace))
end

#tag(user_data = {}) ⇒ Steno::TaggedLogger

Returns a proxy that will emit the supplied user data along with each log record.

Parameters:

  • user_data (Hash) (defaults to: {})

Returns:



149
150
151
 
# File 'lib/steno/logger.rb', line 149

def tag(user_data = {})
  Steno::TaggedLogger.new(self, user_data)
end