Пример #1
0
        public void OnMessage(LogMessage message, ILogger logger)
        {
            if (FlushTrigger == FlushTrigger.OnMessage)
            {
                string filePath = GetFileName(_logsDirectoryFullPath);

                lock (Locker)
                {
                    using (StreamWriter sw = System.IO.File.AppendText(filePath))
                    {
                        sw.WriteLine(_textFormatter.FormatLogMessage(message));
                    }
                }
            }
        }
        public void OnFlush(FlushLogArgs args)
        {
            IEnumerable <LogMessage> logMessages = args.MessagesGroups.SelectMany(p => p.Messages).OrderBy(p => p.DateTime).ToList();
            string filePath = _listener.GetFilePath();

            string beginRequest = _textFormatter.FormatBeginRequest(args.HttpProperties.Request);
            string endRequest   = _textFormatter.FormatEndRequest(args.HttpProperties.Request, args.HttpProperties.Response);

            lock (Locker)
            {
                using (StreamWriter sw = File.AppendText(filePath))
                {
                    if (!string.IsNullOrEmpty(beginRequest))
                    {
                        sw.WriteLine(beginRequest);
                    }

                    if (!string.IsNullOrEmpty(endRequest))
                    {
                        sw.WriteLine(endRequest);
                    }

                    foreach (var logMessage in logMessages)
                    {
                        string value = _textFormatter.FormatLogMessage(logMessage);

                        if (!string.IsNullOrEmpty(value))
                        {
                            sw.WriteLine(value);
                        }
                    }
                }
            }
        }
Пример #3
0
        private void WriteLogMessage(LogMessage message)
        {
            if (message == null)
            {
                return;
            }

            var nLogLogger = NLog.LogManager.GetLogger(message.CategoryName);

            string messageText = _textFormatter.FormatLogMessage(message);

            if (string.IsNullOrEmpty(messageText))
            {
                messageText = message.Message;
            }

            switch (message.LogLevel)
            {
            case LogLevel.Trace:
                nLogLogger.Trace(messageText);
                break;

            case LogLevel.Debug:
                nLogLogger.Debug(messageText);
                break;

            case LogLevel.Information:
                nLogLogger.Info(messageText);
                break;

            case LogLevel.Warning:
                nLogLogger.Warn(messageText);
                break;

            case LogLevel.Error:
            case LogLevel.Critical:
                nLogLogger.Error(messageText);
                break;

            default:
                nLogLogger.Debug(messageText);
                break;
            }
        }
        public void OnMessage(LogMessage message)
        {
            string value = _textFormatter.FormatLogMessage(message);

            if (string.IsNullOrEmpty(value))
            {
                return;
            }

            string filePath = _listener.GetFilePath();

            lock (Locker)
            {
                using (StreamWriter sw = File.AppendText(filePath))
                {
                    sw.WriteLine(value);
                }
            }
        }
Пример #5
0
        public void OnMessage(LogMessage message)
        {
            if (HasKissLogTarget.Value == true)
            {
                return;
            }

            string content = _textFormatter.FormatLogMessage(message);

            var logger = global::NLog.LogManager.GetLogger(Constants.DefaultLoggerCategoryName);

            switch (message.LogLevel)
            {
            case LogLevel.Trace:
                logger.Trace(content);
                break;

            case LogLevel.Debug:
            default:
                logger.Debug(content);
                break;

            case LogLevel.Information:
                logger.Info(content);
                break;

            case LogLevel.Warning:
                logger.Warn(content);
                break;

            case LogLevel.Error:
                logger.Error(content);
                break;

            case LogLevel.Critical:
                logger.Fatal(content);
                break;
            }
        }