class Padrino::Logger

Padrinos internal logger, using all of Padrino log extensions.

Constants

Config

Configuration for a given environment, possible options are:

:log_level

Once of [:fatal, :error, :warn, :info, :debug]

:stream

Once of [:to_file, :null, :stdout, :stderr] our your custom stream

:log_path

Defines log file path or directory if :stream is :to_file

If it's a file, its location is created by mkdir_p.
If it's a directory, it must exist. In this case log name is '<env>.log'
:log_level

The log level from, e.g. :fatal or :info. Defaults to :warn in the production environment and :debug otherwise.

:auto_flush

Whether the log should automatically flush after new messages are added. Defaults to true.

:format_datetime

Format of datetime. Defaults to: “%d/%b/%Y %H:%M:%S”

:format_message

Format of message. Defaults to: “”%s - - [%s] "%s"“”

:log_static

Whether or not to show log messages for static files. Defaults to: false

:colorize_logging

Whether or not to colorize log messages. Defaults to: true

@example

Padrino::Logger::Config[:development] = { :log_level => :debug, :stream => :to_file }
# or you can edit our defaults
Padrino::Logger::Config[:development][:log_level] = :error
# or change log file path
Padrino::Logger::Config[:development][:log_path] = 'logs/app-development.txt'
# or change log file directory
Padrino::Logger::Config[:development][:log_path] = '/var/logs/padrino'
# or you can use your stream
Padrino::Logger::Config[:development][:stream] = StringIO.new

Defaults are:

:production  => { :log_level => :warn, :stream => :to_file }
:development => { :log_level => :debug, :stream => :stdout }
:test        => { :log_level => :fatal, :stream => :null }

In some cases, configuring the loggers before loading the framework is necessary. You can do so by setting PADRINO_LOGGER:

PADRINO_LOGGER = { :staging => { :log_level => :debug, :stream => :to_file }}
Levels

Ruby (standard) logger levels:

:fatal

An not handleable error that results in a program crash

:error

A handleable error condition

:warn

A warning

:info

generic (useful) information about system operation

:debug

low-level information for developers

:devel

Development-related information that is unnecessary in debug mode

Attributes

auto_flush[RW]
buffer[R]
colorize_logging[R]
init_args[R]
level[RW]
log[R]
log_static[RW]

Public Class Methods

logger() click to toggle source
# File lib/padrino-core/logger.rb, line 320
def self.logger
  (@_logger ||= nil) || setup!
end
logger=(logger) click to toggle source
# File lib/padrino-core/logger.rb, line 324
    def self.logger=(logger)
      unless logger.class.ancestors.include?(Padrino::Logger::Extensions)
        warn <<-EOT
WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and other features.
          To do it with a custom logger you have to manually `new_logger.extend(Padrino::Logger::Extensions)`
          before passing to `Padrino.logger = new_logger`.
        EOT
      end
      @_logger = logger
    end
new(options={}) click to toggle source

To initialize the logger you create a new object, proxies to set_log.

@param [Hash] options

@option options [Symbol] :stream ($stdout)

Either an IO object or a name of a logfile. Defaults to $stdout

@option options [Symbol] :log_level (:production in the production environment and :debug otherwise)

The log level from, e.g. :fatal or :info.

@option options [Symbol] :auto_flush (true)

Whether the log should automatically flush after new messages are
added. Defaults to true.

@option options [Symbol] :format_datetime (“ [%d/%b/%Y %H:%M:%S] ”)

Format of datetime.

@option options [Symbol] :format_message (“%s -%s%s”)

Format of message.

@option options [Symbol] :log_static (false)

Whether or not to show log messages for static files.

@option options [Symbol] :colorize_logging (true)

Whether or not to colorize log messages. Defaults to: true.

@option options [Symbol] :sanitize_encoding (false)

