module Bixby::Log

A simple logging mixin

Public Class Methods

bin_regex() click to toggle source
# File lib/bixby-common/util/log.rb, line 22
def bin_regex
  @bin_regex ||= %r{#{Gem.path.first}/(bin/.*)$}
end
clean_ex(ex, exclude_gems=true, exclude_dupes=true) click to toggle source

Created a cleaned up exception, suitable for printing to the console

This method should generally only be used for debugging as it can be quite slow.

@param [Exception] ex @param [Boolean] exclude_gems Whether or not to exclude all gems from the stacktrace (default: true) @param [Boolean] exclude_dupes When exclude_gems is set to false, omits duplicate gems from the stacktrace (default: true)

@return [String]

# File lib/bixby-common/util/log.rb, line 64
def clean_ex(ex, exclude_gems=true, exclude_dupes=true)
  puts self
  s = []
  s << "<#{ex.class}> #{ex.message}"

  last_gem = nil
  ex.backtrace.each do |e|
    if e =~ Log.gems_regex then
      next if exclude_gems
      gem_name = $2
      gem_ver  = $3
      trace    = $4
      gem_str = "#{gem_name} (#{gem_ver})"
      if !exclude_dupes || (last_gem.nil? || last_gem != gem_name) then
        s << "    #{gem_str} #{trace}"
      elsif exclude_dupes && last_gem == gem_name then
        # s << "    " + (" "*(gem_str.size+1)) + "..."
      end
      last_gem = gem_name

    elsif e =~ Log.bin_regex then
      next if exclude_gems
      rel_path = $1
      s << "    #{rel_path}"

    elsif e =~ Log.ruby_regex then
      next if exclude_gems
      last_gem = nil
      trace = $2
      s << "    ruby (#{RUBY_VERSION}) #{trace}"

    else
      s << "    #{e}"
    end
  end

  s.join("\n")
end
clean_ex_for_console(ex, logger) click to toggle source
# File lib/bixby-common/util/log.rb, line 51
def clean_ex_for_console(ex, logger)
  console?(logger) ? clean_ex(ex) : ex
end
console?(logger)
Alias for: console_appender?
console_appender?(logger) click to toggle source

Check whether the given logger is configured to append to the console (STDOUT)

@param [Logging::Logger] logger

@return [Boolean] true if writing to STDOUT

# File lib/bixby-common/util/log.rb, line 35
def console_appender?(logger)
  logger.appenders.each do |a|
    if a.kind_of? Logging::Appenders::Stdout then
      return true
    end
  end

  if logger.respond_to?(:parent) && logger.parent then
    return console_appender?(logger.parent)
  end

  false # at root
end
Also aliased as: console?, stdout?
gems_regex() click to toggle source
# File lib/bixby-common/util/log.rb, line 15
def gems_regex
  return @gems_regex if @gems_regex
  gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
  gems_paths << "#{Gem.path.first}/bundler" # include path for gems installed via git repo
  @gems_regex = %r{(#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
end
ruby_regex() click to toggle source
# File lib/bixby-common/util/log.rb, line 26
def ruby_regex
  @ruby_regex ||= %r{^#{ENV["MY_RUBY_HOME"]}/lib(/.*?)?/ruby/[\d.]+/(.*)$}
end
setup_logger(opts={}) click to toggle source

Setup logging

@param [Hash] opts Options for the rolling file appender @option opts [String] :filename Filename to log to @option opts [Symbol] :level Log level to use (default = :warn) @option opts [String] :pattern Log pattern

# File lib/bixby-common/util/log.rb, line 130
def self.setup_logger(opts={})

  # set level: ENV flag overrides; default to warn
  opts[:level] = ENV["BIXBY_LOG"] if ENV["BIXBY_LOG"]

  if opts[:level].nil? then
    # try to read from config file
    c = Bixby.path("etc", "bixby.yml")
    if File.exists? c then
      if config = YAML.load_file(c) then
        log_level = config["log_level"]
        log_level = log_level.strip.downcase if log_level.kind_of? String
        opts[:level] = log_level
      end
    end
  end

  opts[:level] ||= :info

  pattern = opts.delete(:pattern) || '%.1l, [%d] %5l -- %c:%L: %m\n'
  layout = Logging.layouts.pattern(:pattern => pattern)

  opts[:filename] ||= Bixby.path("var", "bixby-agent.log")
  log_dir = File.dirname(opts[:filename])
  FileUtils.mkdir_p(log_dir)

  # make sure we have the correct permissions
  if Process.uid == 0 then
    if !File.exists? opts[:filename] then
      FileUtils.touch([opts[:filename], opts[:filename] + ".age"])
    end
    File.chmod(0777, log_dir)
    File.chmod(0777, opts[:filename])
    File.chmod(0777, opts[:filename] + ".age")
  end

  # configure stdout appender (used in debug modes, etc)
  Logging.color_scheme( 'bright',
    :levels => {
      :info  => :green,
      :warn  => :yellow,
      :error => :red,
      :fatal => [:white, :on_red]
    },
    :date => :blue,
    :logger => :cyan,
    :message => :magenta
  )
  Logging.appenders.stdout( 'stdout',
    :auto_flushing => true,
    :layout => Logging.layouts.pattern(
      :pattern => pattern,
      :color_scheme => 'bright'
    )
  )

  # configure rolling file appender
  options = {
    :keep          => 7,
    :roll_by       => 'date',
    :age           => 'daily',
    :truncate      => false,
    :auto_flushing => true,
    :layout        => layout
  }.merge(opts)
  Logging.appenders.rolling_file("file", options)

  root = Logging::Logger.root
  root.add_appenders("file") if !root.appenders.find{ |a| a.name == "file" }
  root.level = opts[:level]
  root.trace = true

  # setup HTTPI logger
  HTTPI.log = true
  HTTPI.logger = Logging.logger[HTTPI]
end
stdout?(logger)
Alias for: console_appender?

Public Instance Methods

log() click to toggle source

Get a log instance for this class

@return [Logger]

# File lib/bixby-common/util/log.rb, line 107
def log
  @log ||= Logging.logger[self]
end
Also aliased as: logger
logger()
Alias for: log