Class: SemanticLogger::Logger

Inherits:
Base
  • Object
show all
Includes:
Concerns::Compatibility
Defined in:
lib/semantic_logger/logger.rb

Overview

Logger stores the class name to be used for all log messages so that every log message written by this instance will include the class name

Direct Known Subclasses

DebugAsTraceLogger

Class Attribute Summary collapse

Attributes inherited from Base

#filter, #name

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Concerns::Compatibility

#add, #close, included, #reopen

Methods inherited from Base

#backtrace, #fast_tag, #level, #level=, #measure, #named_tags, #pop_tags, #push_tags, #should_log?, #silence, #tagged, #tags

Constructor Details

#initialize(klass, level = nil, filter = nil) ⇒ Logger

Returns a Logger instance

Return the logger for a specific class, supports class specific log levels

logger = SemanticLogger::Logger.new(self)

OR

logger = SemanticLogger::Logger.new('MyClass')

Parameters:

klass
  A class, module or a string with the application/class name
  to be used in the logger

level
  The initial log level to start with for this logger instance
  Default: SemanticLogger.default_level

filter [Regexp|Proc]
  RegExp: Only include log messages where the class name matches the supplied
  regular expression. All other messages will be ignored
  Proc: Only include log messages where the supplied Proc returns true
        The Proc must return true or false



59
60
61
 
# File 'lib/semantic_logger/logger.rb', line 59

def initialize(klass, level = nil, filter = nil)
  super(klass, level, filter)
end

Class Attribute Details

.subscribers ⇒ Object (readonly)

Returns the value of attribute subscribers.



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

def subscribers
  @subscribers
end

Class Method Details

.call_subscribers(log) ⇒ Object 



80
81
82
83
84
85
86
87
88
 
# File 'lib/semantic_logger/logger.rb', line 80

def self.call_subscribers(log)
  return unless @subscribers

  @subscribers.each do |subscriber|
    subscriber.call(log)
  rescue Exception => e
    processor.logger.error("Exception calling :on_log subscriber", e)
  end
end

.processor ⇒ Object 



22
23
24
 
# File 'lib/semantic_logger/logger.rb', line 22

def self.processor
  @processor ||= Processor.new
end

.subscribe(object = nil, &block) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
 
# File 'lib/semantic_logger/logger.rb', line 7

def self.subscribe(object = nil, &block)
  subscriber = block || object

  unless subscriber.is_a?(Proc) || subscriber.respond_to?(:call)
    raise("When supplying an on_log subscriber, it must support the #call method")
  end

  subscribers = (@subscribers ||= Concurrent::Array.new)
  subscribers << subscriber unless subscribers.include?(subscriber)
end

.sync! ⇒ Object

Switch to the synchronous processor



27
28
29
30
31
 
# File 'lib/semantic_logger/logger.rb', line 27

def self.sync!
  return if @processor.is_a?(SyncProcessor)

  @processor = SyncProcessor.new(@processor&.appenders)
end

.sync? ⇒ Boolean

Running without the background logging thread?

Returns:

  • (Boolean) 


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

def self.sync?
  processor.is_a?(SyncProcessor)
end

Instance Method Details

#log(log, message = nil, progname = nil, &block) ⇒ Object

Place log request on the queue for the Appender thread to write to each appender in the order that they were registered

Subscribers are called inline before handing off to the queue so that they can capture additional context information as needed.



68
69
70
71
72
73
74
75
 
# File 'lib/semantic_logger/logger.rb', line 68

def log(log, message = nil, progname = nil, &block)
  # Compatibility with ::Logger
  return add(log, message, progname, &block) unless log.is_a?(SemanticLogger::Log)

  Logger.call_subscribers(log)

  Logger.processor.log(log)
end