public static void Dispatch(LoggerEvent loggerEvent)
{
foreach (var item in s_eventWriterTriplets)
{
var triplet = item;
if (!triplet.Raw && loggerEvent.Properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
{
loggerEvent[LoggerEvent.MESSAGE_PROPERTY] =
string.Format((string)loggerEvent[LoggerEvent.MESSAGE_PROPERTY],
(object[])loggerEvent[LoggerEvent.PARAMETERS_PROPERTY]);
loggerEvent.Properties.Remove(LoggerEvent.PARAMETERS_PROPERTY);
}
var message = triplet.Formatter.Format(loggerEvent);
try
{
var accepted = triplet.Filters.All(filter => filter.Accepted(triplet, loggerEvent, message));
if (!accepted)
{
continue;
}
triplet.Writer.Write(GetUniqueId(loggerEvent), message);
}
catch (Exception ex)
{
throw new Exception("Ошибка при записи сообщения:\n" + message, ex);
}
}
}
private static void RedirectMessageToApplicationLogger(LoggerEvent logEvent)
{
logEvent[LoggerEvent.MESSAGE_PROPERTY] =
"<" + logEvent[LoggerEvent.LOGGERNAME_PROPERTY] + ">: " +
logEvent[LoggerEvent.MESSAGE_PROPERTY];
CoreApplication.Instance.Logger.Log(logEvent);
}
public static void Dispatch(LoggerEvent loggerEvent)
{
foreach (var item in s_eventWriterTriplets)
{
var triplet = item;
if (!triplet.Raw && loggerEvent.Properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
{
loggerEvent[LoggerEvent.MESSAGE_PROPERTY] =
string.Format((string) loggerEvent[LoggerEvent.MESSAGE_PROPERTY],
(object[]) loggerEvent[LoggerEvent.PARAMETERS_PROPERTY]);
loggerEvent.Properties.Remove(LoggerEvent.PARAMETERS_PROPERTY);
}
var message = triplet.Formatter.Format(loggerEvent);
try
{
var accepted = triplet.Filters.All(filter => filter.Accepted(triplet, loggerEvent, message));
if (!accepted)
continue;
triplet.Writer.Write(GetUniqueId(loggerEvent), message);
}
catch (Exception ex)
{
throw new Exception("Ошибка при записи сообщения:\n" + message, ex);
}
}
}
protected override bool CanAppendLine(LoggerEvent logEvent, string message)
{
var fileSystemManager = GetFileSystemManager();
if (fileSystemManager == null)
return true;
var requiredSize = message.Length / FileUtils.BYTES_IN_KB + 1;
return fileSystemManager.ReserveDiskSpace(_logDirectory, requiredSize);
}
public bool Accepted(EventWriterTriplet writerTriplet, LoggerEvent logEvent, string message)
{
if (!(writerTriplet.Writer is IEventFileSystemWriter))
{
return true;
}
string uniqueId = EventDispatcher.GetUniqueId(logEvent);
if (_blockedLogs.Contains(uniqueId))
{
return false;
}
var pointName = DEFAULT_LOG_NAME;
if (EventDispatcher.GroupByFieldDefined && logEvent.Properties.ContainsKey(EventDispatcher.GroupByField))
{
var groupByFieldValue = (string) logEvent[EventDispatcher.GroupByField];
if (_minFreeSpaces.ContainsKey(groupByFieldValue))
pointName = groupByFieldValue;
}
var minFreeSpace = _minFreeSpaces[pointName];
var requiredSize = message.Length / FileUtils.BYTES_IN_KB + 1;
long availableSize;
var fileSystemManager = GetFileSystemManager();
if (fileSystemManager != null &&
!fileSystemManager.ReserveDiskSpace(
(writerTriplet.Writer as IEventFileSystemWriter).GetPoint(uniqueId),
requiredSize,
minFreeSpace,
out availableSize))
{
var errorEvent = new LoggerEvent { EventType = TraceEventType.Error };
errorEvent[LoggerEvent.LOGGERNAME_PROPERTY] = logEvent[LoggerEvent.LOGGERNAME_PROPERTY];
errorEvent[BpcLoggerExtensions.MESSAGEID_PROPERTY] =
Message.Common_AvailableSpaceFilterNotEnoughSpaceError;
var minSizeMb = (double)minFreeSpace / FileUtils.BYTES_IN_KB;
var availableSizeMb = (double)availableSize / FileUtils.BYTES_IN_MB;
if (writerTriplet.Raw)
{
errorEvent[LoggerEvent.MESSAGE_PROPERTY] =
Message.Common_AvailableSpaceFilterNotEnoughSpaceError;
errorEvent[LoggerEvent.PARAMETERS_PROPERTY] =
new object[] { uniqueId, availableSizeMb, minSizeMb };
}
else
{
errorEvent[LoggerEvent.MESSAGE_PROPERTY] =
string.Format(
BpcLoggerExtensions.GetMessageBody(Message.Common_AvailableSpaceFilterNotEnoughSpaceError),
uniqueId, availableSizeMb, minSizeMb);
}
writerTriplet.Writer.Write(uniqueId, writerTriplet.Formatter.Format(errorEvent));
if (!_blockedLogs.Contains(uniqueId))
{
_blockedLogs.Add(uniqueId);
}
return false;
}
return true;
}
public void Log(LoggerEvent logEvent)
{
var resultMsg = ConstructMessage(logEvent);
if (CanAppendLine(logEvent, resultMsg))
{
_writer.WriteLine(resultMsg);
_writer.Flush();
}
}
public bool Accepted(LoggerEvent loggerEvent)
{
var scannerManager = GetScannerManager();
if (scannerManager != null &&
scannerManager.SheetProcessingSession != null &&
!scannerManager.SheetProcessingSession.Closed)
{
loggerEvent.Properties[BULLETIN_ID_PROPERTY] = scannerManager.SheetProcessingSession.Id;
}
return true;
}
protected virtual string ConstructMessage(LoggerEvent logEvent)
{
var resultMsg = logEvent.Properties[BpcLoggerExtensions.MESSAGEID_PROPERTY].ToString();
if (logEvent.Properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
resultMsg = ((object[]) logEvent.Properties[LoggerEvent.PARAMETERS_PROPERTY]).
Aggregate(resultMsg + '\t', (current, param) => current + param.ToString() + '|');
resultMsg = resultMsg.Trim('|');
resultMsg = String.Format("{0:yyMMddHHmmss} {1}", DateTime.Now, resultMsg);
return resultMsg;
}
private static string ApplyLogEventParams(LoggerEvent logEvent)
{
var resultMsg = logEvent.Properties[LoggerEvent.MESSAGE_PROPERTY].ToString();
if (logEvent.Properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
{
resultMsg = BpcLoggerExtensions.
GetMessageBody((Message)logEvent.Properties[BpcLoggerExtensions.MESSAGEID_PROPERTY]);
resultMsg =
String.Format(resultMsg, (object[])logEvent.Properties[LoggerEvent.PARAMETERS_PROPERTY]);
}
return resultMsg;
}
public static string GetUniqueId(LoggerEvent loggerEvent)
{
string uniqueId = null;
if (GroupByFieldDefined && loggerEvent.Properties.ContainsKey(GroupByField))
{
uniqueId = (string)loggerEvent[GroupByField];
}
if (string.IsNullOrEmpty(uniqueId))
{
uniqueId = loggerEvent.EventType.ToString();
}
return uniqueId;
}
public static string GetUniqueId(LoggerEvent loggerEvent)
{
string uniqueId = null;
if (GroupByFieldDefined && loggerEvent.Properties.ContainsKey(GroupByField))
{
uniqueId = (string)loggerEvent[GroupByField];
}
if (string.IsNullOrEmpty(uniqueId))
{
uniqueId = loggerEvent.EventType.ToString();
}
return(uniqueId);
}
public bool Accepted(EventWriterTriplet writerTriplet, LoggerEvent loggerEvent, string message)
{
var newMessage = loggerEvent.Properties[LoggerEvent.MESSAGE_PROPERTY].ToString();
bool asseptResult = false;
if (!loggerEvent.Properties.ContainsKey(BpcLoggerExtensions.MESSAGEID_PROPERTY))
asseptResult = true;
else if (!_filteredTypes.Contains((Message)loggerEvent.Properties[BpcLoggerExtensions.MESSAGEID_PROPERTY]))
asseptResult = true;
else if (writerTriplet.Raw)
{
newMessage = string.Format(newMessage, (object[])loggerEvent[LoggerEvent.PARAMETERS_PROPERTY]);
asseptResult = _lastMessageText != newMessage;
}
else if (!writerTriplet.Raw && _lastMessageText != newMessage)
asseptResult = true;
_lastMessageText = newMessage;
return asseptResult;
}
public string Format(LoggerEvent loggerEvent)
{
var args = new object[_messageNames.Count];
for (int i = 0; i < _messageNames.Count; ++i)
{
args[i] = string.Empty;
if (loggerEvent.Properties.ContainsKey(_messageNames[i]))
{
object arg = loggerEvent[_messageNames[i]];
if (_singleFileProps.Contains(_messageNames[i]))
arg = SavePropToFile(_messageNames[i], arg);
if (!(arg is string) && (arg is IEnumerable))
{
args[i] = ObjectDumper.DumpObject(arg, dumperSetting);
}
else
{
args[i] = arg;
}
}
else
{
switch(_messageNames[i])
{
case LoggerEvent.EVENTTYPE_PROPERTY:
args[i] = loggerEvent.EventType;
break;
}
}
}
try
{
return string.Format(_format, args);
}
catch (Exception ex)
{
_format = StringFormatParser.Parse(DEFAULT_FORMAT, out _messageNames);
CoreApplication.Instance.Logger.LogWarning(Message.Common_SingleLineFormatterFormatError, ex, _userFormat);
return Format(loggerEvent);
}
}
public void Log(LoggerEvent logEvent)
{
try
{
if (_queue.IsClosed)
{
return;
}
logEvent[LoggerEvent.LOGGERNAME_PROPERTY] = LoggerName;
if (_filters.Any(filter => !filter.Accepted(logEvent)))
{
return;
}
if (IsAsync)
{
_queue.Enqueue(logEvent);
}
else
{
EventDispatcher.Dispatch(logEvent);
}
}
catch (Exception ex)
{
var message = IsAsync
? "Ошибка при помещении события в очередь {0} на асинхронное логирование: {1}"
: "Ошибка при записи в логгер {0}: {1}";
if (this != CoreApplication.Instance.Logger)
{
CoreApplication.Instance.Logger.LogError(message, LoggerName, ex);
RedirectMessageToApplicationLogger(logEvent);
}
else
{
LoggingUtils.LogToConsole(message, LoggerName, ex);
}
}
}
protected override string ConstructMessage(LoggerEvent logEvent)
{
var recResultMsg = ApplyLogEventParams(logEvent);
recResultMsg = String.Format(LOG_MESSAGE_FORMAT, GetTimeLabel(), recResultMsg);
return recResultMsg;
}
public bool Accepted(LoggerEvent logEvent)
{
return ((int) logEvent.EventType & _allowedTraceEventTypeMask) > 0;
}
private static void RedirectMessageToApplicationLogger(LoggerEvent logEvent)
{
logEvent[LoggerEvent.MESSAGE_PROPERTY] =
"<" + logEvent[LoggerEvent.LOGGERNAME_PROPERTY] + ">: " +
logEvent[LoggerEvent.MESSAGE_PROPERTY];
CoreApplication.Instance.Logger.Log(logEvent);
}
public void Log(LoggerEvent logEvent)
{
try
{
if (_queue.IsClosed)
return;
logEvent[LoggerEvent.LOGGERNAME_PROPERTY] = LoggerName;
if (_filters.Any(filter => !filter.Accepted(logEvent)))
return;
if (IsAsync)
{
_queue.Enqueue(logEvent);
}
else
{
EventDispatcher.Dispatch(logEvent);
}
}
catch (Exception ex)
{
var message = IsAsync
? "Ошибка при помещении события в очередь {0} на асинхронное логирование: {1}"
: "Ошибка при записи в логгер {0}: {1}";
if (this != CoreApplication.Instance.Logger)
{
CoreApplication.Instance.Logger.LogError(message, LoggerName, ex);
RedirectMessageToApplicationLogger(logEvent);
}
else
{
LoggingUtils.LogToConsole(message, LoggerName, ex);
}
}
}
public bool IsAcceptedByEventType(LoggerEvent logEvent)
{
return _traceLevelFilter == null || _traceLevelFilter.Accepted(logEvent);
}
public bool IsAcceptedByEventType(LoggerEvent logEvent)
{
return(_traceLevelFilter == null || _traceLevelFilter.Accepted(logEvent));
}
protected virtual bool CanAppendLine(LoggerEvent logEvent, string message)
{
return true;
}
public bool Accepted(LoggerEvent logEvent)
{
return(((int)logEvent.EventType & _allowedTraceEventTypeMask) > 0);
}
public bool IsAcceptedByEventType(LoggerEvent logEvent)
{
return true;
}
