/// <summary> /// Writes the specified message to the logger at fatal severity. /// </summary> /// <param name="message">The message.</param> public void Fatal(string message) { if (IsFatalEnabled) { _log.Fatal(message); } }
public void Log(LogEntry entry) { switch (entry.EventType) { case LoggingEventType.Debug: if (entry.Exception == null) { logger.Debug(entry.Message); } else { logger.Debug(entry.Exception, entry.Message); } break; case LoggingEventType.Info: if (entry.Exception == null) { logger.Info(entry.Message); } else { logger.Info(entry.Exception, entry.Message); } break; case LoggingEventType.Warn: if (entry.Exception == null) { logger.Warn(entry.Message); } else { logger.Warn(entry.Exception, entry.Message); } break; case LoggingEventType.Error: if (entry.Exception == null) { logger.Error(entry.Message); } else { logger.Error(entry.Exception, entry.Message); } break; case LoggingEventType.Fatal: if (entry.Exception == null) { logger.Fatal(entry.Message); } else { logger.Fatal(entry.Exception, entry.Message); } break; } }
public void Log(LogLevel level, Exception exception, string format, params object[] args) { if (args == null) { switch (level) { case LogLevel.Debug: nlogLogger.Debug(exception, format); break; case LogLevel.Info: nlogLogger.Info(exception, format); break; case LogLevel.Warning: nlogLogger.Warn(exception, format); break; case LogLevel.Error: nlogLogger.Error(exception, format); break; case LogLevel.Fatal: nlogLogger.Fatal(exception, format); break; default: break; } } else { switch (level) { case LogLevel.Debug: nlogLogger.Debug(exception, format, args); break; case LogLevel.Info: nlogLogger.Info(exception, format, args); break; case LogLevel.Warning: nlogLogger.Warn(exception, format, args); break; case LogLevel.Error: nlogLogger.Error(exception, format, args); break; case LogLevel.Fatal: nlogLogger.Fatal(exception, format, args); break; default: break; } } }
public void Fatal(string format, params object[] args) { try { format = string.Format(format, args); } catch (FormatException) { } _logger.Fatal(format); }
protected virtual void Write(string message, Exception exception, LogLevel logLevel) { switch (logLevel) { case LogLevel.Trace: _logger.Trace(exception, message); break; case LogLevel.Debug: _logger.Debug(exception, message); break; case LogLevel.Info: _logger.Info(exception, message); break; case LogLevel.Warn: _logger.Warn(exception, message); break; case LogLevel.Error: _logger.Error(exception, message); break; case LogLevel.Fatal: _logger.Fatal(exception, message); break; } }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { string message = formatter.Invoke(state, exception); switch (logLevel) { case LogLevel.Critical: _nlogger.Fatal(message); break; case LogLevel.Error: _nlogger.Error(message); break; case LogLevel.Warning: _nlogger.Warn(message); break; case LogLevel.Information: _nlogger.Info(message); break; case LogLevel.Debug: _nlogger.Debug(message); break; case LogLevel.Trace: default: _nlogger.Trace(message); break; } }
public void Log(object sender, LogEventArgs e) { switch (e.Severity) { case LogSeverity.Debug: var debugMsg = CreatetMessage(e.Message); _logger.Debug(debugMsg); break; case LogSeverity.Info: var infoMsg = CreatetMessage(e.Message); _logger.Info(infoMsg); break; case LogSeverity.Warning: var warningMsg = CreatetMessage(e.Message); _logger.Warn(warningMsg); break; case LogSeverity.Error: var errorMsg = CreatetMessage(e.Message, e.Exception); _logger.Error(errorMsg); break; case LogSeverity.Fatal: var fatalMsg = CreatetMessage(e.Message); _logger.Fatal(fatalMsg); break; } }
private static void DoWrite(NLog.ILogger logger, LogLevel level, string message) { switch (level) { case LogLevel.Debug: logger.Debug(message); break; case LogLevel.Info: logger.Info(message); break; case LogLevel.Warn: logger.Warn(message); break; case LogLevel.Error: logger.Error(message); break; case LogLevel.Fatal: logger.Fatal(message); break; default: throw new ArgumentException("不支持的日志级别", "level"); } }
private void MainWindow_OnLoaded(object sender, RoutedEventArgs e) { LogHelper.Debug("Debug"); LogHelper.Info("Info"); LogHelper.Warn("Warn"); LogHelper.Error("Error"); LogHelper.Fatal("Fatal"); }
public static T GetCacheByKey <T>(string key, bool addKeyPrefix = true) { try { var mc = new MemcachedClient(); if (mc.KeyExists(key)) { return((T)mc.Get(key)); } return(default(T)); } catch (Exception ex) { log.Fatal($"GetCacheByKey error,key:{key} ex:{ex}"); return(default(T)); } }
private void MainForm_Load(object sender, EventArgs e) { LogHelper.Debug("Debug"); LogHelper.Info("Info"); LogHelper.Warn("Warn"); LogHelper.Error("Error"); LogHelper.Fatal("Fatal"); }
public async Task <string> LoadAsync(Uri uri, CancellationToken cancellationToken) { _logger.Info($"Send request to {uri}"); try { HttpResponseMessage response = await GetHttpClient().GetAsync(uri, cancellationToken); _logger.Info($"Response's status code is {response.StatusCode}"); string content = await response.Content.ReadAsStringAsync(); if (response.IsSuccessStatusCode) { return(content); } // if server-side exception else if (response.StatusCode == HttpStatusCode.InternalServerError || response.StatusCode == HttpStatusCode.Unauthorized) { var error = JsonConvert.DeserializeObject <Error>(content); _logger.Error($"Error in response: {error}"); throw new Error() { Info = error.Info, ErrorCode = error.ErrorCode }; } else if (response.StatusCode == HttpStatusCode.NotFound) { throw new Error() { Info = AppResources.ErrorMessage_PageNotFound, ErrorCode = Errors.Not_found }; } // if unhandled server-side exception else { _logger.Fatal("Unhandled exception"); throw new Exception($"response status code: {response.StatusCode}; content: {content}"); } } catch (Exception ex) { if (ex is OperationCanceledException) { _logger.Error("Request canceld"); } else { _logger.Error($"Error while sending request: {ex.Message}"); } throw ex; } }
static async Task RunServer(WebServer server, Action update) { try { while (!stopped) { update(); server.SendUpdates(); await Task.Delay(TimeSpan.FromSeconds(1)); } } catch (Exception ex) { _log.Fatal(ex, "Uncaught exception in server thread! {0}", ex.ToString()); } }
static void Main(string[] args) { NLog.LogManager.LoadConfiguration("nlog.config"); log = NLog.LogManager.GetCurrentClassLogger(); log.Fatal("sdfdf"); Console.WriteLine("Hello World!"); MemcachedPoolinitialize("127.0.0.1:11211"); var key = "key_001"; var v = "ttt_oooo"; SetCache(key, v); v = "ddd"; log.Error(v); v = GetCacheByKey <string>(key); log.Error(v); Console.ReadLine(); }
public void NLogLogger() { int k = 42; int l = 100; _nlog.Trace().Message("Sample trace message, k={0}, l={1}", k, l).Write(); _nlog.Debug().Message("Sample debug message, k={0}, l={1}", k, l).Write(); _nlog.Info().Message("Sample informational message, k={0}, l={1}", k, l).Write(); _nlog.Warn().Message("Sample warning message, k={0}, l={1}", k, l).Write(); _nlog.Error().Message("Sample error message, k={0}, l={1}", k, l).Write(); _nlog.Fatal().Message("Sample fatal error message, k={0}, l={1}", k, l).Write(); _nlog .Debug() .Property("Test", "value") .Property("Time", DateTime.Now) .Message("Blah {0}", "format") .Write(); }
public void StartMonitor(ConfigurationOptions config, int monitorPort, int monitorIntervalMilliseconds, Func <EndPoint, bool> masterChanged) { try { port = monitorPort; serviceName = config.ServiceName; innerConnection = GetConnection(config); this.onMasterChanged = masterChanged; Monitoring = true; MonitorOnce(); MonitorPush(); } catch (Exception exp) { log.Fatal("No master found. Reason:{0}", exp.Message); throw new EntryPointNotFoundException("No master found"); } }
public void Fatal(object message) { _logger.Fatal(message); }
private static void UnhandledExceptionTrapper(object sender, UnhandledExceptionEventArgs e) { Logger.Fatal(e.ExceptionObject.ToString()); }
public void Fatal(string text) { _logger.Fatal(text); }
public void Fatal(string message, params object[] formatArgs) { _logger.Fatal(message, formatArgs); }
// Log all unhandled exceptions static void Global_UnhandledException(object sender, UnhandledExceptionEventArgs e) { _logger.Fatal(e.ExceptionObject); }
public void Fatal(object message) { _internalLogger.Fatal(message); }
public void Fatal(string message) { _log.Fatal(message); }
/// <summary> /// Logs the fatal error message. /// </summary> /// <param name="message">The message.</param> public void Fatal(object message) { Log.Fatal(message); }
static void Main(string[] args) { try { _logger.Info("Starting up Video Monitor {0}", typeof(Program).Assembly.GetName().Version); var config = new ConfigurationBuilder() .AddJsonFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "appsettings.json"), false, false) .AddJsonFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..", "appsettings.json"), true, false) .AddEnvironmentVariables() .Build(); _roots.AddRange(config.GetSection("FoldersToScan").GetChildren().Select(a => a.Value)); _exclusions.AddRange(config.GetSection("Exclusions").GetChildren().Select(a => a.Value)); _preset = config.GetSection("presetFile").Value; _logger.Info("Staring monitor thread"); Task.Factory.StartNew(() => ProcessNewFiles()); var timer = TimeSpan.Parse(config.GetSection("OldFileCheckInterval").Value); _logger.Info("Scanning for old files every {0}", timer); var aTimer = new System.Timers.Timer(timer.TotalMilliseconds); // Hook up the Elapsed event for the timer. aTimer.Elapsed += OnTimedEvent; aTimer.AutoReset = true; aTimer.Enabled = true; OnTimedEvent(null, null); foreach (var r in _roots) { _logger.Info("Monitoring {0}", r); var watcher = new FileSystemWatcher(r); watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.CreationTime; watcher.Filter = "*.*"; watcher.Created += OnFileCreated; // Begin watching. watcher.EnableRaisingEvents = true; _watchers.Add(watcher); } while (true) { Thread.Sleep(int.MaxValue); } } catch (Exception ex) { _logger.Fatal(ex, "Fatal Error"); throw; } }
private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { Logger.Fatal(e.ExceptionObject as Exception, "Fatal UnhandledException"); }
public void LogFatal(string message) { _logger.Fatal(message); }
public Task Fatal(string message, params object[] arguments) { _logger.Fatal(message, arguments); return(Task.CompletedTask); }
public void Fatal(string message) { _internaLogger.Fatal(message); }