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); }