class Logster::Logger

Constants

LOGSTER_ENV

Attributes

chained[R]
skip_store[RW]
store[RW]

Public Class Methods

new(store) click to toggle source
Calls superclass method
# File lib/logster/logger.rb, line 12
def initialize(store)
  super(nil)
  @store = store
  @override_levels = nil
  @chained = []
  @skip_store = false
end

Public Instance Methods

add(*args, &block) click to toggle source
# File lib/logster/logger.rb, line 53
def add(*args, &block)
  add_with_opts(*args, &block)
end
add_to_chained(logger, severity, message, progname, opts = nil, &block) click to toggle source
# File lib/logster/logger.rb, line 36
def add_to_chained(logger, severity, message, progname, opts = nil, &block)
  if logger.respond_to? :skip_store
    old = logger.skip_store
    logger.skip_store = @skip_store
  end

  if logger.is_a?(Logster::Logger)
    logger.add(severity, message, progname, opts, &block)
  else
    logger.add(severity, message, progname, &block)
  end
ensure
  if logger.respond_to? :skip_store
    logger.skip_store = old
  end
end
add_with_opts(severity, message = nil, progname = progname(), opts = nil) { || ... } click to toggle source
# File lib/logster/logger.rb, line 62
def add_with_opts(severity, message = nil, progname = progname(), opts = nil, &block)
  if severity < level
    return true
  end

  # it is not fun losing messages cause encoding is bad
  # protect all messages by scrubbing if needed
  if message && !message.valid_encoding?
    message = message.scrub
  end

  # we want to get the backtrace as early as possible so that logster's
  # own methods don't show up as the first few frames in the backtrace
  if !opts || !opts.key?(:backtrace)
    opts ||= {}
    backtrace = caller_locations
    while backtrace.first.path.end_with?("/logger.rb")
      backtrace.shift
    end
    backtrace = backtrace.join("\n")
    opts[:backtrace] = backtrace
  end

  if @chained
    i = 0
    # micro optimise for logging
    while i < @chained.length
      # TODO double yielding blocks
      begin
        add_to_chained(@chained[i], severity, message, progname, opts, &block)
      rescue => e
        # don't blow up if STDERR is somehow closed
        STDERR.puts "Failed to report message to chained logger #{e}" rescue nil
      end
      i += 1
    end
  end

  progname ||= @progname
  if message.nil?
    if block_given?
      message = yield
    else
      message = progname
      progname = @progname
    end
  end

  return if @skip_store

  opts ||= {}
  opts[:env] ||= Thread.current[LOGSTER_ENV]

  report_to_store(severity, progname, message, opts)
rescue => e
  # don't blow up if STDERR is somehow closed
  STDERR.puts "Failed to report error: #{e} #{severity} #{message} #{progname}" rescue nil
end
chain(logger) click to toggle source
# File lib/logster/logger.rb, line 32
def chain(logger)
  @chained << logger
end
level() click to toggle source
# File lib/logster/logger.rb, line 57
def level
  ol = @override_levels
  (ol && ol[Thread.current.object_id]) || @level
end
override_level=(val) click to toggle source
# File lib/logster/logger.rb, line 20
def override_level=(val)
  tid = Thread.current.object_id

  ol = @override_levels
  if val.nil? && ol && ol.key?(tid)
    ol.delete(tid)
    @override_levels = nil if ol.length == 0
  elsif val
    (@override_levels ||= {})[tid] = val
  end
end

Private Instance Methods

report_to_store(severity, progname, message, opts = {}) click to toggle source
# File lib/logster/logger.rb, line 123
def report_to_store(severity, progname, message, opts = {})
  @store.report(severity, progname, message, opts)
end