module Trinidad::Logging

Constants

DefaultFormatter
FileHandler
JUL
LINE_SEP
LogFactory
MessageFormatter

A message formatter only prints the log message (and the thrown value).

Public Class Methods

configure(log_level = nil) click to toggle source

Configure the “global” Trinidad logging.

# File lib/trinidad/logging.rb, line 13
def self.configure(log_level = nil)
  return false if @@configured
  @@configured = true

  root_logger = JUL::Logger.getLogger('')
  level = parse_log_level(log_level, :INFO)

  out_handler = new_console_handler JRuby.runtime.out
  out_handler.formatter = console_formatter

  root_logger.synchronized do
    root_logger.handlers.to_a.each do |handler|
      root_logger.remove_handler(handler) if handler.is_a?(JUL::ConsoleHandler)
    end

    root_logger.add_handler(out_handler)
    if JRuby.runtime.out != Java::JavaLang::System.out ||
       JRuby.runtime.err != Java::JavaLang::System.err
     # NOTE: only add err handler if customized STDOUT or STDERR :
    err_handler = new_console_handler JRuby.runtime.err
    err_handler.formatter = console_formatter
    err_handler.level = level.intValue > JUL::Level::WARNING.intValue ?
      level : JUL::Level::WARNING # only >= WARNING on STDERR

     root_logger.add_handler(err_handler)
    end
    set_log_level(root_logger, level)
  end
  silence_tomcat_loggers

  root_logger
end
configure!(log_level = nil) click to toggle source

Force logging (re-)configuration. @see configure

# File lib/trinidad/logging.rb, line 48
def self.configure!(log_level = nil)
  ( @@configured = false ) || configure(log_level)
end
configure_web_app(web_app, context, reset = nil) click to toggle source

Configure logging for a web application.

# File lib/trinidad/logging.rb, line 57
def self.configure_web_app(web_app, context, reset = nil)
  param_name, param_value = 'jruby.rack.logging', 'JUL'
  # 1. delegate (jruby-rack) servlet log to JUL
  if set_value = web_app_context_param(web_app, context, param_name)
    return nil if set_value.upcase != param_value
  else
    context.add_parameter(param_name, param_value)
  end
  # 2. use Tomcat's JUL logger name (unless set) :
  param_name = 'jruby.rack.logging.name'
  unless logger_name = web_app_context_param(web_app, context, param_name)
    # for a context path e.g. '/foo' most likely smt of the following :
    # org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
    context.add_parameter(param_name, logger_name = context.send(:logName))
  end
  configure # make sure 'global' logging is configured

  logger = JUL::Logger.getLogger(logger_name) # exclusive for web app
  logger.handlers.each { |h| logger.remove_handler(h); h.close } if reset
  # avoid duplicate calls - do not configure (e.g. FileHandler) twice :
  return false unless logger.handlers.empty?

  logging = web_app.logging

  logger.level = parse_log_level(logging[:level], nil)
  # delegate to root (console) output only in development mode :
  logger.use_parent_handlers = logging[:use_parent_handlers]
  # logging:
  #  file:
  #    dir: log # [RAILS_ROOT]/log
  #    prefix: production
  #    suffix: .log
  if file = logging[:file]
    prefix, suffix = file[:prefix], file[:suffix] # {prefix}{date}{suffix}
    file_handler = FileHandler.new(file[:dir] || file[:directory], prefix, suffix)
    file_handler.rotatable = file.key?(:rotatable) ? file[:rotatable] : file[:rotate]
    file_handler.buffer_size = file[:buffer_size] if file[:buffer_size]
    format = file.key?(:format) ? file[:format] : logging[:format]
    file_handler.formatter = web_app_formatter(format) # nil uses default
    logger.add_handler(file_handler)
  end
  logger
end
configure_web_app!(web_app, context) click to toggle source
# File lib/trinidad/logging.rb, line 52
def self.configure_web_app!(web_app, context)
  configure_web_app!(web_app, context, true)
end

Protected Class Methods

console_formatter() click to toggle source
# File lib/trinidad/logging.rb, line 103
def self.console_formatter
  MessageFormatter.new
end
web_app_formatter(format = nil) click to toggle source
# File lib/trinidad/logging.rb, line 107
def self.web_app_formatter(format = nil)
  # format used by Rails "2012-06-13 16:42:21 +0200"
  DefaultFormatter.new(format.nil? ? 'yyyy-MM-dd HH:mm:ss Z' : format)
end

Private Class Methods

new_console_handler(stream) click to toggle source
# File lib/trinidad/logging.rb, line 156
def self.new_console_handler(stream)
  handler = JUL::ConsoleHandler.new # sets output stream to System.err
  handler.writer = nil if handler.respond_to?(:writer=) # avoid writer.close
  if handler.respond_to?(:sealed) && handler.sealed
    handler.sealed = false # avoid manager security checks
    handler.setOutputStream(stream) # closes previous writer if != null
    handler.sealed = true
  else
    handler.setOutputStream(stream)
  end
  handler
end
parse_log_level(log_level, default = nil) click to toggle source
# File lib/trinidad/logging.rb, line 114
def self.parse_log_level(log_level, default = nil)
  log_level = log_level && log_level.to_s.upcase
  unless JUL::Level.constants.find { |level| level.to_s == log_level }
    log_level = { # try mapping common level names to JUL names
      'ERROR' => 'SEVERE', 'WARN' => 'WARNING', 'DEBUG' => 'FINE'
    }[log_level]
    log_level = default ? default.to_s.upcase : nil unless log_level
  end
  JUL::Level.parse(log_level) if log_level
end
set_log_level(logger, level) click to toggle source
# File lib/trinidad/logging.rb, line 125
def self.set_log_level(logger, level)
  logger.level = level; LogFactory.getLog(logger.name)
end
silence_tomcat_loggers() click to toggle source
# File lib/trinidad/logging.rb, line 129
def self.silence_tomcat_loggers
  # org.apache.coyote.http11.Http11Protocol   INFO: Initializing ProtocolHandler ["http-bio-3000"]
  # org.apache.catalina.core.StandardService  INFO: Starting service Tomcat
  # org.apache.catalina.core.StandardEngine   INFO: Starting Servlet Engine: Apache Tomcat/7.0.27
  # org.apache.catalina.startup.ContextConfig INFO: No global web.xml found
  # org.apache.coyote.http11.Http11Protocol   INFO: Starting ProtocolHandler ["http-bio-3000"]
  level = JUL::Level::WARNING
  logger_names = [
    'org.apache.catalina.core.StandardService',
    'org.apache.catalina.core.StandardEngine',
    'org.apache.catalina.startup.ContextConfig',
  ]
  for name in logger_names
    logger = JUL::Logger.getLogger(name)
    set_log_level(logger, level) if logger
  end
end
web_app_context_param(web_app, context, name) click to toggle source
# File lib/trinidad/logging.rb, line 147
def self.web_app_context_param(web_app, context, name)
  context.find_parameter(name) || web_app.web_xml_context_param(name)
end

Private Instance Methods

formatThrown(record) click to toggle source
# File lib/trinidad/logging.rb, line 177
def formatThrown(record)
  if record.thrown
    writer = java.io.StringWriter.new(1024)
    print_writer = java.io.PrintWriter.new(writer)
    print_writer.println
    record.thrown.printStackTrace(print_writer)
    print_writer.close
    return writer.toString
  end
end