Class: DaemonKit::AbstractLogger

Inherits:
Object
  • Object
show all
Defined in:
lib/daemon_kit/abstract_logger.rb

Overview

One of the key parts of succesful background processes is adequate logging. The AbstractLogger aims to simplify logging from inside daemon processes by providing additional useful information with each log line, including calling file name and line number and support for cleanly logging exceptions.

The logger can be accessed through #DaemonKit.logger.

AbstractLogger provides an interface that is fully compatible with the Logger class provided by Ruby’s Standard Library, and is extended with some additional conveniences.

The AbstractLogger supports different backends, by default it uses a Logger instance, but can by swapped out for a SysLogLogger logger as well.

Defined Under Namespace

Classes: Formatter

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(log_path = nil) ⇒ AbstractLogger

Optional log path, defaults to DAEMON_ROOT/log/DAEMON_ENV.log



41
42
43
44
45
46
47
48
49
50
 
# File 'lib/daemon_kit/abstract_logger.rb', line 41

def initialize( log_path = nil )
  if log_path.to_s == "syslog"
    @backend = :syslog
  else
    @logger_file = log_path || "#{DAEMON_ROOT}/log/#{DAEMON_ENV}.log"
    @backend = :logger
  end

  @copy_to_stdout = false
end

Class Attribute Details

.severities ⇒ Object (readonly)

Returns the value of attribute severities.



35
36
37
 
# File 'lib/daemon_kit/abstract_logger.rb', line 35

def severities
  @severities
end

.silencer ⇒ Object

Returns the value of attribute silencer.



36
37
38
 
# File 'lib/daemon_kit/abstract_logger.rb', line 36

def silencer
  @silencer
end

Instance Attribute Details

#copy_to_stdout ⇒ Object

Returns the value of attribute copy_to_stdout.



21
22
23
 
# File 'lib/daemon_kit/abstract_logger.rb', line 21

def copy_to_stdout
  @copy_to_stdout
end

Instance Method Details

#add(severity, message, skip_caller = false) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/daemon_kit/abstract_logger.rb', line 119

def add( severity, message, skip_caller = false )
  message = "#{called(caller)}: #{message}" unless skip_caller

  self.logger.add( self.class.severities[ severity ] ) { message }

  STDOUT.puts( message ) if self.copy_to_stdout
end

#clean_trace(trace) ⇒ Object 



151
152
153
154
155
156
 
# File 'lib/daemon_kit/abstract_logger.rb', line 151

def clean_trace( trace )
  trace = trace.map { |l| l.gsub(DAEMON_ROOT, '') }
  trace = trace.reject { |l| l =~ /gems\/daemon[\-_]kit/ }
  trace = trace.reject { |l| l =~ /vendor\/daemon[\-_]kit/ }
  trace
end

#close ⇒ Object 



158
159
160
161
162
163
164
 
# File 'lib/daemon_kit/abstract_logger.rb', line 158

def close
  case @backend
  when :logger
    self.logger.close
    @logger = nil
  end
end

#debug(msg) ⇒ Object 



66
67
68
 
# File 'lib/daemon_kit/abstract_logger.rb', line 66

def debug( msg )
  add( :debug, msg )
end

#debug? ⇒ Boolean

Returns:

  • (Boolean) 


70
71
72
 
# File 'lib/daemon_kit/abstract_logger.rb', line 70

def debug?
  self.level == :debug
end

#error(msg) ⇒ Object 



90
91
92
 
# File 'lib/daemon_kit/abstract_logger.rb', line 90

def error( msg )
  add( :error, msg )
end

#error? ⇒ Boolean

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/daemon_kit/abstract_logger.rb', line 94

def error?
  self.level == :error
end

#exception(e) ⇒ Object 



114
115
116
117
 
# File 'lib/daemon_kit/abstract_logger.rb', line 114

def exception( e )
  message = "EXCEPTION: #{e.message}: #{clean_trace( e.backtrace )}"
  self.add( :error, message, true )
end

#fatal(msg) ⇒ Object 



98
99
100
 
# File 'lib/daemon_kit/abstract_logger.rb', line 98

def fatal( msg )
  add( :fatal, msg )
end

#fatal? ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/daemon_kit/abstract_logger.rb', line 102

def fatal?
  self.level == :fatal
end

#info(msg) ⇒ Object 



74
75
76
 
# File 'lib/daemon_kit/abstract_logger.rb', line 74

def info( msg )
  add( :info, msg )
end

#info? ⇒ Boolean

Returns:

  • (Boolean) 


78
79
80
 
# File 'lib/daemon_kit/abstract_logger.rb', line 78

def info?
  self.level == :info
end

#level ⇒ Object 



127
128
129
 
# File 'lib/daemon_kit/abstract_logger.rb', line 127

def level
  self.class.severities.invert[ @logger.level ]
end

#level=(level) ⇒ Object 



131
132
133
134
 
# File 'lib/daemon_kit/abstract_logger.rb', line 131

def level=( level )
  level = ( Symbol === level ? self.class.severities[ level ] : level )
  self.logger.level = level
end

#logger ⇒ Object 



136
137
138
 
# File 'lib/daemon_kit/abstract_logger.rb', line 136

def logger
  @logger ||= create_logger
end

#logger=(logger) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
 
# File 'lib/daemon_kit/abstract_logger.rb', line 140

def logger=( logger )
  if logger.is_a?( Symbol )
    @backend = logger
    @logger.close rescue nil
    @logger = create_logger
  else
    @logger.close rescue nil
    @logger = logger
  end
end

#silence(temporary_level = :error) ⇒ Object

Silence the logger for the duration of the block.



53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/daemon_kit/abstract_logger.rb', line 53

def silence( temporary_level = :error )
  if self.class.silencer
    begin
      old_level, self.level = self.level, temporary_level
      yield self
    ensure
      self.level = old_level
    end
  else
    yield self
  end
end

#unknown(msg) ⇒ Object 



106
107
108
 
# File 'lib/daemon_kit/abstract_logger.rb', line 106

def unknown( msg )
  add( :unknown, msg )
end

#unknown? ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/daemon_kit/abstract_logger.rb', line 110

def unknown?
  self.level == :unknown
end

#warn(msg) ⇒ Object 



82
83
84
 
# File 'lib/daemon_kit/abstract_logger.rb', line 82

def warn( msg )
  add( :warn, msg )
end

#warn? ⇒ Boolean

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/daemon_kit/abstract_logger.rb', line 86

def warn?
  self.level == :warn
end