Module: SemanticLogger

Defined in:
lib/semantic_logger.rb,
lib/semantic_logger/log.rb,
lib/semantic_logger/base.rb,
lib/semantic_logger/logger.rb,
lib/semantic_logger/version.rb,
lib/semantic_logger/loggable.rb,
lib/semantic_logger/appender/base.rb,
lib/semantic_logger/appender/file.rb,
lib/semantic_logger/appender/syslog.rb,
lib/semantic_logger/semantic_logger.rb,
lib/semantic_logger/appender/mongodb.rb,
lib/semantic_logger/appender/wrapper.rb,
lib/semantic_logger/debug_as_trace_logger.rb,
lib/semantic_logger/jruby/garbage_collection_logger.rb

Overview

Wrapper appender

Wraps the Rails log, log4r, or Ruby Logger with the SemanticLogger API's

Defined Under Namespace

Modules: Appender, JRuby, Loggable Classes: Base, DebugAsTraceLogger, Log, Logger

Constant Summary collapse

VERSION = 
'2.18.0'
LEVELS =

Logging levels in order of most detailed to most severe

[:trace, :debug, :info, :warn, :error, :fatal]

Class Method Summary collapse

Class Method Details

.[](klass) ⇒ Object

Return a logger for the supplied class or class_name



7
8
9
 
# File 'lib/semantic_logger/semantic_logger.rb', line 7

def self.[](klass)
  SemanticLogger::Logger.new(klass)
end

.add_appender(appender, level = nil, &block) ⇒ Object

Add a new logging appender as a new destination for all log messages emitted from Semantic Logger

Appenders will be written to in the order that they are added

If a block is supplied then it will be used to customize the format of the messages sent to that appender. See SemanticLogger::Logger.new for more information on custom formatters

Parameters

appender [String|IO|SemanticLogger::Appender::Base|::Logger]
  Filename to write log messages to
     Or,
  STDOUT, STDERR, or any IO stream to write log messages to
     Or,
  Any SemanticLogger::Appender instance such as
    SemanticLogger::Appender::File
    SemanticLogger::Appender::Wrapper
    SemanticLogger::Appender::Mongodb
     Or,
  A custom appender derived from SemanticLogger::Appender::Base
     Or,
  Ruby built-in Logger, or any logger that implements the following methods:
    :debug, :info, :warn, :error, :fatal

level [Symbol]
  Optional
  By setting the level higher than the SemanticLogger::default_level
  this appender can exclude lower level log messages
  Any one of SemanticLogger::LEVELS. For example: :trace, :debug, :info, :warn, :error, :fatal

Examples:

# Send all logging output to Standard Out (Screen)
SemanticLogger.add_appender(STDOUT)

# Send all logging output to a file
SemanticLogger.add_appender('logfile.log')

# Send all logging output to a file and only :info and above to standard output
SemanticLogger.add_appender('logfile.log')
SemanticLogger.add_appender(STDOUT, :info)

Log to an existing logger:

# Send Semantic logging output to an existing logger
require 'logger'
require 'semantic_logger'

# Built-in Ruby logger
log = Logger.new(STDOUT)
log.level = Logger::DEBUG

SemanticLogger.default_level = :debug
SemanticLogger.add_appender(log)

logger = SemanticLogger['Example']
logger.info "Hello World"
logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/semantic_logger/semantic_logger.rb', line 110

def self.add_appender(appender, level=nil, &block)
  appender_instance =
    if appender.is_a?(String) || appender.is_a?(IO)
      # $stderr, STDOUT, other IO, or a filename
      SemanticLogger::Appender::File.new(appender, level, &block)
    elsif appender.is_a? Appender::Base
      # Already an instance of an appender
      appender.level     = level if level
      appender.formatter = block if block
      appender
    else
      # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
      if does_not_implement = LEVELS[1..-1].find { |i| !appender.respond_to?(i) }
        raise "Supplied appender does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}"
      end

      raise "Change the log level to #{level}, update the log level directly against the supplied appender" if level
      SemanticLogger::Appender::Wrapper.new(appender, &block)
    end
  @@appenders << appender_instance

  # Start appender thread if it is not already running
  SemanticLogger::Logger.start_appender_thread

  appender_instance
end

.add_signal_handler(log_level_signal = 'USR2', thread_dump_signal = 'TTIN', gc_log_microseconds = 100000) ⇒ Object

Add signal handlers for Semantic Logger

Two signal handlers will be registered by default:

  1. Changing the log_level:

The log level can be changed without restarting the process by sending the
log_level_signal, which by default is 'USR2'

When the log_level_signal is raised on this process, the global default log level
rotates through the following log levels in the following order, starting
from the current global default level:
  :warn, :info, :debug, :trace

If the current level is :trace it wraps around back to :warn

  1. Logging a Ruby thread dump

When the signal is raised on this process, Semantic Logger will write the list
of threads to the log file, along with their back-traces when available

For JRuby users this thread dump differs form the standard QUIT triggered
Java thread dump which includes system threads and Java stack traces.

