Browse Source
Now `LoggerAPI`, instead of simply loggin messages by itself, uses logger objects (deriving from `Logger` class) to output log messages for it (previous way of logging by `Log()` method is available by `ConsoleLogger`). Multiple loggers can be configured per each log level, which can be done via config.pull/8/head
20 changed files with 1152 additions and 278 deletions
@ -0,0 +1,41 @@ |
|||||||
|
/** |
||||||
|
* Simple logger class that uses `Log` method to print all of the |
||||||
|
* log messages. Supports all of the default `acediaStamp`, `timeStamp` and |
||||||
|
* `levelStamp` settings |
||||||
|
* Copyright 2021 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class ConsoleLogger extends Logger |
||||||
|
perObjectConfig |
||||||
|
config(AcediaSystem) |
||||||
|
dependson(LoggerAPI); |
||||||
|
|
||||||
|
public function Write(Text message, LoggerAPI.LogLevel messageLevel) |
||||||
|
{ |
||||||
|
local MutableText builder; |
||||||
|
if (message != none) |
||||||
|
{ |
||||||
|
builder = GetPrefix(messageLevel); |
||||||
|
builder.Append(message); |
||||||
|
Log(builder.ToPlainString()); |
||||||
|
builder.FreeSelf(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
@ -0,0 +1,355 @@ |
|||||||
|
/** |
||||||
|
* Object of this class is meant to represent a single log message that |
||||||
|
* can have parameters, specified by "%<number>" definitions |
||||||
|
* (e.g. "Thing %1 conflicts with thing %2, so we will have to remove %3"). |
||||||
|
* Log message only has to prepare (break into parts) provided human-readable |
||||||
|
* string once and then will be able to quickly perform argument insertion |
||||||
|
* (for which several convenient `Arg*()` methods are provided). |
||||||
|
* The supposed way to use `LogMessage` is is in conjunction with |
||||||
|
* `LoggerAPI`'s `Auto()` method that takes `Definition` with pre-filled |
||||||
|
* message (`m`) and type (`t`), then: |
||||||
|
* 1. (first time only) Generates a new `LogMessage` from them; |
||||||
|
* 2. Returns `LogMessage` object that, whos arguments are supposed to be |
||||||
|
* filled with `Arg*()` methods; |
||||||
|
* 3. When the appropriate amount of `Arg*()` calls (by the number of |
||||||
|
* specified "%<number>" tags) was made - logs resulting message. |
||||||
|
* (4). If message takes no arguments - no `Arg*()` calls are necessary; |
||||||
|
* (5). If new `Auto()` call is made before previous message was provided |
||||||
|
* enough arguments - error will be logged and previous message |
||||||
|
* will be discarded (along with it's arguments). |
||||||
|
* For more information about using it - refer to the documentation. |
||||||
|
* Copyright 2021 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class LogMessage extends AcediaObject; |
||||||
|
|
||||||
|
// Flag to prevent `Initialize()` being called several times in a row |
||||||
|
var private bool isInitialized; |
||||||
|
// With what level was this message initialized? |
||||||
|
var private LoggerAPI.LogLevel myLevel; |
||||||
|
|
||||||
|
/** |
||||||
|
* We essentially break specified log string into parts |
||||||
|
* (replacing empty parts with `none`) like this: |
||||||
|
* "This %1 is %3, not %2" => |
||||||
|
* * "This " |
||||||
|
* * " is " |
||||||
|
* * ", not " |
||||||
|
* * `none` |
||||||
|
* Arguments always fit between these parts, so if there is `N` parts, |
||||||
|
* there will be `N - 1` arguments. We consider that we are done filling |
||||||
|
* arguments when amount of `Arg*()` calls reaches that number. |
||||||
|
* |
||||||
|
* For future localization purposes we do not assume that arguments are |
||||||
|
* specified from left to right in order: in our example, |
||||||
|
* if we make following calls: `.Arg("one").Arg("caged").Arg("free")`, |
||||||
|
* we will get the string: "This one is free, not caged". |
||||||
|
* To remember the order we keep a special array, in our case it would be |
||||||
|
* [1, 3, 2], except normalized to start from zero: [0, 2, 1]. |
||||||
|
*/ |
||||||
|
// Parts of the initial message, broken by "%<number> tags |
||||||
|
var private array<Text> logParts; |
||||||
|
// Defines order of arguments: |
||||||
|
// `i` -> argument at what number to use at insertion place `i`? |
||||||
|
// (`i` starting from zero instead of `1`). |
||||||
|
var private array<int> normalizedArguments; |
||||||
|
|
||||||
|
// Only default value is used for this variable: it remembers what |
||||||
|
// `LogMessage` currently stores "garbage": temporary `Text` object to create |
||||||
|
// a log message. Making an `Arg*()` call on any other `LogMessage` will cause |
||||||
|
// progress of `default.dirtyLogMessage` to be reset, thus enforcing that only |
||||||
|
// one `LogMessage` can be in the process of filling itself with arguments at |
||||||
|
// a time and, therefore, only one can be "dirty": contain temporary |
||||||
|
// `Text` objects. |
||||||
|
// This way using `LogMessage` would not lead to accumulating large |
||||||
|
// amounts of trash objects, since only one of them can "make a mess". |
||||||
|
var private LogMessage dirtyLogMessage; |
||||||
|
// Arguments, collected so far by the `Arg*()` calls |
||||||
|
var private array<Text> collectedArguments; |
||||||
|
|
||||||
|
protected function Finalizer() |
||||||
|
{ |
||||||
|
isInitialized = false; |
||||||
|
_.memory.FreeMany(logParts); |
||||||
|
_.memory.FreeMany(collectedArguments); |
||||||
|
logParts.length = 0; |
||||||
|
collectedArguments.length = 0; |
||||||
|
normalizedArguments.length = 0; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Initialize new `LogMessage` object by a given definition. |
||||||
|
* Can only be done once. |
||||||
|
* |
||||||
|
* Correct functionality is guaranteed when arguments start from either |
||||||
|
* `0` or `1` and then increase in order, without gaps or repetitions. |
||||||
|
* `Initialize()` will attempt to correctly initialize `LogMessage` in case |
||||||
|
* these rules are broken, by making assumptions about user's intentions, |
||||||
|
* but behavior in that case should be considered undefined. |
||||||
|
* |
||||||
|
* @param logMessageDefinition Definition to take message parameter from. |
||||||
|
*/ |
||||||
|
public final function Initialize(LoggerAPI.Definition logMessageDefinition) |
||||||
|
{ |
||||||
|
local int nextArgument; |
||||||
|
local Parser parser; |
||||||
|
local MutableText nextLogPart, nextChunk; |
||||||
|
local Text.Character percentCharacter; |
||||||
|
local array<int> parsedArguments; |
||||||
|
if (isInitialized) { |
||||||
|
return; |
||||||
|
} |
||||||
|
isInitialized = true; |
||||||
|
myLevel = logMessageDefinition.l; |
||||||
|
percentCharacter = _.text.GetCharacter("%"); |
||||||
|
parser = _.text.ParseString(logMessageDefinition.m); |
||||||
|
nextLogPart = _.text.Empty(); |
||||||
|
// General idea is simply to repeat: parse until "%" -> parse "%<number>" |
||||||
|
while (!parser.HasFinished()) |
||||||
|
{ |
||||||
|
parser.MUntil(nextChunk, percentCharacter).Confirm(); |
||||||
|
nextLogPart.Append(nextChunk); |
||||||
|
// If we cannot parse "%" after `MUntil(nextChunk, percentCharacter)`, |
||||||
|
// then we have parsed everything |
||||||
|
if (!parser.Match(P("%")).Confirm()) { |
||||||
|
break; |
||||||
|
} |
||||||
|
// We need to check whether it i really "%<number>" tag and not |
||||||
|
// just a "%" symbol without number |
||||||
|
if (parser.MInteger(nextArgument).Confirm()) |
||||||
|
{ |
||||||
|
parsedArguments[parsedArguments.length] = nextArgument; |
||||||
|
logParts[logParts.length] = nextLogPart.Copy(); |
||||||
|
nextLogPart.Clear(); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
// If it is just a symbol - simply add it |
||||||
|
nextLogPart.AppendCharacter(percentCharacter); |
||||||
|
parser.R(); |
||||||
|
} |
||||||
|
} |
||||||
|
logParts[logParts.length] = nextLogPart.Copy(); |
||||||
|
parser.FreeSelf(); |
||||||
|
nextLogPart.FreeSelf(); |
||||||
|
CleanupEmptyLogParts(); |
||||||
|
NormalizeArguments(parsedArguments); |
||||||
|
} |
||||||
|
|
||||||
|
// Since `none` and empty `Text` will be treated the same way by the `Append()` |
||||||
|
// operation, we do not need to keep empty `Text` objects and can simply |
||||||
|
// replace them with `none`s |
||||||
|
private final function CleanupEmptyLogParts() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
for (i = 0; i < logParts.length; i += 1) |
||||||
|
{ |
||||||
|
if (logParts[i].IsEmpty()) |
||||||
|
{ |
||||||
|
logParts[i].FreeSelf(); |
||||||
|
logParts[i] = none; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Normalize enumeration by replacing them with natural numbers sequence: |
||||||
|
// [0, 1, 2, ...] in the same order: |
||||||
|
// [2, 6, 3] -> [0, 2, 1] |
||||||
|
// [-2, 0, 4, -7] -> [1, 2, 3, 0] |
||||||
|
// [1, 1, 2, 1] -> [0, 1, 3, 2] |
||||||
|
private final function NormalizeArguments(array<int> argumentsOrder) |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
local int nextArgument; |
||||||
|
local int lowestArgument, lowestArgumentIndex; |
||||||
|
normalizedArguments.length = 0; |
||||||
|
normalizedArguments.length = argumentsOrder.length; |
||||||
|
while (nextArgument < normalizedArguments.length) |
||||||
|
{ |
||||||
|
// Find next minimal index and record next natural number |
||||||
|
// (`nextArgument`) into it |
||||||
|
for (i = 0; i < argumentsOrder.length; i += 1) |
||||||
|
{ |
||||||
|
if (argumentsOrder[i] < lowestArgument || i == 0) |
||||||
|
{ |
||||||
|
lowestArgumentIndex = i; |
||||||
|
lowestArgument = argumentsOrder[i]; |
||||||
|
} |
||||||
|
} |
||||||
|
argumentsOrder[lowestArgumentIndex] = MaxInt; |
||||||
|
normalizedArguments[lowestArgumentIndex] = nextArgument; |
||||||
|
nextArgument += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills next argument in caller `LogMessage` with given `Text` argument. |
||||||
|
* |
||||||
|
* When used on `LogMessage` returned from `LoggerAPI.Auto()` call - filling |
||||||
|
* all arguments leads to message being logged. |
||||||
|
* |
||||||
|
* @param argument This argument will be managed by the `LogMessage`: |
||||||
|
* you should not deallocate it by hand or rely on passed `Text` to not |
||||||
|
* be deallocated. This also means that you should not pass `Text` objects |
||||||
|
* returned by `P()`, `C()` or `F()` calls. |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage Arg(Text argument) |
||||||
|
{ |
||||||
|
local Text assembledMessage; |
||||||
|
if (IsArgumentListFull()) { |
||||||
|
return self; |
||||||
|
} |
||||||
|
// Do we need to clean old `LogMessage` from it's arguments first? |
||||||
|
if (default.dirtyLogMessage != none && default.dirtyLogMessage != self) { |
||||||
|
default.dirtyLogMessage.Reset(); |
||||||
|
} |
||||||
|
default.dirtyLogMessage = self; // `self` is dirty with arguments now |
||||||
|
collectedArguments[collectedArguments.length] = argument; |
||||||
|
if (IsArgumentListFull()) |
||||||
|
{ |
||||||
|
// Last argument - have to log what we have collected |
||||||
|
assembledMessage = Collect(); |
||||||
|
_.logger.LogAtLevel(assembledMessage, myLevel); |
||||||
|
assembledMessage.FreeSelf(); |
||||||
|
return self; |
||||||
|
} |
||||||
|
return self; |
||||||
|
} |
||||||
|
|
||||||
|
// Check whether we have enough arguments to completely make log message: |
||||||
|
// each argument goes in between two log parts, so there is |
||||||
|
// `logParts.length - 1` arguments total. |
||||||
|
private final function bool IsArgumentListFull() |
||||||
|
{ |
||||||
|
return collectedArguments.length >= logParts.length - 1; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills next argument in caller `LogMessage` with given `int` argument. |
||||||
|
* |
||||||
|
* When used on `LogMessage` returned from `LoggerAPI.Auto()` call - filling |
||||||
|
* all arguments leads to message being logged. |
||||||
|
* |
||||||
|
* @param argument This value will be converted into `Text` and pasted |
||||||
|
* into the log message. |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage ArgInt(int argument) |
||||||
|
{ |
||||||
|
return Arg(_.text.FromInt(argument)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills next argument in caller `LogMessage` with given `float` argument. |
||||||
|
* |
||||||
|
* When used on `LogMessage` returned from `LoggerAPI.Auto()` call - filling |
||||||
|
* all arguments leads to message being logged. |
||||||
|
* |
||||||
|
* @param argument This value will be converted into `Text` and pasted |
||||||
|
* into the log message. |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage ArgFloat(float argument) |
||||||
|
{ |
||||||
|
return Arg(_.text.FromFloat(argument)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills next argument in caller `LogMessage` with given `bool` argument. |
||||||
|
* |
||||||
|
* When used on `LogMessage` returned from `LoggerAPI.Auto()` call - filling |
||||||
|
* all arguments leads to message being logged. |
||||||
|
* |
||||||
|
* @param argument This value will be converted into `Text` and pasted |
||||||
|
* into the log message. |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage ArgBool(bool argument) |
||||||
|
{ |
||||||
|
return Arg(_.text.FromBool(argument)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Fills next argument in caller `LogMessage` with given `class<Object>` |
||||||
|
* argument. |
||||||
|
* |
||||||
|
* When used on `LogMessage` returned from `LoggerAPI.Auto()` call - filling |
||||||
|
* all arguments leads to message being logged. |
||||||
|
* |
||||||
|
* @param argument This value will be converted into `Text` and pasted |
||||||
|
* into the log message. |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage ArgClass(class<Object> argument) |
||||||
|
{ |
||||||
|
return Arg(_.text.FromClass(argument)); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Resets current progress of filling caller `LogMessage` with arguments, |
||||||
|
* deallocating already passed ones. |
||||||
|
* |
||||||
|
* @return Caller `LogMessage` to allow for method chaining. |
||||||
|
*/ |
||||||
|
public final function LogMessage Reset() |
||||||
|
{ |
||||||
|
_.memory.FreeMany(collectedArguments); |
||||||
|
collectedArguments.length = 0; |
||||||
|
return self; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Returns `LogMessage`, assembled with it's arguments into the `Text`. |
||||||
|
* |
||||||
|
* If some arguments were not yet filled - they will treated as empty `Text` |
||||||
|
* values. |
||||||
|
* |
||||||
|
* This result will be reset if `Reset()` method is called or another |
||||||
|
* `LogMessage` starts filling itself with arguments. |
||||||
|
* |
||||||
|
* @return Caller `LogMessage`, assembled with it's arguments into the `Text`. |
||||||
|
*/ |
||||||
|
public final function Text Collect() |
||||||
|
{ |
||||||
|
local int i, argumentIndex; |
||||||
|
local Text result; |
||||||
|
local Text nextArgument; |
||||||
|
local MutableText builder; |
||||||
|
if (logParts.length == 0) { |
||||||
|
return P("").Copy(); |
||||||
|
} |
||||||
|
builder = _.text.Empty(); |
||||||
|
for (i = 0; i < logParts.length - 1; i += 1) |
||||||
|
{ |
||||||
|
nextArgument = none; |
||||||
|
// Since arguments might not be specified in order - |
||||||
|
argumentIndex = normalizedArguments[i]; |
||||||
|
if (argumentIndex < collectedArguments.length) { |
||||||
|
nextArgument = collectedArguments[argumentIndex]; |
||||||
|
} |
||||||
|
builder.Append(logParts[i]).Append(nextArgument); |
||||||
|
} |
||||||
|
builder.Append(logParts[logParts.length - 1]); |
||||||
|
result = builder.Copy(); |
||||||
|
builder.FreeSelf(); |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
@ -0,0 +1,151 @@ |
|||||||
|
/** |
||||||
|
* Base class for implementing "loggers" - objects that actually write log |
||||||
|
* messages somewhere. To use it - simply implement `Write()` method, |
||||||
|
* preferably making use of `GetPrefix()` method. |
||||||
|
* Copyright 2021 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class Logger extends AcediaObject |
||||||
|
perObjectConfig |
||||||
|
config(AcediaSystem) |
||||||
|
dependson(LoggerAPI) |
||||||
|
abstract; |
||||||
|
|
||||||
|
// Named loggers are stored here to avoid recreating them |
||||||
|
var private AssociativeArray loadedLoggers; |
||||||
|
|
||||||
|
// Should `Logger` display prefix indicating it's a log message from Acedia? |
||||||
|
var protected config bool acediaStamp; |
||||||
|
// Should `Logger` display time stamp prefix in front of log messages? |
||||||
|
var protected config bool timeStamp; |
||||||
|
// Should `Logger` display information about what level message was logged? |
||||||
|
var protected config bool levelStamp; |
||||||
|
|
||||||
|
var protected const int TDEBUG, TINFO, TWARNING, TERROR, TFATAL, TTIME, TACEDIA; |
||||||
|
var protected const int TSPACE; |
||||||
|
|
||||||
|
/** |
||||||
|
* Method for creating named `Logger`s that can have their settings prepared |
||||||
|
* in the config file. Only one `Logger` is made for every |
||||||
|
* unique (case insensitive) `loggerName`. |
||||||
|
* |
||||||
|
* @param loggerName Name of the logger instance to return. Consequent calls |
||||||
|
* with the same `loggerName` value will return the same `Logger`, |
||||||
|
* unless it is deallocated. |
||||||
|
* @return Logger with object name `loggerName`. |
||||||
|
*/ |
||||||
|
public final static function Logger GetLogger(Text loggerName) |
||||||
|
{ |
||||||
|
local Logger loggerInstance; |
||||||
|
local Text loggerKey; |
||||||
|
if (default.loadedLoggers == none) |
||||||
|
{ |
||||||
|
// TODO: do this in static constructor |
||||||
|
default.loadedLoggers = __().collections.EmptyAssociativeArray(); |
||||||
|
} |
||||||
|
if (loggerName == none) { |
||||||
|
return none; |
||||||
|
} |
||||||
|
loggerKey = loggerName.LowerCopy(); |
||||||
|
loggerInstance = Logger(default.loadedLoggers.GetItem(loggerKey)); |
||||||
|
if (loggerInstance == none) |
||||||
|
{ |
||||||
|
// TODO: important to redo this via `MemoryAPI` to call constructors |
||||||
|
loggerInstance = new(none, loggerName.ToPlainString()) default.class; |
||||||
|
loggerInstance._constructor(); |
||||||
|
default.loadedLoggers.SetItem(loggerKey, loggerInstance); |
||||||
|
} |
||||||
|
loggerKey.FreeSelf(); |
||||||
|
return loggerInstance; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Auxiliary method for generating log message prefix based on `acediaStamp`, |
||||||
|
* `timeStamp` and `levelStamp` flags according to their description. |
||||||
|
* Method does not provide any guarantees on how exactly. |
||||||
|
* |
||||||
|
* @param messageLevel Message level for which to generate prefix. |
||||||
|
* @return Text (mutable) representation of generated prefix. |
||||||
|
*/ |
||||||
|
protected function MutableText GetPrefix(LoggerAPI.LogLevel messageLevel) |
||||||
|
{ |
||||||
|
local MutableText builder; |
||||||
|
builder = _.text.Empty(); |
||||||
|
if (acediaStamp) { |
||||||
|
builder.Append(T(TACEDIA)); |
||||||
|
} |
||||||
|
if (timeStamp) { |
||||||
|
builder.Append(T(TTIME)); |
||||||
|
} |
||||||
|
// Make output prettier by adding a space after the "[...]" prefixes |
||||||
|
if (!levelStamp && (acediaStamp || timeStamp)) { |
||||||
|
builder.Append(T(TSPACE)); |
||||||
|
} |
||||||
|
if (!levelStamp) { |
||||||
|
return builder; |
||||||
|
} |
||||||
|
switch (messageLevel) |
||||||
|
{ |
||||||
|
case LOG_Debug: |
||||||
|
builder.Append(T(TDEBUG)); |
||||||
|
break; |
||||||
|
case LOG_Info: |
||||||
|
builder.Append(T(TINFO)); |
||||||
|
break; |
||||||
|
case LOG_Warning: |
||||||
|
builder.Append(T(TWARNING)); |
||||||
|
break; |
||||||
|
case LOG_Error: |
||||||
|
builder.Append(T(TERROR)); |
||||||
|
break; |
||||||
|
case LOG_Fatal: |
||||||
|
builder.Append(T(TFATAL)); |
||||||
|
break; |
||||||
|
default: |
||||||
|
} |
||||||
|
return builder; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Method that must perform an actual work of outputting message `message` |
||||||
|
* at level `messageLevel`. |
||||||
|
* |
||||||
|
* @param message Message to output. |
||||||
|
* @param messageLevel Level, at which message must be output. |
||||||
|
*/ |
||||||
|
public function Write(Text message, LoggerAPI.LogLevel messageLevel){} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
// Parts of the prefix for our log messages, redirected into kf log file. |
||||||
|
TDEBUG = 0 |
||||||
|
stringConstants(0) = "[Debug] " |
||||||
|
TINFO = 1 |
||||||
|
stringConstants(1) = "[Info] " |
||||||
|
TWARNING = 2 |
||||||
|
stringConstants(2) = "[Warning] " |
||||||
|
TERROR = 3 |
||||||
|
stringConstants(3) = "[Error] " |
||||||
|
TFATAL = 4 |
||||||
|
stringConstants(4) = "[Fatal] " |
||||||
|
TTIME = 5 |
||||||
|
stringConstants(5) = "[hh:mm:ss]" |
||||||
|
TACEDIA = 6 |
||||||
|
stringConstants(6) = "[Acedia]" |
||||||
|
TSPACE = 7 |
||||||
|
stringConstants(7) = " " |
||||||
|
} |
||||||
@ -1,166 +0,0 @@ |
|||||||
/** |
|
||||||
* Logger that allows to separate log messages into several levels of |
|
||||||
* significance and lets users and admins to access only the ones they want |
|
||||||
* and/or receive notifications when they happen. |
|
||||||
* Copyright 2020 Anton Tarasenko |
|
||||||
*------------------------------------------------------------------------------ |
|
||||||
* This file is part of Acedia. |
|
||||||
* |
|
||||||
* Acedia is free software: you can redistribute it and/or modify |
|
||||||
* it under the terms of the GNU General Public License as published by |
|
||||||
* the Free Software Foundation, version 3 of the License, or |
|
||||||
* (at your option) any later version. |
|
||||||
* |
|
||||||
* Acedia is distributed in the hope that it will be useful, |
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||||
* GNU General Public License for more details. |
|
||||||
* |
|
||||||
* You should have received a copy of the GNU General Public License |
|
||||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
|
||||||
*/ |
|
||||||
class LoggerService extends Service |
|
||||||
config(AcediaLogger); |
|
||||||
|
|
||||||
// Log levels, available in Acedia. |
|
||||||
enum LogLevel |
|
||||||
{ |
|
||||||
// For the purposes of "tracing" the code, when trying to figure out |
|
||||||
// where exactly problems occurred. |
|
||||||
// Should not be used in any released version of |
|
||||||
// your packages/mutators. |
|
||||||
LOG_Track, |
|
||||||
// Information that can be used to track down errors that occur on |
|
||||||
// other people's systems, that developer cannot otherwise pinpoint. |
|
||||||
// Should be used with purpose of tracking a certain issue and |
|
||||||
// not "just in case". |
|
||||||
LOG_Debug, |
|
||||||
// Information about important events that should be occurring under |
|
||||||
// normal conditions, such as initializations/shutdowns, |
|
||||||
// successful completion of significant events, configuration assumptions. |
|
||||||
// Should not occur too often. |
|
||||||
LOG_Info, |
|
||||||
// For recoverable issues, anything that might cause errors or |
|
||||||
// oddities in behavior. |
|
||||||
// Should be used sparingly, i.e. player disconnecting might cause |
|
||||||
// interruption in some logic, but should not cause a warning, |
|
||||||
// since it is something expected to happen normally. |
|
||||||
LOG_Warning, |
|
||||||
// Use this for errors, - events that some operation cannot recover from, |
|
||||||
// but still does not require your module to shut down. |
|
||||||
LOG_Failure, |
|
||||||
// Anything that does not allow your module or game to function, |
|
||||||
// completely irrecoverable failure state. |
|
||||||
LOG_Fatal |
|
||||||
}; |
|
||||||
|
|
||||||
var private const string kfLogPrefix; |
|
||||||
var private const string traceLevelName; |
|
||||||
var private const string DebugLevelName; |
|
||||||
var private const string infoLevelName; |
|
||||||
var private const string warningLevelName; |
|
||||||
var private const string errorLevelName; |
|
||||||
var private const string fatalLevelName; |
|
||||||
|
|
||||||
var private config array< class<Manifest> > registeredManifests; |
|
||||||
var private config bool logTraceInKFLog; |
|
||||||
var private config bool logDebugInKFLog; |
|
||||||
var private config bool logInfoInKFLog; |
|
||||||
var private config bool logWarningInKFLog; |
|
||||||
var private config bool logErrorInKFLog; |
|
||||||
var private config bool logFatalInKFLog; |
|
||||||
|
|
||||||
var private array<string> traceMessages; |
|
||||||
var private array<string> debugMessages; |
|
||||||
var private array<string> infoMessages; |
|
||||||
var private array<string> warningMessages; |
|
||||||
var private array<string> errorMessages; |
|
||||||
var private array<string> fatalMessages; |
|
||||||
|
|
||||||
public final function bool ShouldAddToKFLog(LogLevel messageLevel) |
|
||||||
{ |
|
||||||
if (messageLevel == LOG_Track && logTraceInKFLog) return true; |
|
||||||
if (messageLevel == LOG_Debug && logDebugInKFLog) return true; |
|
||||||
if (messageLevel == LOG_Info && logInfoInKFLog) return true; |
|
||||||
if (messageLevel == LOG_Warning && logWarningInKFLog) return true; |
|
||||||
if (messageLevel == LOG_Failure && logErrorInKFLog) return true; |
|
||||||
if (messageLevel == LOG_Fatal && logFatalInKFLog) return true; |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
public final static function LogMessageToKFLog |
|
||||||
( |
|
||||||
LogLevel messageLevel, |
|
||||||
string message |
|
||||||
) |
|
||||||
{ |
|
||||||
local string levelPrefix; |
|
||||||
levelPrefix = default.kfLogPrefix; |
|
||||||
switch (messageLevel) |
|
||||||
{ |
|
||||||
case LOG_Track: |
|
||||||
levelPrefix = levelPrefix $ default.traceLevelName; |
|
||||||
break; |
|
||||||
case LOG_Debug: |
|
||||||
levelPrefix = levelPrefix $ default.debugLevelName; |
|
||||||
break; |
|
||||||
case LOG_Info: |
|
||||||
levelPrefix = levelPrefix $ default.infoLevelName; |
|
||||||
break; |
|
||||||
case LOG_Warning: |
|
||||||
levelPrefix = levelPrefix $ default.warningLevelName; |
|
||||||
break; |
|
||||||
case LOG_Failure: |
|
||||||
levelPrefix = levelPrefix $ default.errorLevelName; |
|
||||||
break; |
|
||||||
case LOG_Fatal: |
|
||||||
levelPrefix = levelPrefix $ default.fatalLevelName; |
|
||||||
break; |
|
||||||
default: |
|
||||||
} |
|
||||||
Log(levelPrefix @ message); |
|
||||||
} |
|
||||||
|
|
||||||
public final function LogMessage(LogLevel messageLevel, string message) |
|
||||||
{ |
|
||||||
switch (messageLevel) |
|
||||||
{ |
|
||||||
case LOG_Track: |
|
||||||
traceMessages[traceMessages.length] = message; |
|
||||||
case LOG_Debug: |
|
||||||
debugMessages[debugMessages.length] = message; |
|
||||||
case LOG_Info: |
|
||||||
infoMessages[infoMessages.length] = message; |
|
||||||
case LOG_Warning: |
|
||||||
warningMessages[warningMessages.length] = message; |
|
||||||
case LOG_Failure: |
|
||||||
errorMessages[errorMessages.length] = message; |
|
||||||
case LOG_Fatal: |
|
||||||
fatalMessages[fatalMessages.length] = message; |
|
||||||
default: |
|
||||||
} |
|
||||||
if (ShouldAddToKFLog(messageLevel)) |
|
||||||
{ |
|
||||||
LogMessageToKFLog(messageLevel, message); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
defaultproperties |
|
||||||
{ |
|
||||||
// Log everything by default, if someone does not like it - |
|
||||||
// he/she can disable it themselves. |
|
||||||
logTraceInKFLog = true |
|
||||||
logDebugInKFLog = true |
|
||||||
logInfoInKFLog = true |
|
||||||
logWarningInKFLog = true |
|
||||||
logErrorInKFLog = true |
|
||||||
logFatalInKFLog = true |
|
||||||
// Parts of the prefix for our log messages, redirected into kf log file. |
|
||||||
kfLogPrefix = "Acedia:" |
|
||||||
traceLevelName = "Trace" |
|
||||||
debugLevelName = "Debug" |
|
||||||
infoLevelName = "Info" |
|
||||||
warningLevelName = "Warning" |
|
||||||
errorLevelName = "Error" |
|
||||||
fatalLevelName = "Fatal" |
|
||||||
} |
|
||||||
@ -0,0 +1,170 @@ |
|||||||
|
/** |
||||||
|
* Set of tests related to `LoggerAPI`. |
||||||
|
* Copyright 2021 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia is distributed in the hope that it will be useful, |
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||||
|
* GNU General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class TEST_LogMessage extends TestCase |
||||||
|
abstract; |
||||||
|
|
||||||
|
// Short-hand for creating disposable `Text` out of a `string` |
||||||
|
// We need it, since `P()` always returns the same value, which might lead to |
||||||
|
// a conflict. |
||||||
|
protected static function Text A(string message) |
||||||
|
{ |
||||||
|
return __().text.FromString(message); |
||||||
|
} |
||||||
|
|
||||||
|
// Short-hand for quickly producing `LogMessage.Definition` |
||||||
|
protected static function LoggerAPI.Definition DEF(string message) |
||||||
|
{ |
||||||
|
local LoggerAPI.Definition result; |
||||||
|
result.m = message; |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
protected static function TESTS() |
||||||
|
{ |
||||||
|
Context("Testing how `LogMessage` collects given arguments."); |
||||||
|
Test_SimpleArgumentCollection(); |
||||||
|
Test_ArgumentCollection(); |
||||||
|
Test_ArgumentCollectionOrder(); |
||||||
|
Test_TypedArgumentCollection(); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function Test_SimpleArgumentCollection() |
||||||
|
{ |
||||||
|
local LogMessage message; |
||||||
|
Issue("`Text` arguments are not correctly pasted."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Message %1and%2: %3")); |
||||||
|
message.Arg(A("umbra")).Arg(A("mumbra")).Arg(A("eleven! ")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "Message umbraandmumbra: eleven! "); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("%1 - was pasted.")); |
||||||
|
message.Arg(A("Heheh")); |
||||||
|
TEST_ExpectTrue(message.Collect().ToPlainString() == "Heheh - was pasted."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("This %%%1 and that %2")); |
||||||
|
message.Arg(A("one")).Arg(A("two")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "This %%one and that two"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("%1%2")); |
||||||
|
message.Arg(A("one")).Arg(A("two")); |
||||||
|
TEST_ExpectTrue(message.Collect().ToPlainString() == "onetwo"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("%1")); |
||||||
|
message.Arg(A("only")); |
||||||
|
TEST_ExpectTrue(message.Collect().ToPlainString() == "only"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Just some string.")); |
||||||
|
TEST_ExpectTrue(message.Collect().ToPlainString() == "Just some string."); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function Test_ArgumentCollection() |
||||||
|
{ |
||||||
|
local LogMessage message; |
||||||
|
Issue("`Text` arguments are not correctly collected after reset."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("This %1 and that %2")); |
||||||
|
message.Arg(A("one")).Arg(A("two")).Reset().Arg(A("huh")).Arg(A("muh")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "This huh and that muh"); |
||||||
|
|
||||||
|
Issue("`Text` arguments are not correctly collected after specifying" |
||||||
|
@ "too many."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Just %1, %2, %3, %4 and %5")); |
||||||
|
message.Arg(A("1")).Arg(A("2")).Arg(A("3")).Arg(A("4")).Arg(A("5")) |
||||||
|
.Arg(A("6")).Arg(A("7")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "Just 1, 2, 3, 4 and 5"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Just")); |
||||||
|
TEST_ExpectTrue(message.Arg(A("arg")).Collect().ToPlainString() == "Just"); |
||||||
|
|
||||||
|
Issue("`Text` arguments are not correctly collected after specifying" |
||||||
|
@ "too little."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Just %1, %2, %3, %4 and %5")); |
||||||
|
message.Arg(A("1")).Arg(A("2")).Arg(A("3")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "Just 1, 2, 3, and "); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Maybe %1")); |
||||||
|
TEST_ExpectTrue(message.Collect().ToPlainString() == "Maybe "); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function Test_ArgumentCollectionOrder() |
||||||
|
{ |
||||||
|
local LogMessage message; |
||||||
|
Issue("`Text` arguments are not correctly collected if are not specified" |
||||||
|
@ "in order."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("This %2 and that %1")); |
||||||
|
message.Arg(A("huh")).Arg(A("muh")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "This muh and that huh"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Just %5, %3, %4, %1 and %2")); |
||||||
|
message.Arg(A("1")).Arg(A("2")).Arg(A("3")).Arg(A("4")).Arg(A("5")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "Just 5, 3, 4, 1 and 2"); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
|
||||||
|
Issue("`Text` arguments are not correctly collected if are not specified" |
||||||
|
@ "in order and not enough of them was specified."); |
||||||
|
message.Initialize(DEF("Just %5, %3, %4, %1 and %2")); |
||||||
|
message.Arg(A("1")).Arg(A("2")).Arg(A("3")); |
||||||
|
TEST_ExpectTrue( message.Collect().ToPlainString() |
||||||
|
== "Just , 3, , 1 and 2"); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function Test_TypedArgumentCollection() |
||||||
|
{ |
||||||
|
local LogMessage message; |
||||||
|
Issue("`int` arguments are not correctly collected."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Int: %1")); |
||||||
|
TEST_ExpectTrue(message.ArgInt(-7).Collect().ToPlainString() |
||||||
|
== "Int: -7"); |
||||||
|
|
||||||
|
Issue("`float` arguments are not correctly collected."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Float: %1")); |
||||||
|
TEST_ExpectTrue(message.ArgFloat(3.14).Collect().ToPlainString() |
||||||
|
== "Float: 3.14"); |
||||||
|
|
||||||
|
Issue("`bool` arguments are not correctly collected."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Bool: %1 and %2")); |
||||||
|
TEST_ExpectTrue(message.ArgBool(true).ArgBool(false).Collect() |
||||||
|
.ToPlainString() == "Bool: true and false"); |
||||||
|
|
||||||
|
Issue("`Class` arguments are not correctly collected."); |
||||||
|
message = LogMessage(__().memory.Allocate(class'LogMessage')); |
||||||
|
message.Initialize(DEF("Class: %1")); |
||||||
|
TEST_ExpectTrue(message.ArgClass(class'M14EBRBattleRifle').Collect() |
||||||
|
.ToPlainString() == "Class: KFMod.M14EBRBattleRifle"); |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
caseGroup = "Logger" |
||||||
|
caseName = "LogMessage" |
||||||
|
} |
||||||
Loading…
Reference in new issue