private LogLevel TranslateLevel(SerilogEventLevel level)
{
switch (level)
{
case SerilogEventLevel.Verbose:
return(LogLevel.Trace);
case SerilogEventLevel.Debug:
return(LogLevel.Debug);
case SerilogEventLevel.Information:
return(LogLevel.Info);
case SerilogEventLevel.Warning:
return(LogLevel.Warn);
case SerilogEventLevel.Error:
return(LogLevel.Error);
case SerilogEventLevel.Fatal:
return(LogLevel.Fatal);
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
/// <summary>
/// Write a log event with the <see cref="!:LogEventLevel.Debug" /> level and associated exception.
/// </summary>
/// <param name="logLevel">The logging level to report the event.</param>
/// <param name="context">The context.</param>
/// <param name="exception">Exception related to the event.</param>
/// <param name="messageTemplate">Message template describing the event.</param>
/// <param name="propertyValues">Objects positionally formatted into the message template.</param>
/// <example>
/// Log.Write(ex, "Swallowing a mundane exception.");
/// </example>
public void Write(LogLevel logLevel, Type context = null, Exception exception = null, string messageTemplate = null, params object[] propertyValues)
{
S.Events.LogEventLevel seriLevel = (S.Events.LogEventLevel)Enum.Parse(typeof(S.Events.LogEventLevel), logLevel.ToString());
var logger = (context != null) ? _log.ForContext(context) : _log;
logger.Write(seriLevel, exception, messageTemplate, propertyValues);
}
/// <summary>
/// Occurs when an event has been written by an event source (EventSource object) for which the event listener has enabled events.
/// </summary>
/// <param name="eventData"></param>
protected override void OnEventWritten(EventWrittenEventArgs eventData)
{
if (eventData != null && eventData.Payload != null && eventData.Payload.Count > 0)
{
//Map .NET EventLevel to Serilog logging levels
Serilog.Events.LogEventLevel level = Serilog.Events.LogEventLevel.Information;
switch (eventData !.Level)
{
/// <summary>
/// Creates new instance of Serilog logger with default configuration:
/// Write logs to Console (ConsoleSink)
/// </summary>
public SerilogAdapter(Serilog.Events.LogEventLevel minLevel = Serilog.Events.LogEventLevel.Information)
{
_logger = new LoggerConfiguration( )
.WriteTo
.Console(restrictedToMinimumLevel: minLevel)
.Enrich
.FromLogContext()
.CreateLogger();
}
public PykeAPI(Serilog.Events.LogEventLevel DebugLevel = Serilog.Events.LogEventLevel.Information)
{
logger = new LoggerConfiguration()
.WriteTo.Console()
.MinimumLevel.Is(DebugLevel)
.CreateLogger();
_processHandler = new LeagueProcessHandler();
_lockFileHandler = new LockFileHandler();
}
private ILogger GetLogger(Serilog.Events.LogEventLevel logEventLevel = Serilog.Events.LogEventLevel.Information)
{
_loggerOutput = new StringBuilder();
var writer = new StringWriter(_loggerOutput);
var loggerConfiguration = new LoggerConfiguration()
.WriteTo.TextWriter(writer);
loggerConfiguration.MinimumLevel.Is(logEventLevel);
var logger = loggerConfiguration.CreateLogger();
return(logger);
}
public static void log(object msg, Serilog.Events.LogEventLevel level = Serilog.Events.LogEventLevel.Information)
{
string s = System.Threading.Thread.CurrentThread.ManagedThreadId + " " + msg.ToString();
if (_logger is not null)
{
_logger.Write(level, s);
}
else
{
Console.WriteLine(System.DateTime.Now.ToString("HH-mm-ss-fff") + " " + s);
}
}
private ILogger CreateLogger(string file, Serilog.Events.LogEventLevel level)
{
string outputTemplate = "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] ({ThreadId}) {Message}{NewLine}{Exception}";
var log = new LoggerConfiguration()
.MinimumLevel
.Is(level)
.Enrich.With(new ThreadIdEnricher())
.WriteTo
.RollingFile(file, retainedFileCountLimit: null, outputTemplate: outputTemplate)
.CreateLogger();
return(log);
}
/// <summary>
/// 获取配置的Console的日志等级，作为推送日志的等级
/// </summary>
/// <returns></returns>
private static Serilog.Events.LogEventLevel GetConsoleLogLevel()
{
var consoleLevelStr = RayConfiguration.Root["Serilog:WriteTo:0:Args:restrictedToMinimumLevel"];
if (string.IsNullOrWhiteSpace(consoleLevelStr))
{
consoleLevelStr = "Information";
}
Serilog.Events.LogEventLevel levelEnum = (Serilog.Events.LogEventLevel)
Enum.Parse(typeof(Serilog.Events.LogEventLevel), consoleLevelStr);
return(levelEnum);
}
public JsonResult ChangeLogLevel(string toLevel)
{
try
{
Logger.LogInformation($"Trying to change log level to {toLevel}.");
Serilog.Events.LogEventLevel level = (Serilog.Events.LogEventLevel)Enum.Parse(typeof(Serilog.Events.LogEventLevel), toLevel);
Extensions.HostBuilderExtensions.SwitchToLogLevel(level);
Logger.LogInformation($"Successfully changed log level to {toLevel}.");
return(Json(true));
}
catch (Exception ex)
{
Logger.LogError(ex, $"Error changing log level to {toLevel}.");
return(Json(false));
}
}
public static UtlzLevel Convert(SerilogLevel level)
{
switch (level)
{
case SerilogLevel.Fatal: return(UtlzLevel.Fatal);
case SerilogLevel.Error: return(UtlzLevel.Error);
case SerilogLevel.Warning: return(UtlzLevel.Warn);
case SerilogLevel.Information: return(UtlzLevel.Info);
case SerilogLevel.Debug: return(UtlzLevel.Debug);
case SerilogLevel.Verbose: return(UtlzLevel.Trace);
default: return(UtlzLevel.Info);
}
}
public async Task Run(XConsole xc)
{
try
{
using (var scope = xc.WebHost.Services.CreateScope())
{
xc.AskForInput(this, "Enter log level (case sensitive) you want to switch over: ");
var toLevel = Console.ReadLine();
xc.WriteInfo(this, $"Trying to change log level to {toLevel} ...");
Serilog.Events.LogEventLevel level = (Serilog.Events.LogEventLevel)Enum.Parse(typeof(Serilog.Events.LogEventLevel), toLevel);
Extensions.HostBuilderExtensions.SwitchToLogLevel(level);
xc.WriteSuccess(this, "Done");
}
}
catch (Exception ex)
{
xc.WriteException(this, ex);
}
}
/// <summary>
/// Configures the services for the bot.
/// </summary>
/// <param name="services">The services.</param>
private static void ConfigureServices(IServiceCollection services)
{
//Read level type from config.json
services.AddLogging(configure => configure.AddSerilog());
Serilog.Events.LogEventLevel level = Serilog.Events.LogEventLevel.Error;
switch (Global.LoggingLevel.ToLower())
{
case "error":
level = Serilog.Events.LogEventLevel.Error;
break;
case "info":
level = Serilog.Events.LogEventLevel.Information;
break;
case "debug":
level = Serilog.Events.LogEventLevel.Debug;
break;
case "crit":
level = Serilog.Events.LogEventLevel.Fatal;
break;
case "warn":
level = Serilog.Events.LogEventLevel.Warning;
break;
case "trace":
level = Serilog.Events.LogEventLevel.Debug;
break;
default:
throw new Exception("Logging level is invalid");
}
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.WriteTo.File(Global.LogPath)
.MinimumLevel.Is(level)
.CreateLogger();
}
/// <summary>
/// Writes a specified level log.
/// </summary>
/// <param name="level">Log level.</param>
/// <param name="exception">Exception related with this log message.</param>
/// <param name="messageTemplate">Log message.</param>
/// <param name="propertyValues">The property values for the message template.</param>
private static void Write(Serilog.Events.LogEventLevel level, Exception exception, string messageTemplate, params object[] propertyValues)
{
try
{
if (Log.level < LogLevel.Silent)
{
logger.Write(level, exception, messageTemplate, propertyValues);
}
}
catch (Exception)
{
if (isClosedAfterException)
{
Close();
}
if (!isExceptionIgnored)
{
throw;
}
}
}
/// <summary>
/// Writes a specified level log.
/// </summary>
/// <param name="level">Log level.</param>
/// <param name="exception">Exception related with this log message.</param>
/// <param name="messageTemplate">Log message.</param>
/// <param name="propertyValue0">The property value for the message template.</param>
/// <param name="propertyValue1">The property value for the message template.</param>
/// <param name="propertyValue2">The property value for the message template.</param>
private static void Write <T0, T1, T2>(Serilog.Events.LogEventLevel level, Exception exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
{
try
{
if (Log.level < LogLevel.Silent)
{
logger.Write(level, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
}
}
catch (Exception)
{
if (isClosedAfterException)
{
Close();
}
if (!isExceptionIgnored)
{
throw;
}
}
}
/// <summary>
/// Writes a specified level log.
/// </summary>
/// <param name="level">Log level.</param>
/// <param name="exception">Exception related with this log message.</param>
/// <param name="message">Log message.</param>
private static void Write(Serilog.Events.LogEventLevel level, Exception exception, string message)
{
try
{
if (Log.level < LogLevel.Silent)
{
logger.Write(level, exception, message);
}
}
catch (Exception)
{
if (isClosedAfterException)
{
Close();
}
if (!isExceptionIgnored)
{
throw;
}
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
if (logLevel == LogLevel.None)
{
return;
}
Serilog.Events.LogEventLevel logEventLevel = Serilog.Events.LogEventLevel.Information;
switch (logLevel)
{
case LogLevel.Information:
logEventLevel = Serilog.Events.LogEventLevel.Information;
break;
case LogLevel.Error:
logEventLevel = Serilog.Events.LogEventLevel.Error;
break;
case LogLevel.Warning:
logEventLevel = Serilog.Events.LogEventLevel.Warning;
break;
case LogLevel.Critical:
logEventLevel = Serilog.Events.LogEventLevel.Fatal;
break;
case LogLevel.Debug:
logEventLevel = Serilog.Events.LogEventLevel.Debug;
break;
case LogLevel.Trace:
logEventLevel = Serilog.Events.LogEventLevel.Verbose;
break;
}
_logger.Write(logEventLevel, exception, formatter.Invoke(state, exception));
}
/// <summary>
/// This logs discord messages to our LogHandler
/// </summary>
/// <param name="message">
/// The message.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
internal Task LogAsync(LogMessage message)
{
Serilog.Events.LogEventLevel logEventLevel = Serilog.Events.LogEventLevel.Information;
switch (message.Severity)
{
case LogSeverity.Critical:
logEventLevel = Serilog.Events.LogEventLevel.Fatal;
break;
case LogSeverity.Error:
logEventLevel = Serilog.Events.LogEventLevel.Error;
break;
case LogSeverity.Warning:
logEventLevel = Serilog.Events.LogEventLevel.Warning;
break;
case LogSeverity.Info:
logEventLevel = Serilog.Events.LogEventLevel.Information;
break;
case LogSeverity.Verbose:
logEventLevel = Serilog.Events.LogEventLevel.Verbose;
break;
case LogSeverity.Debug:
logEventLevel = Serilog.Events.LogEventLevel.Debug;
break;
default:
logEventLevel = Serilog.Events.LogEventLevel.Information;
break;
}
Global.Log.Write(logEventLevel, message.Message);
return(Task.CompletedTask);
}
public void OutputLog(Serilog.Events.LogEventLevel level, string message)
{
}
private static (SerilogILogger serilogger, LoggingLevelSwitch levelSwitch) SetupSerilog(SerilogLevel level)
{
var levelSwitch = new LoggingLevelSwitch(level);
var serilogger =
new LoggerConfiguration()
.MinimumLevel.ControlledBy(levelSwitch)
.Enrich.With <AllCapsLevelEnricher>()
.WriteTo.Console(
formatProvider: CustomFormatProviderSingleton,
outputTemplate: BuildConsoleTemplate(),
theme: ConsoleTheme.None)
.CreateLogger();
return(serilogger, levelSwitch);
}
/// <summary>
/// Dynamically changes the SeriLog log level.
/// </summary>
/// <remarks>
/// It wont work if SeriLog logger is configured by yourself
/// and you forgot to call <code>MinimumLevel.ControlledBy(ExicoShopifyBuilder.LevelSwitch)</code>
/// during the congiuration/creation.
/// </remarks>
/// <param name="level"></param>
public static void SwitchToLogLevel(Serilog.Events.LogEventLevel level)
{
LevelSwitch.MinimumLevel = level;
}
public static void SetLoggingLevel(LogEventLevel logLevel)
{
LoggingLevelSwitch.MinimumLevel = logLevel;
}
private void LogMessage(Serilog.Events.LogEventLevel logLevel, Func <string> messageFunc, object[] formatParameters)
{
logger.Write(logLevel, messageFunc(), formatParameters);
}
public static void SetLoggingLevel(Serilog.Events.LogEventLevel level)
{
_loggingLevel.MinimumLevel = level;
}
public bool IsEnabled(Serilog.Events.LogEventLevel level)
{
var r = _logger?.IsEnabled(level);
return(r ?? false);
}
private void LogException(Serilog.Events.LogEventLevel logLevel, Func <string> messageFunc, Exception exception, object[] formatParams)
{
logger.Write(logLevel, exception, messageFunc(), formatParams);
}
private void HandleReloadBoth()
{
//Check for changes in the log level
Serilog.Events.LogEventLevel logLevel = (Serilog.Events.LogEventLevel)DataHelper.GetSettingInt(SettingsConstants.LOG_LEVEL, (long)Serilog.Events.LogEventLevel.Information);
if (logLevel != TRBotLogger.MinLoggingLevel)
{
TRBotLogger.Logger.Information($"Detected change in logging level - changing the logging level from {TRBotLogger.MinLoggingLevel} to {logLevel}");
TRBotLogger.SetLogLevel(logLevel);
}
//Check if the periodic input value changed, and enable/disable the routine if we should
long periodicEnabled = DataHelper.GetSettingInt(SettingsConstants.PERIODIC_INPUT_ENABLED, 0L);
if (periodicEnabled == 0)
{
RoutineHandler.FindRoutine(RoutineConstants.PERIODIC_INPUT_ROUTINE_ID, out int rIndex);
//Remove the routine if it exists
if (rIndex >= 0)
{
RoutineHandler.RemoveRoutine(rIndex);
}
}
else
{
RoutineHandler.FindRoutine(RoutineConstants.PERIODIC_INPUT_ROUTINE_ID, out int rIndex);
//Add the routine if it doesn't exist
if (rIndex < 0)
{
RoutineHandler.AddRoutine(new PeriodicInputRoutine());
}
}
//Check if the virtual controller type was changed
if (LastVControllerTypeChanged() == true)
{
VirtualControllerTypes lastVControllerType = (VirtualControllerTypes)DataHelper.GetSettingInt(SettingsConstants.LAST_VCONTROLLER_TYPE, 0L);
VirtualControllerTypes supportedVCType = VControllerHelper.ValidateVirtualControllerType(lastVControllerType, TRBotOSPlatform.CurrentOS);
//Show a message saying the previous value wasn't supported
if (VControllerHelper.IsVControllerSupported(lastVControllerType, TRBotOSPlatform.CurrentOS) == false)
{
MsgHandler.QueueMessage($"Current virtual controller {lastVControllerType} is not supported by the {TRBotOSPlatform.CurrentOS} platform. Switched it to the default of {supportedVCType} for this platform.");
using (BotDBContext context = DatabaseManager.OpenContext())
{
Settings lastVControllerSetting = DataHelper.GetSettingNoOpen(SettingsConstants.LAST_VCONTROLLER_TYPE, context);
lastVControllerSetting.ValueInt = (long)supportedVCType;
context.SaveChanges();
}
}
ChangeVControllerType(supportedVCType);
}
else
{
ReinitVControllerCount();
}
//Handle message throttling changes
MessageThrottlingOptions msgThrottle = (MessageThrottlingOptions)DataHelper.GetSettingInt(SettingsConstants.MESSAGE_THROTTLE_TYPE, 0L);
long msgTime = DataHelper.GetSettingInt(SettingsConstants.MESSAGE_COOLDOWN, 30000L);
long msgThrottleCount = DataHelper.GetSettingInt(SettingsConstants.MESSAGE_THROTTLE_COUNT, 20L);
if (msgThrottle != MsgHandler.CurThrottleOption)
{
TRBotLogger.Logger.Information("Detected change in message throttling type - changing message throttler.");
}
MsgHandler.SetMessageThrottling(msgThrottle, new MessageThrottleData(msgTime, msgThrottleCount));
}
public SerilogLogSink(string file, Serilog.Events.LogEventLevel minimumLevel)
{
_logger = new LoggerConfiguration().WriteTo.File(
file, minimumLevel, rollingInterval: RollingInterval.Day).CreateLogger();
}
public void SetLevel(Serilog.Events.LogEventLevel minimumLevel)
{
_loggingLevelSwitch.MinimumLevel = minimumLevel;
}
/// <summary>
/// Write a log event with the <see cref="!:LogEventLevel.Debug" /> level and associated exception.
/// </summary>
/// <typeparam name="TSourceContext">The type of the class that is calling the logger.</typeparam>
/// <param name="logLevel">The logging level to report the event.</param>
/// <param name="exception">Exception related to the event.</param>
/// <param name="messageTemplate">Message template describing the event.</param>
/// <param name="propertyValues">Objects positionally formatted into the message template.</param>
/// <example>
/// Log.Debug(ex, "Swallowing a mundane exception.");
/// </example>
public void Write <TSourceContext>(LogLevel logLevel, Exception exception = null, string messageTemplate = null, params object[] propertyValues)
{
S.Events.LogEventLevel seriLevel = (S.Events.LogEventLevel)Enum.Parse(typeof(S.Events.LogEventLevel), logLevel.ToString());
_log.ForContext <TSourceContext>().Write(seriLevel, exception, messageTemplate, propertyValues);
}