It is recommended to name any threads you create in the application, by
calling the following from within the thread itself:
   Thread.current.name = 'My Worker'

Also adds JRuby Garbage collection logging so that any garbage collections that exceed the time threshold will be logged. Default: 100 ms Currently only supported when running JRuby

Note:

To only register one of the signal handlers, set the other to nil
Set gc_log_microseconds to nil to not enable JRuby Garbage collections



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/semantic_logger/semantic_logger.rb', line 216

def self.add_signal_handler(log_level_signal='USR2', thread_dump_signal='TTIN', gc_log_microseconds=100000)
  Signal.trap(log_level_signal) do
    index     = (default_level == :trace) ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
    new_level = LEVELS[index-1]
    self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
    self.default_level = new_level
  end if log_level_signal

  Signal.trap(thread_dump_signal) do
    logger = SemanticLogger['Thread Dump']
    Thread.list.each do |thread|
      next if thread == Thread.current
      message = thread.name
      if backtrace = thread.backtrace
        message += "\n"
        message << backtrace.join("\n")
      end
      tags = thread[:semantic_logger_tags]
      tags = tags.nil? ? [] : tags.clone
      logger.tagged(tags) { logger.warn(message) }
    end
  end if thread_dump_signal

  if gc_log_microseconds && defined?(JRuby)
    listener = SemanticLogger::JRuby::GarbageCollectionLogger.new(gc_log_microseconds)
    Java::JavaLangManagement::ManagementFactory.getGarbageCollectorMXBeans.each do |gcbean|
      gcbean.add_notification_listener(listener, nil, nil)
    end
  end

  true
end

.appenders ⇒ Object

Returns [SemanticLogger::Appender::Base] a copy of the list of active appenders for debugging etc. Use SemanticLogger.add_appender and SemanticLogger.remove_appender to manipulate the active appenders list



147
148
149
 
# File 'lib/semantic_logger/semantic_logger.rb', line 147

def self.appenders
  @@appenders.clone
end

.backtrace_level ⇒ Object

Returns the current backtrace level



40
41
42
 
# File 'lib/semantic_logger/semantic_logger.rb', line 40

def self.backtrace_level
  @@backtrace_level
end

.backtrace_level=(level) ⇒ Object

Sets the level at which backtraces should be captured for every log message.

By enabling backtrace capture the filename and line number of where message was logged can be written to the log file. Additionally, the backtrace can be forwarded to error management services such as Bugsnag.

Warning:

Capturing backtraces is very expensive and should not be done all
the time. It is recommended to run it at :error level in production.



33
34
35
36
37
 
# File 'lib/semantic_logger/semantic_logger.rb', line 33

def self.backtrace_level=(level)
  @@backtrace_level       = level
  # For performance reasons pre-calculate the level index
  @@backtrace_level_index = level.nil? ? 65535 : level_to_index(level)
end

.backtrace_level_index ⇒ Object

Returns the current backtrace level index For internal use only



46
47
48
 
# File 'lib/semantic_logger/semantic_logger.rb', line 46

def self.backtrace_level_index #:nodoc
  @@backtrace_level_index
end

.default_level ⇒ Object

Returns the global default log level



19
20
21
 
# File 'lib/semantic_logger/semantic_logger.rb', line 19

def self.default_level
  @@default_level
end

.default_level=(level) ⇒ Object

Sets the global default log level



12
13
14
15
16
 
# File 'lib/semantic_logger/semantic_logger.rb', line 12

def self.default_level=(level)
  @@default_level       = level
  # For performance reasons pre-calculate the level index
  @@default_level_index = level_to_index(level)
end

.flush ⇒ Object

Wait until all queued log messages have been written and flush all active appenders



153
154
155
 
# File 'lib/semantic_logger/semantic_logger.rb', line 153

def self.flush
  SemanticLogger::Logger.flush
end

.on_metric(&block) ⇒ Object

Supply a block to be called whenever a metric is seen during benchmark logging

Parameters
  block
    The block to be called

Example:

SemanticLogger.on_metric do |log_struct|
  puts "#{log_struct.metric} was received. Log Struct: #{log_struct.inspect}"
end



177
178
179
 
# File 'lib/semantic_logger/semantic_logger.rb', line 177

def self.on_metric(&block)
  SemanticLogger::Logger.on_metric(&block)
end

.remove_appender(appender) ⇒ Object

Remove an existing appender Currently only supports appender instances



139
140
141
 
# File 'lib/semantic_logger/semantic_logger.rb', line 139

def self.remove_appender(appender)
  @@appenders.delete(appender)
end

.reopen ⇒ Object

After forking an active process call SemanticLogger.reopen to re-open any open file handles etc to resources

Note: Only appenders that implement the reopen method will be called



161
162
163
164
165
 
# File 'lib/semantic_logger/semantic_logger.rb', line 161

def self.reopen
  @@appenders.each { |appender| appender.reopen if appender.respond_to?(:reopen) }
  # After a fork the appender thread is not running, start it if it is not running
  SemanticLogger::Logger.start_appender_thread
end