private Task LogDiscordMessage(Discord.LogMessage logMessage)
{
switch (logMessage.Severity)
{
case Discord.LogSeverity.Critical:
_logger.LogCritical(logMessage.Exception, logMessage.Message);
break;
case Discord.LogSeverity.Debug:
_logger.LogDebug(logMessage.Message);
break;
case Discord.LogSeverity.Error:
_logger.LogError(logMessage.Exception, logMessage.Message);
break;
case Discord.LogSeverity.Info:
_logger.LogInformation(logMessage.Message);
break;
case Discord.LogSeverity.Verbose:
_logger.LogTrace(logMessage.Message);
break;
case Discord.LogSeverity.Warning:
_logger.LogWarning(logMessage.Exception, logMessage.Message);
break;
}
return(Task.CompletedTask);
}
public LogMessage(Discord.LogMessage logMessage)
{
Severity = (LogSeverity)logMessage.Severity;
Source = logMessage.Source;
Message = logMessage.Message;
Exception = logMessage.Exception;
}
/// <summary>
/// Constructor that converts a <c>Discord.LogMessage</c> to the <c>IStandardLog</c> format.
/// </summary>
/// <param name='message'> <c>Discord.LogMessage</c> to convert to the <c>IStandardLog</c> format.
public DiscordLogMessageAdapter(Discord.LogMessage message)
{
Severity = (LogSeverity)message.Severity;
Source = message.Source;
Message = message.Message;
Exception = message.Exception;
}
public ILogMessage CreateLogMessage(Discord.LogMessage discordLogMessage)
{
var message = (ILogMessage) new LogMessage(discordLogMessage.Message);
message = new Source(message, discordLogMessage.Source);
message = new Timestamp(message);
return(message);
}
private static Task Client_Log(Discord.LogMessage arg)
{
if (arg.Message != null && !arg.Message.StartsWith("Received Dispatch"))
{
Console.WriteLine("Logging: " + arg.Message);
}
return(Task.CompletedTask);
}
private async Task OnLog(Discord.LogMessage message)
{
StringBuilder excBuilder = new StringBuilder();
TraceLevel entryType;
bool critical = false;
excBuilder.Append("A message was logged: ");
excBuilder.Append(message.Message);
excBuilder.AppendLine();
excBuilder.AppendLine();
excBuilder.Append(message.Exception.StackTrace);
switch (message.Severity)
{
case Discord.LogSeverity.Critical:
entryType = TraceLevel.Error;
critical = true;
break;
case Discord.LogSeverity.Error:
entryType = TraceLevel.Error;
break;
case Discord.LogSeverity.Debug:
entryType = TraceLevel.Info;
break;
case Discord.LogSeverity.Warning:
entryType = TraceLevel.Warning;
break;
default:
entryType = TraceLevel.Info;
break;
}
switch (entryType)
{
case TraceLevel.Error:
Trace.TraceError(excBuilder.ToString());
break;
case TraceLevel.Info:
Trace.TraceInformation(excBuilder.ToString());
break;
case TraceLevel.Warning:
Trace.TraceWarning(excBuilder.ToString());
break;
}
if (critical)
{
runComplete.Set();
}
}
private Task _discordClient_Log(Discord.LogMessage arg)
{
if (arg.Message != null)
{
Task.Factory.StartNew(() => { Loger.Log(arg.Message); });
Console.WriteLine(arg.Message);
}
if (arg.Exception != null)
{
Task.Factory.StartNew(() => { Loger.Log(arg.Exception.ToString()); });
}
return(Task.CompletedTask);
}
private Task OnClientLog(Discord.LogMessage logMessage)
{
LogLevel severity = logMessage.Severity.ToString() switch {
"Critical" => LogLevel.Critical,
"Warning" => LogLevel.Warning,
"Info" => LogLevel.Information,
"Verbose" => LogLevel.Information,
"Debug" => LogLevel.Debug,
"Error" => LogLevel.Error,
_ => LogLevel.Information
};
_logger.Log(severity, $"{logMessage.Source.PadRight(15)}{logMessage.Message}");
return(Task.CompletedTask);
}
}
/// <summary>
/// Whether or not a discord log represents a reconnect to the Discord service.
/// </summary>
/// <param name="log">The client log.</param>
/// <returns>True if the log represents a reconnect, false otherwise.</returns>
private static bool IsDiscordReconnect(Discord.LogMessage log)
{
var exception = log.Exception;
if (exception is Discord.WebSocket.GatewayReconnectException)
{
return(true);
}
else if (exception is System.Net.WebSockets.WebSocketException webSocketException)
{
if (webSocketException.WebSocketErrorCode == System.Net.WebSockets.WebSocketError.ConnectionClosedPrematurely)
{
return(true);
}
}
return(false);
}
public static LogMessage GenerateLog(Discord.LogMessage message)
{
var logItem = "Time: " + DateTime.Now.ToString();
logItem += " | " + "Severity: " + message.Severity.ToString();
logItem += " | " + "Source: " + message.Source;
logItem += " | " + "Message: " + message.Message;
if (message.Exception != null)
{
logItem += " | " + "Exception: " + message.Exception;
}
var logmsg = new LogMessage();
logmsg.message = logItem;
if (message.Severity == Discord.LogSeverity.Critical)
{
logmsg.level = LogLevel.Critical;
}
else if (message.Severity == Discord.LogSeverity.Error)
{
logmsg.level = LogLevel.Error;
}
else if (message.Severity == Discord.LogSeverity.Warning)
{
logmsg.level = LogLevel.Warning;
}
else if (message.Severity == Discord.LogSeverity.Info)
{
logmsg.level = LogLevel.Information;
}
else if (message.Severity == Discord.LogSeverity.Debug)
{
logmsg.level = LogLevel.Debug;
}
else if (message.Severity == Discord.LogSeverity.Verbose)
{
logmsg.level = LogLevel.Trace;
}
return(logmsg);
}
private Task discordClient_Log(Discord.LogMessage arg)
{
switch (arg.Severity)
{
case Discord.LogSeverity.Info:
this.mainWindow.AddLog(Client.LogType.Info, arg.Message);
break;
case Discord.LogSeverity.Error:
this.mainWindow.AddLog(Client.LogType.Error, arg.Message);
break;
case Discord.LogSeverity.Warning:
this.mainWindow.AddLog(Client.LogType.Warning, arg.Message);
break;
case Discord.LogSeverity.Critical:
this.mainWindow.AddLog(Client.LogType.Critical, arg.Message);
break;
}
return(Task.CompletedTask);
}
public static Task Log(Discord.LogMessage msg)
{
lock (Logger.o)
{
//Save old foreground color
var fc = Console.ForegroundColor;
//Set new color based on severity
switch (msg.Severity)
{
case Discord.LogSeverity.Debug:
case Discord.LogSeverity.Verbose:
case Discord.LogSeverity.Info:
{
Console.ForegroundColor = ConsoleColor.White;
} break;
case Discord.LogSeverity.Warning:
{
Console.ForegroundColor = ConsoleColor.Yellow;
} break;
case Discord.LogSeverity.Critical:
case Discord.LogSeverity.Error:
{
Console.ForegroundColor = ConsoleColor.Red;
} break;
}
//Write message
Console.WriteLine($"[{DateTime.Now}| {msg.Severity,8}] {msg.Source}: {msg.Message}");
//Restore foreground color
Console.ForegroundColor = fc;
}
//Return done
return(Task.CompletedTask);
}
private async Task HandleCommand(SocketMessage parameterMessage)
{
// Don't handle the command if it is a system message
var message = parameterMessage as SocketUserMessage;
if (message == null)
{
return;
}
// Mark where the prefix ends and the command begins
int argPos = 0;
// Determine if the message has a valid prefix, adjust argPos
if (!(message.HasMentionPrefix(m_client.CurrentUser, ref argPos) || message.HasStringPrefix(GlobalConfiguration.CommandPrefix, ref argPos)))
{
return;
}
// Create a Command Context
var context = new CommandContext(m_client, message);
// Execute the Command, store the result
var result = await commands.ExecuteAsync(context, argPos, serviceProvider).ConfigureAwait(false);
// If the command failed
if (!result.IsSuccess)
{
// result.Error will be unmetpreconditions if doesn't have permissions to attach files
// could maybe prompt back about it
// log the error
Discord.LogMessage errorMessage = new Discord.LogMessage(Discord.LogSeverity.Warning, "CommandHandler", result.ErrorReason);
Bot.Log(errorMessage);
// don't actually reply back with the error
}
}
/// <summary>
/// Forwards all client logs to the console.
/// </summary>
/// <param name="log">The client log.</param>
/// <returns>When the task has completed.</returns>
private static Task ForwardLogToLogging(Discord.LogMessage log)
{
var logCategory = ChillBotService.DiscordLogSourceCategoryCache.GetOrAdd(log.Source, (source) => $"{nameof(Discord)}.{source}");
var discordLogger = LogManager.GetLogger(logCategory);
if (ChillBotService.IsDiscordReconnect(log))
{
discordLogger.Log(
LogLevel.Information,
"Client log - Client reconnect;{{exceptionType:{exceptionType}}}",
log.Exception?.GetType());
}
else
{
discordLogger.Log(
log.Severity.ToLogLevel(),
log.Exception,
"Client log - {logMessage}",
log.Message ?? string.Empty);
}
return(Task.CompletedTask);
}
protected async Task RaiseLogAsync(Discord.LogMessage message)
{
await Log?.Invoke(new LogMessage(message));
}
private Task Log(Discord.LogMessage msg)
{
_logger.LogInformation(msg.ToString());
return(Task.CompletedTask);
}
public static (Source Source, Severity Severity, string Message, Exception Exception) FromDiscord(
Discord.LogMessage log)
{
return(Source.Discord, DiscordSeverity[log.Severity], log.Message, log.Exception);
}
private static Task LogAsync(Discord.LogMessage log)
{
Console.WriteLine(log.ToString());
return(Task.FromResult(0));
}
private async Task Log(Discord.LogMessage message)
{
Console.WriteLine(message.Message);
}
private Task _client_Log(Discord.LogMessage arg)
{
Console.WriteLine(arg);
return(Task.CompletedTask);
}
private Task Log(Discord.LogMessage logMessage)
{
_logger.Log(logMessage.Severity.ToNLogLevel(), logMessage.Exception, logMessage.Message);
return(Task.CompletedTask);
}
public async Task RaiseAsync(Discord.LogMessage message)
{
await _logMethod(new LogMessage(message));
}
private Task OnCommandLogAsync(DiscordLogMessage msg) => LogAsync(msg.Severity, msg.Source, msg.Exception?.ToString() ?? msg.Message);
private Task LogAsync(Discord.LogMessage logMessage)
{
Console.WriteLine(logMessage.Message);
return(Task.CompletedTask);
}
//Performs some simple logging for our Discord CLient
public static Task LogAsync(Discord.LogMessage log)
{
LogAsync(log.ToString());
return(Task.CompletedTask);
}
private Task Log(Discord.LogMessage arg) //write in console what is going on
{
Console.WriteLine(arg);
return(Task.CompletedTask);
}
/// <summary>
/// Discordのログ出力
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private static Task Client_Log(Discord.LogMessage message)
{
Console.WriteLine($"[{DateTime.Now}] {message.Message}");
return(Task.CompletedTask);
}
private async Task Client_Log(Discord.LogMessage Message)
{
Console.WriteLine($"{DateTime.Now} at {Message.Source} -- {Message.Message}");
}
public LogMsg(Discord.LogMessage logMessage)
{
Severity = (int)logMessage.Severity;
Message = logMessage.Message;
}
/// <summary>
/// Logs a Discord.Net debug message.
/// </summary>
#pragma warning disable CS1998
public static async Task Enter(Discord.LogMessage message)
=> Enter($"{DiscordNetPrefix} {message.Message.ToString()}");
