示例#1
0
 /// <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);
     }
 }
示例#2
0
        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;
            }
        }
示例#3
0
        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);
 }
示例#5
0
        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;
            }
        }
示例#8
0
        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");
            }
        }
示例#9
0
 private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
 {
     LogHelper.Debug("Debug");
     LogHelper.Info("Info");
     LogHelper.Warn("Warn");
     LogHelper.Error("Error");
     LogHelper.Fatal("Fatal");
 }
示例#10
0
 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));
     }
 }
示例#11
0
 private void MainForm_Load(object sender, EventArgs e)
 {
     LogHelper.Debug("Debug");
     LogHelper.Info("Info");
     LogHelper.Warn("Warn");
     LogHelper.Error("Error");
     LogHelper.Fatal("Fatal");
 }
示例#12
0
        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;
            }
        }
示例#13
0
 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());
     }
 }
示例#14
0
        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();
        }
示例#15
0
        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();
        }
示例#16
0
 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");
     }
 }
示例#17
0
 public void Fatal(object message)
 {
     _logger.Fatal(message);
 }
示例#18
0
 private static void UnhandledExceptionTrapper(object sender, UnhandledExceptionEventArgs e)
 {
     Logger.Fatal(e.ExceptionObject.ToString());
 }
示例#19
0
 public void Fatal(string text)
 {
     _logger.Fatal(text);
 }
示例#20
0
 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);
 }
示例#23
0
 public void Fatal(string message)
 {
     _log.Fatal(message);
 }
示例#24
0
 /// <summary>
 /// Logs the fatal error message.
 /// </summary>
 /// <param name="message">The message.</param>
 public void Fatal(object message)
 {
     Log.Fatal(message);
 }
示例#25
0
        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;
            }
        }
示例#26
0
 private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
 {
     Logger.Fatal(e.ExceptionObject as Exception, "Fatal UnhandledException");
 }
 public void LogFatal(string message)
 {
     _logger.Fatal(message);
 }
示例#28
0
 public Task Fatal(string message, params object[] arguments)
 {
     _logger.Fatal(message, arguments);
     return(Task.CompletedTask);
 }
示例#29
0
 public void Fatal(string message)
 {
     _internaLogger.Fatal(message);
 }