use modified opal logger

logger was having bizarre format errors
copied and simplified (to get on)
This commit is contained in:
Torsten Ruger 2018-05-20 14:45:48 +03:00
parent a350325b6b
commit a7a62d53b2
8 changed files with 694 additions and 58 deletions

View File

@ -1,51 +0,0 @@
# a simple module to be included into a class that want to log
#
# use the standard logger and the class name as the program name
#
# The standard functions are available on the log object
# And the log level may be set after inclusion with level function (that takes symbols)
require "logger"
module Logging
def self.included(base)
base.extend(Methods)
end
def log
self.class.log
end
module Methods
def log
return @logger if @logger
@logger = Logger.new log_stream
@logger.progname = self.name.split("::").last
@logger.datetime_format = '%M:%S'
@logger.level = Logger::INFO
@logger
end
def log_level l
log.level = case l
when :unknown
Logger::UNKNOWN
when :fatal
Logger::FATAL
when :error
Logger::ERROR
when :warn
Logger::WARN
when :info
Logger::INFO
when :debug
Logger::DEBUG
else
raise "unknown log level #{l}"
end
end
private
def log_stream
STDOUT
end
end
end

View File

@ -13,8 +13,8 @@ module Risc
class Interpreter
# fire events for changed pc and register contents
include Util::Eventable
include Logging
log_level :info
include Util::Logging
log_level :debug
attr_reader :instruction , :clock # current instruction or pc
attr_reader :registers # the registers, 16 (a hash, sym -> contents)

View File

@ -13,8 +13,8 @@ module Risc
#
class Machine
include Logging
log_level :info
include Util::Logging
log_level :debug
def initialize
@booted = false

View File

@ -13,7 +13,7 @@ module Risc
# we just add it to pointers.
class TextWriter
include Logging
include Util::Logging
log_level :info
def initialize(machine)

View File

@ -9,7 +9,7 @@ end
require "rx-file"
require_relative "logging"
require "util/logging"
require_relative "elf/object_writer"
require_relative "risc"
require_relative "arm/arm_machine"

635
lib/util/logger.rb Normal file
View File