Logger will replace undefined or broken characters with
“uFFFD” for Unicode and “?” otherwise.
Can be an encoding, false or true.
If it's true, logger sanitizes to Encoding.default_external.
# File lib/padrino-core/logger.rb, line 408
def initialize(options={})
  @buffer           = []
  @auto_flush       = options.has_key?(:auto_flush) ? options[:auto_flush] : true
  @level            = options[:log_level] ? Padrino::Logger::Levels[options[:log_level]] : Padrino::Logger::Levels[:debug]
  @log              = options[:stream]  || $stdout
  @log.sync         = true
  @format_datetime  = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
  @format_message   = options[:format_message]  || "%s - %s %s"
  @log_static       = options.has_key?(:log_static) ? options[:log_static] : false
  @colorize_logging = options.has_key?(:colorize_logging) ? options[:colorize_logging] : true
  @source_location  = options[:source_location]
  @sanitize_encoding = options[:sanitize_encoding] || false
  @sanitize_encoding = Encoding.default_external if @sanitize_encoding == true
  colorize! if @colorize_logging
end
setup!() click to toggle source

Setup a new logger.

@return [Padrino::Logger]

A {Padrino::Logger} instance
# File lib/padrino-core/logger.rb, line 341
def self.setup!
  config_level = (PADRINO_LOG_LEVEL || Padrino.env || :test).to_sym # need this for PADRINO_LOG_LEVEL
  config = Config[config_level]

  unless config
    warn("No logging configuration for :#{config_level} found, falling back to :production")
    config = Config[:production]
  end

  stream = case config[:stream]
    when :to_file
      if filename = config[:log_path]
        filename = Padrino.root(filename) unless Pathname.new(filename).absolute?
        if File.directory?(filename)
          filename = File.join(filename, "#{Padrino.env}.log")
        else
          FileUtils.mkdir_p(File.dirname(filename))
        end
        File.new(filename, 'a+')
      else
        FileUtils.mkdir_p(Padrino.root('log')) unless File.exist?(Padrino.root('log'))
        File.new(Padrino.root('log', "#{Padrino.env}.log"), 'a+')
      end
    when :null   then StringIO.new
    when :stdout then $stdout
    when :stderr then $stderr
    else config[:stream] # return itself, probabilly is a custom stream.
  end

  new_logger = Padrino::Logger.new(config.merge(:stream => stream))
  new_logger.extend(Padrino::Logger::Extensions)
  self.logger = new_logger
end

Public Instance Methods

<<(message = nil) click to toggle source

Directly append message to the log.

@param [String] message

The message
# File lib/padrino-core/logger.rb, line 466
def <<(message = nil)
  message << "\n" unless message[-1] == ?\n
  @@mutex.synchronize {
    @buffer << message
  }
  flush if @auto_flush
  message
end
Also aliased as: write
add(level, message = nil) click to toggle source

Adds a message to the log - for compatibility with other loggers.

# File lib/padrino-core/logger.rb, line 456
def add(level, message = nil)
  write(message)
end
close() click to toggle source

Close and remove the current log object.

@return [NilClass]

# File lib/padrino-core/logger.rb, line 447
def close
  flush
  @log.close if @log.respond_to?(:close) && !@log.tty?
  @log = nil
end
flush() click to toggle source

Flush the entire buffer to the log object.

# File lib/padrino-core/logger.rb, line 431
def flush
  return unless @buffer.size > 0
  @@mutex.synchronize do
    @buffer.each do |line|
      line.encode!(@sanitize_encoding, :invalid => :replace, :undef => :replace) if @sanitize_encoding
      @log.write(line)
    end
    @buffer.clear
  end
end
format(message, level) click to toggle source
# File lib/padrino-core/logger.rb, line 476
def format(message, level)
  @format_message % [stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
end
source_location?() click to toggle source
# File lib/padrino-core/logger.rb, line 424
def source_location?
  !!@source_location
end
write(message = nil)
Alias for: <<