public async Task SwapLogLevel(string level)
{
LogLvl curLog = ConfigProperties.LogLevel;
string validSeverities = "Trace, Debug, Info, Warn, Error";
ConfigProperties.LogLevel = level.ToLower() switch
{
"trace" => LogLvl.TRACE,
"debug" => LogLvl.DEBUG,
"info" => LogLvl.INFO,
"warn" => LogLvl.WARN,
"error" => LogLvl.ERROR,
_ => throw new ArgumentOutOfRangeException($"Valid logtypes are `{validSeverities}`", new Exception())
};
var embed = new KaguyaEmbedBuilder
{
Description = $"Successfully changed LogLevel from `{curLog.Humanize()}` to `{ConfigProperties.LogLevel.Humanize()}`",
Footer = new EmbedFooterBuilder
{
Text = $"Note: This loglevel will return back to `{curLog.Humanize()}` after a restart."
}
};
embed.SetColor(EmbedColor.VIOLET);
await ReplyAsync(embed : embed.Build());
}
}
private static void Output(LogLvl type, string msg)
{
if (null != OnOutput)
{
OnOutput(type, msg);
}
}
private void TraceMessageInternal(LogLvl level, string message)
{
if (level > desiredLogLevel)
{
return;
}
switch (level)
{
case LogLvl.Debug:
variableLogger?.Debug(message);
break;
case LogLvl.Info:
variableLogger?.Info(message);
break;
case LogLvl.Warning:
variableLogger?.Warn(message);
break;
case LogLvl.Error:
variableErrorLogger?.Error(message);
break;
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
/// <summary>
/// Add a message to NoHarmony log file
/// </summary>
/// <param name="mLvl">Message logging level</param>
/// <param name="message">Message core</param>
public void Log(LogLvl mLvl, string message)
{
if (mLvl.CompareTo(MinLogLvl) < 0 || !Logging)
{
return;
}
switch (mLvl)
{
case LogLvl.Error:
message = "!![Error] " + message + " !!";
break;
case LogLvl.Warning:
message = "![Warn] " + message;
break;
case LogLvl.Info:
message = "[Info] " + message;
break;
case LogLvl.Tracking:
message = "[Track] " + message;
break;
}
using (StreamWriter sw = new StreamWriter(LogFile, true))
{
sw.WriteLine(DateTime.Now.ToString(LogDateFormat) + " > " + message);
}
}
async private Task WriteToLogAsync(LogLvl logLvl, string msg, Exception ex = null)
{
var newMsg = Extensions.MsgHanlder(msg, ex);
var logString = Extensions.GetLogString(logLvl, newMsg);
using (var sw = new StreamWriter(_path, true))
await sw.WriteLineAsync(logString);
}
public async Task WriteLineAsync(string message, LogLvl lvl = LogLvl.Debug)
{
var logMsg = CreateMessage(message, lvl);
OutputToConsole(logMsg);
await SaveToDiskAsync(GetLogfilename(), logMsg);
}
public void WriteLine(string message, LogLvl lvl = LogLvl.Debug)
{
var logMsg = CreateMessage(message, lvl);
OutputToConsole(logMsg);
SaveToDisk(GetLogfilename(), logMsg);
}
private void WriteToLog(LogLvl logLvl, string msg = null, Exception ex = null)
{
var newMsg = Extensions.MsgHanlder(msg, ex);
var logString = Extensions.GetLogString(logLvl, newMsg);
using (var sw = new StreamWriter(_path, true))
sw.WriteLine(logString);
}
/// <summary>
/// Logs a Discord command to the console. This log message is special in that the format is completely different from other log messages.
/// </summary>
/// <param name="context">The <see cref="ICommandContext" /> that we will use to gather command data from.</param>
/// <param name="logLevel">The severity of this log message.</param>
/// <returns></returns>
public static async Task LogAsync(ICommandContext context, LogLvl logLevel = LogLvl.INFO)
{
string logP = LogPrefix(logLevel);
int shardId = ConfigProperties.Client.GetShardIdFor(context.Guild);
string contents = $"\n{DateTime.Now.ToLongDateString()} {DateTime.Now.ToLongTimeString()} {logP} " +
$"Command: [{context.Message}]\nUser: [Name: {context.User} | ID: {context.User.Id}]\n" +
$"Guild: [Name: {context.Guild} | ID: {context.Guild.Id} | Shard: {shardId}]\n" +
$"Channel: [Name: {context.Channel.Name} | ID: {context.Channel.Id}]\n";
await LogFinisher(contents);
}
public static async Task LogAsync(Exception e, LogLvl logLvl = LogLvl.ERROR)
{
Type type = e.GetType();
if (type == typeof(KaguyaSupportException) || type == typeof(KaguyaPremiumException))
{
return;
}
string logP = LogPrefix(LogLvl.ERROR);
string contents = $"{DateTime.Now.ToLongDateString()} {DateTime.Now.ToLongTimeString()} {logP} Exception thrown: " +
$"{e.Message}.\nInner Exception Message: {e.InnerException?.Message ?? "NULL"}\n" +
$"Stack Trace: {e.StackTrace ?? "NULL"}";
await LogFinisher(contents);
}
public void log(string text, LogLvl type = LogLvl.Info)
{
try
{
if (CharacterSettings != null)
{
if (!CharacterSettings.LogAll)
{
return;
}
}
var color = new Color();
switch (type)
{
case LogLvl.Ok:
color = Color.Green;
break;
case LogLvl.Error:
color = Color.Red;
break;
case LogLvl.Info:
color = Color.DarkGray;
break;
case LogLvl.Important:
color = Color.DarkOrange;
break;
}
if (Me != null)
{
Log(DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture) + ": " + Me?.Name + "(" + Me?.Level + ") " + FarmModule?.FarmState + " " + text, color, GetCurrentAccount().Name);
}
else
{
Log(DateTime.Now.ToString("hh:mm:ss.fff", CultureInfo.InvariantCulture) + ": " + "Character offline: " + " " + text, color, GetCurrentAccount().Name);
}
}
catch (Exception)
{
//igrored
}
}
public Logger(ILoggingConfig config)
{
desiredLogLevel = config.LogLevel;
if (string.IsNullOrEmpty(config.NlogConfigFileName))
{
loggerFactory = new LogFactory();
variableLogger = loggerFactory.GetLogger("customLogger");
variableErrorLogger = loggerFactory.GetLogger("customErrorLogger");
}
else
{
var normalizer = new PathNormalizer();
var serverPath = normalizer.Normalize(config.NlogConfigFileName);
loggerFactory = new LogFactory(new XmlLoggingConfiguration(serverPath));
variableLogger = loggerFactory.GetLogger("messageLogger");
variableErrorLogger = loggerFactory.GetLogger("errorLogger");
}
}
private static void Log(string msg, LogChannel channel, LogLvl level)
{
// cease log that we do not want
if ((int)level < (int)minimumLvl || !LogChannels.IsChannelActive(channel))
{
return;
}
string channelStr = LogChannels.GetChannelName(channel);
string finalMsg = string.Format("[ {0} ] - {1}", channelStr, msg);
switch (level)
{
case LogLvl.Info:
Debug.Log(finalMsg);
break;
case LogLvl.Warning:
Debug.LogWarning(finalMsg);
break;
case LogLvl.Error:
Debug.LogError(finalMsg);
break;
case LogLvl.Assertion:
Debug.LogAssertion(finalMsg);
break;
case LogLvl.Exception:
// TODO: Implementation
break;
default:
Debug.LogFormat("The log level {0} does not exist", level.ToString());
break;
}
}
/// <summary>
/// Logs a message to the console and the log file.
/// </summary>
/// <param name="message">The <see cref="string" /> to display inside of the console.</param>
/// <param name="logLevel">The <see cref="LogLvl" /> that determines this log's severity.</param>
/// <param name="foregroundColor">Assuming we override the colors, this will alter the color of the text shown in the console.</param>
/// <param name="displaySeverity">Whether to display the date and time in the console.</param>
/// <param name="showDate">Whether to display the date and time in the console.</param>
/// <returns></returns>
public static async Task LogAsync(string message,
LogLvl logLevel,
ConsoleColor foregroundColor = ConsoleColor.White,
bool displaySeverity = true,
bool showDate = true)
{
string logP = LogPrefix(logLevel);
string dateString = $"{DateTime.Now.ToLongDateString()} {DateTime.Now.ToLongTimeString()}";
string contents = $"{(showDate ? $"{dateString} " : "")}{(displaySeverity ? $"{logP} " : "")}{message}";
// If the loglevel provided in the Config is only set to display more severe logs, return.
if (ConfigProperties.LogLevel > logLevel)
{
return;
}
// If the color wasn't overridden by the caller...
if (foregroundColor == ConsoleColor.White)
{
foregroundColor = GetConsoleForegroundColor(logLevel);
}
await LogFinisher(contents, foregroundColor);
}
private static void LogFormat(string format, LogChannel channel, LogLvl level, params object[] args)
{
Log(string.Format(format, args), channel, level);
}
private static string CreateMessage(string message, LogLvl lvl = LogLvl.Debug)
{
return($"[{DateTime.Now:T}][{lvl.ToString()[0]}]:{message}");
}
internal static string GetLogString(LogLvl logLvl, string msg)
=> $"{logLvl} {DateTime.Now} >>> {msg}";
private static string LogPrefix(LogLvl logLevel) => logLevel switch
{
public void WrightFormat(LogLvl lvl, object sender, params object[] message)
{
}
public void Wright(LogLvl lvl, object sender, string message)
{
}