@ -0,0 +1,635 @@
# Copied logger from logger gem.
# removed monitor for opal
# rmoevd shifting and file options
# == Description
#
# The Logger class provides a simple but sophisticated logging utility that
# you can use to output messages.
#
# The messages have associated
# levels, such as +INFO+ or +ERROR+ that indicate their importance.
# You can then give the Logger a level, and only messages at that
# level of higher will be printed.
#
# The levels are:
#
# +FATAL+:: an unhandleable 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
#
# For instance, in a production system, you may have your Logger set to
# +INFO+ or even +WARN+
# When you are developing the system, however, you probably
# want to know about the program's internal state, and would set the Logger to
# +DEBUG+.
#
# *Note*: Logger does not escape or sanitize any messages passed to it.
# Developers should be aware of when potentially malicious data (user-input)
# is passed to Logger, and manually escape the untrusted data:
#
# logger.info("User-input: #{input.dump}")
# logger.info("User-input: %p" % input)
#
# You can use #formatter= for escaping all data.
#
# original_formatter = Logger::Formatter.new
# logger.formatter = proc { |severity, datetime, progname, msg|
# original_formatter.call(severity, datetime, progname, msg.dump)
# }
# logger.info(input)
#
# === Example
#
# This creates a logger to the standard output stream, with a level of +WARN+
#
# log = Logger.new(STDOUT)
# log.level = Logger::WARN
#
# log.debug("Created logger")
# log.info("Program started")
# log.warn("Nothing to do!")
#
# begin
# File.each_line(path) do |line|
# unless line =~ /^(\w+) = (.*)$/
# log.error("Line in wrong format: #{line}")
# end
# end
# rescue => err
# log.fatal("Caught exception; exiting")
# log.fatal(err)
# end
#
# Because the Logger's level is set to +WARN+, only the warning, error, and
# fatal messages are recorded. The debug and info messages are silently
# discarded.
#
# === Features
#
# There are several interesting features that Logger provides, like
# auto-rolling of log files, setting the format of log messages, and
# specifying a program name in conjunction with the message. The next section
# shows you how to achieve these things.
#
#
# == HOWTOs
#
# === How to create a logger
#
# The options below give you various choices, in more or less increasing
# complexity.
#
# 1. Create a logger which logs messages to STDERR/STDOUT.
#
# logger = Logger.new(STDERR)
# logger = Logger.new(STDOUT)
#
# 2. Create a logger for the file which has the specified name.
#
# logger = Logger.new('logfile.log')
#
# 3. Create a logger for the specified file.
#
# file = File.open('foo.log', File::WRONLY | File::APPEND)
# # To create new (and to remove old) logfile, add File::CREAT like;
# # file = open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
# logger = Logger.new(file)
#
# 4. Create a logger which ages logfile once it reaches a certain size. Leave
# 10 "old log files" and each file is about 1,024,000 bytes.
#
# logger = Logger.new('foo.log', 10, 1024000)
#
# 5. Create a logger which ages logfile daily/weekly/monthly.
#
# logger = Logger.new('foo.log', 'daily')
# logger = Logger.new('foo.log', 'weekly')
# logger = Logger.new('foo.log', 'monthly')
#
# === How to log a message
#
# Notice the different methods (+fatal+, +error+, +info+) being used to log
# messages of various levels? Other methods in this family are +warn+ and
# +debug+. +add+ is used below to log a message of an arbitrary (perhaps
# dynamic) level.
#
# 1. Message in block.
#
# logger.fatal { "Argument 'foo' not given." }
#
# 2. Message as a string.
#
# logger.error "Argument #{ @foo } mismatch."
#
# 3. With progname.
#
# logger.info('initialize') { "Initializing..." }
#
# 4. With severity.
#
# logger.add(Logger::FATAL) { 'Fatal error!' }
#
# The block form allows you to create potentially complex log messages,
# but to delay their evaluation until and unless the message is
# logged. For example, if we have the following:
#
# logger.debug { "This is a " + potentially + " expensive operation" }
#
# If the logger's level is +INFO+ or higher, no debug messages will be logged,
# and the entire block will not even be evaluated. Compare to this:
#
# logger.debug("This is a " + potentially + " expensive operation")
#
# Here, the string concatenation is done every time, even if the log
# level is not set to show the debug message.
#
# === How to close a logger
#
# logger.close
#
# === Setting severity threshold
#
# 1. Original interface.
#
# logger.sev_threshold = Logger::WARN
#
# 2. Log4r (somewhat) compatible interface.
#
# logger.level = Logger::INFO
#
# DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
#
#
# == Format
#
# Log messages are rendered in the output stream in a certain format by
# default. The default format and a sample are shown below:
#
# Log format:
# SeverityID, [Date Time mSec #pid] SeverityLabel -- ProgName: message
#
# Log sample:
# I, [Wed Mar 03 02:34:24 JST 1999 895701 #19074] INFO -- Main: info.
#
#
# Or, you may change the overall format with #formatter= method.
#
# logger.formatter = proc do |severity, datetime, progname, msg|
# "#{datetime}: #{msg}\n"
# end
# # e.g. "Thu Sep 22 08:51:08 GMT+9:00 2005: hello world"
#
module Util
class Logger
VERSION = "1.2.8"
ProgName = "#{File.basename(__FILE__)}/#{VERSION}"
class Error < RuntimeError # :nodoc:
end
# not used after 1.2.7. just for compat.
class ShiftingError < Error # :nodoc:
end
# Logging severity.
module Severity
# Low-level information, mostly for developers
DEBUG = 0
# generic, useful information about system operation
INFO = 1
# a warning
WARN = 2
# a handleable error condition
ERROR = 3
# an unhandleable error that results in a program crash
FATAL = 4
# an unknown message that should always be logged
UNKNOWN = 5
end
include Severity
# Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
attr_accessor :level
# program name to include in log messages.
attr_accessor :progname
# Logging formatter, as a +Proc+ that will take four arguments and
# return the formatted message. The arguments are:
#
# +severity+:: The Severity of the log message
# +time+:: A Time instance representing when the message was logged
# +progname+:: The #progname configured, or passed to the logger method
# +msg+:: The _Object_ the user passed to the log message; not necessarily a String.
#
# The block should return an Object that can be written to the logging device via +write+. The
# default formatter is used when no formatter is set.
attr_accessor :formatter
alias sev_threshold level
alias sev_threshold= level=
# Returns +true+ iff the current severity level allows for the printing of
# +DEBUG+ messages.
def debug?; @level <= DEBUG; end
# Returns +true+ iff the current severity level allows for the printing of
# +INFO+ messages.
def info?; @level <= INFO; end
# Returns +true+ iff the current severity level allows for the printing of
# +WARN+ messages.
def warn?; @level <= WARN; end
# Returns +true+ iff the current severity level allows for the printing of
# +ERROR+ messages.
def error?; @level <= ERROR; end
# Returns +true+ iff the current severity level allows for the printing of
# +FATAL+ messages.
def fatal?; @level <= FATAL; end
#
# === Synopsis
#
# Logger.new(name)
# Logger.new(name)
#
# === Args
#
# +logdev+::
# The log device. This is a filename (String) or IO object (typically
# +STDOUT+, +STDERR+, or an open file).
#
# === Description
#
# Create an instance.
#
def initialize(logdev)
@progname = nil
@level = DEBUG
@default_formatter = Formatter.new
@formatter = nil
@logdev = nil
if logdev
@logdev = LogDevice.new(logdev)
end
end
#
# === Synopsis
#
# Logger#add(severity, message = nil, progname = nil) { ... }
#
# === Args
#
# +severity+::
# Severity. Constants are defined in Logger namespace: +DEBUG+, +INFO+,
# +WARN+, +ERROR+, +FATAL+, or +UNKNOWN+.
# +message+::
# The log message. A String or Exception.
# +progname+::
# Program name string. Can be omitted. Treated as a message if no
# +message+ and +block+ are given.
# +block+::
# Can be omitted. Called to get a message string if +message+ is nil.
#
# === Return
#
# +true+ if successful, +false+ otherwise.
#
# When the given severity is not high enough (for this particular logger), log
# no message, and return +true+.
#
# === Description
#
# Log a message if the given severity is high enough. This is the generic
# logging method. Users will be more inclined to use #debug, #info, #warn,
# #error, and #fatal.
#
# <b>Message format</b>: +message+ can be any object, but it has to be
# converted to a String in order to log it. Generally, +inspect+ is used
# if the given object is not a String.
# A special case is an +Exception+ object, which will be printed in detail,
# including message, class, and backtrace. See #msg2str for the
# implementation if required.
#
# === Bugs
#
# * Logfile is not locked.
# * Append open does not need to lock file.
# * If the OS which supports multi I/O, records possibly be mixed.
#
def add(severity, message = nil, progname = nil, &block)
severity ||= UNKNOWN
if @logdev.nil? or severity < @level
return true
end
progname ||= @progname
if message.nil?
if block_given?
message = yield
else
message = progname
progname = @progname
end
end
@logdev.write(
format_message(format_severity(severity), Time.now, progname, message))
true
end
alias log add
#
# Dump given message to the log device without any formatting. If no log
# device exists, return +nil+.
#
def <<(msg)
unless @logdev.nil?
@logdev.write(msg)
end
end
#
# Log a +DEBUG+ message.
#
# See #info for more information.
#
def debug(progname = nil, &block)
add(DEBUG, nil, progname, &block)
end
#
# :call-seq:
# info(message)
# info(progname,&block)
#
# Log an +INFO+ message.
#
# +message+:: the message to log; does not need to be a String
# +progname+:: in the block form, this is the #progname to use in the
# the log message. The default can be set with #progname=
# <tt>&block</tt>:: evaluates to the message to log. This is not evaluated
# unless the logger's level is sufficient
# to log the message. This allows you to create
# potentially expensive logging messages that are
# only called when the logger is configured to show them.
#
# === Examples
#
# logger.info("MainApp") { "Received connection from #{ip}" }
# # ...
# logger.info "Waiting for input from user"
# # ...
# logger.info { "User typed #{input}" }
#
# You'll probably stick to the second form above, unless you want to provide a
# program name (which you can do with #progname= as well).
#
# === Return
#
# See #add.
#
def info(progname = nil, &block)
add(INFO, nil, progname, &block)
end
#
# Log a +WARN+ message.
#
# See #info for more information.
#
def warn(progname = nil, &block)
add(WARN, nil, progname, &block)
end
#
# Log an +ERROR+ message.
#
# See #info for more information.
#
def error(progname = nil, &block)
add(ERROR, nil, progname, &block)
end
#
# Log a +FATAL+ message.
#
# See #info for more information.
#
def fatal(progname = nil, &block)
add(FATAL, nil, progname, &block)
end
#
# Log an +UNKNOWN+ message. This will be printed no matter what the logger's
# level.
#
# See #info for more information.
#
def unknown(progname = nil, &block)
add(UNKNOWN, nil, progname, &block)
end
#
# Close the logging device.
#
def close
@logdev.close if @logdev
end
private
# Severity label for logging. (max 5 char)
SEV_LABEL = %w(DEBUG INFO WARN ERROR FATAL ANY)
def format_severity(severity)
SEV_LABEL[severity] || 'ANY'
end
def format_message(severity, datetime, progname, msg)
(@formatter || @default_formatter).call(severity, datetime, progname, msg)
end
# Default formatter for log messages
class Formatter
def call(severity, time, progname, msg)
"#{severity} #{progname} #{time.strftime("%M-%S-%L")} #{progname}::#{msg2str(msg)}\n"
end
private
def msg2str(msg)
case msg
when ::String
msg
when ::Exception
"#{ msg.message } (#{ msg.class })\n" <<
(msg.backtrace || []).join("\n")
else
msg.inspect
end
end
end
# Device used for logging messages.
class LogDevice
attr_reader :dev
attr_reader :filename
def initialize(log)
@dev = log
end
def write(message)
@dev.write(message)
end
def close
begin
@dev.close rescue nil
rescue Exception
@dev.close rescue nil
end
end
private
SiD = 24 * 60 * 60
def eod(t)
Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
end
end
#
# == Description
#
# Application -- Add logging support to your application.
#
# == Usage
#
# 1. Define your application class as a sub-class of this class.
# 2. Override 'run' method in your class to do many things.
# 3. Instantiate it and invoke 'start'.
#
# == Example
#
# class FooApp < Application
# def initialize(foo_app, application_specific, arguments)
# super('FooApp') # Name of the application.
# end
#
# def run
# ...
# log(WARN, 'warning', 'my_method1')
# ...
# @log.error('my_method2') { 'Error!' }
# ...
# end
# end
#
# status = FooApp.new(....).start
#
class Application
include Logger::Severity
# Name of the application given at initialize.
attr_reader :appname
#
# == Synopsis
#
# Application.new(appname = '')
#
# == Args
#
# +appname+:: Name of the application.
#
# == Description
#
# Create an instance. Log device is +STDERR+ by default. This can be
# changed with #set_log.
#
def initialize(appname = nil)
@appname = appname
@log = Logger.new(STDERR)
@log.progname = @appname
@level = @log.level
end
#
# Start the application. Return the status code.
#
def start
status = -1
begin
log(INFO, "Start of #{ @appname }.")
status = run
rescue
log(FATAL, "Detected an exception. Stopping ... #{$!} (#{$!.class})\n" << $@.join("\n"))
ensure
log(INFO, "End of #{ @appname }. (status: #{ status.to_s })")
end
status
end
# Logger for this application. See the class Logger for an explanation.
def logger
@log
end
#
# Sets the logger for this application. See the class Logger for an explanation.
#
def logger=(logger)
@log = logger
@log.progname = @appname
@log.level = @level
end
#
# Sets the log device for this application. See <tt>Logger.new</tt> for an explanation
# of the arguments.
#
def set_log(logdev)
@log = Logger.new(logdev)
@log.progname = @appname
@log.level = @level
end
def log=(logdev)
set_log(logdev)
end
#
# Set the logging threshold, just like <tt>Logger#level=</tt>.
#
def level=(level)
@level = level
@log.level = @level
end
#
# See Logger#add. This application's +appname+ is used.
#
def log(severity, message = nil, &block)
@log.add(severity, message, @appname, &block) if @log
end
private
def run
# TODO: should be an NotImplementedError
raise RuntimeError.new('Method run must be defined in the derived class.')
end
end
end
end

52
lib/util/logging.rb Normal file
View File

@ -0,0 +1,52 @@
# a simple module to be included into a class that want to log
#
# use the standard logger and the class name as the program name
#
# The standard functions are available on the log object
# And the log level may be set after inclusion with level function (that takes symbols)
require_relative "logger"
module Util
module Logging
def self.included(base)
base.extend(Methods)
end
def log
self.class.log
end
module Methods
def log
return @logger if @logger
@logger = Logger.new log_stream
@logger.progname = self.name.split("::").last
@logger.level = Logger::INFO
@logger
end
def log_level l
log.level = case l
when :unknown
Logger::UNKNOWN
when :fatal
Logger::FATAL
when :error
Logger::ERROR
when :warn
Logger::WARN
when :info
Logger::INFO
when :debug
Logger::DEBUG
else
raise "unknown log level #{l}"
end
end
private
def log_stream
STDOUT
end
end
end
end

View File

@ -7,7 +7,7 @@ class MemLogger
def self.log_stream
@stream = StringIO.new
end
include Logging
include Util::Logging
end
class LoggerTest < MiniTest::Test