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