public static bool TryWriteAppLog(string message, string detail)
{
LogEntity logEntity = new LogEntity(message);
logEntity.LogEventType = TraceEventType.Error;
logEntity.EventID = ApplicationErrorEventID;
logEntity.StackTrace = detail;
HttpContext context = HttpContext.Current;
try
{
if (context != null)
{
string[] paths = context.Request.ApplicationPath.Split('/');
logEntity.Source = paths[paths.Length - 1];
logEntity.Title = string.Format("{0}应用页面错误", context.Request.ApplicationPath);
logEntity.ExtendedProperties.Add("RequestUrl", context.Request.Url.AbsoluteUri);
logEntity.ExtendedProperties.Add("UserHostAddress", context.Request.UserHostAddress);
if (HttpContext.Current.User != null)
{
logEntity.ExtendedProperties.Add("UserLogOnName", HttpContext.Current.User.Identity.Name);
}
}
}
catch
{
}
return TryWriteAppLog(logEntity);
}
/// <summary>
/// 将LogEntity对象格式化成XML串
/// </summary>
/// <param name="log">LogEntity对象</param>
/// <returns>格式化好的XML串</returns>
/// <remarks>
/// 重载方法，实现格式化
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\FormatterTest.cs"
/// lang="cs" region="Format Test" tittle="获取Formatter对象"></code>
/// </remarks>
public override string Format(LogEntity log)
{
XElement root = new XElement("Root");
Format(log, root);
return root.ToString();
}
private static LogEntity CreateLogEntity(CacheNotifyData notifyData)
{
string message = string.Format("{0}",
notifyData.ToString()
);
LogEntity logEntity = new LogEntity(message);
logEntity.EventID = 7005;
logEntity.LogEventType = TraceEventType.Information;
logEntity.Source = "MmfCache";
logEntity.Title = "发送MmfCache";
logEntity.Priority = LogPriority.Normal;
return logEntity;
}
/// <summary>
/// 重载方法，写入数据
/// </summary>
/// <param name="eventCache">包含当前进程 ID、线程 ID 以及堆栈跟踪信息的 TraceEventCache 对象</param>
/// <param name="source">标识输出时使用的名称，通常为生成跟踪事件的应用程序的名称</param>
/// <param name="logEventType">TraceEventType枚举值，指定引发日志记录的事件类型</param>
/// <param name="eventID">事件的数值标识符</param>
/// <param name="data">要记录的日志数据</param>
/// <remarks>
/// 只有Formatter属性不为空时，才格式化
/// <code source="..\Framework\src\DeluxeWorks.Library\Logging\Logger.cs" lang="cs" region="Process Log" title="写日志"></code>
/// </remarks>
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType logEventType, int eventID, object data)
{
if (data is LogEntity)
{
LogEntity logData = data as LogEntity;
if (this.Formatter != null)
{
this.slaveListener.TraceData(eventCache, source, logEventType, eventID, this.Formatter.Format(logData));
}
else
{
this.slaveListener.TraceData(eventCache, source, logEventType, eventID, logData);
}
}
else
{
this.slaveListener.TraceData(eventCache, source, logEventType, eventID, data);
}
}
/// <summary>
/// 实现ICloneable接口
/// </summary>
/// <returns>
/// 克隆出的LogEntity对象
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\LogEntityTest.cs"
/// lang="cs" region="LogEntityClone Test" tittle="克隆LogEntity对象"></code>
/// </returns>
public object Clone()
{
LogEntity log = new LogEntity(this.Message);
log.EventID = this.EventID;
log.Title = this.Title;
log.Priority = this.Priority;
log.LogEventType = this.LogEventType;
log.MachineName = this.MachineName;
log.StackTrace = this.StackTrace;
log.ActivityID = this.ActivityID;
log.Source = this.Source;
if (this.extendedProperties != null)
{
log.extendedProperties = new Dictionary <string, object>(this.extendedProperties);
}
return(log);
}
public static bool TryWriteAppLog(LogEntity logEntity)
{
bool result = false;
if (logEntity != null)
{
try
{
Logger logger = LoggerFactory.Create("webApplicationError");
logger.Write(logEntity);
result = true;
}
catch
{
}
}
return result;
}
/// <summary>
/// 重载方法，写入数据
/// </summary>
/// <param name="eventCache">包含当前进程 ID、线程 ID 以及堆栈跟踪信息的 TraceEventCache 对象</param>
/// <param name="source">标识输出时使用的名称，通常为生成跟踪事件的应用程序的名称</param>
/// <param name="eventType">TraceEventType枚举值，指定引发日志记录的事件类型</param>
/// <param name="id">事件的数值标识符</param>
/// <param name="data">要记录的日志数据</param>
/// <remarks>
/// <code source="..\Framework\src\DeluxeWorks.Library\Logging\Logger.cs"
/// lang="cs" region="Process Log" title="写日志"></code>
/// </remarks>
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
if (data is LogEntity)
{
LogEntity logData = data as LogEntity;
if (this.Formatter != null)
{
base.Write(this.Formatter.Format(logData));
}
else
{
base.TraceData(eventCache, source, eventType, id, logData);
}
}
else
{
base.TraceData(eventCache, source, eventType, id, data);
}
}
/// <summary>
/// 文本格式化
/// </summary>
/// <param name="templateBuilder">包含格式化模板串的StringBuilder</param>
/// <param name="log">待格式化的LogEntity对象</param>
/// <returns>格式化成的文本串</returns>
private string Format(StringBuilder templateBuilder, LogEntity log)
{
templateBuilder.Replace(TextLogFormatter.TimeStampToken, log.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss"));
templateBuilder.Replace(TextLogFormatter.TitleToken, log.Title);
templateBuilder.Replace(TextLogFormatter.MessageToken, log.Message);
templateBuilder.Replace(TextLogFormatter.EventIdToken, log.EventID.ToString(Resource.Culture));
templateBuilder.Replace(TextLogFormatter.EventTypeToken, log.LogEventType.ToString());
templateBuilder.Replace(TextLogFormatter.StackTraceToken, log.StackTrace);
templateBuilder.Replace(TextLogFormatter.PriorityToken, log.Priority.ToString());
templateBuilder.Replace(TextLogFormatter.MachineToken, log.MachineName);
templateBuilder.Replace(TextLogFormatter.ActivityidToken, log.ActivityID.ToString("D", Resource.Culture));
FormatTokenFunctions(templateBuilder, log);
templateBuilder.Replace(TextLogFormatter.NewLineToken, Environment.NewLine);
templateBuilder.Replace(TextLogFormatter.TabToken, "\t");
return(templateBuilder.ToString());
}
/// <summary>
/// Searches for token functions in the message and replace all with formatted values.
/// </summary>
/// <param name="messageBuilder">Message template containing tokens.</param>
/// <param name="log">Log entry containing properties to format.</param>
public virtual void Format(StringBuilder messageBuilder, LogEntity log)
{
int pos = 0;
while (pos < messageBuilder.Length)
{
string messageString = messageBuilder.ToString();
if (messageString.IndexOf(this.startDelimiter) == -1)
{
break;
}
string tokenTemplate = GetInnerTemplate(pos, messageString);
string tokenToReplace = this.startDelimiter + tokenTemplate + this.endDelimiter;
pos = messageBuilder.ToString().IndexOf(tokenToReplace);
string tokenValue = FormatToken(tokenTemplate, log);
messageBuilder.Replace(tokenToReplace, tokenValue);
}
}
/// <summary>
/// Formats the timestamp property with the specified date time format string.
/// </summary>
/// <param name="tokenTemplate">Date time format string.</param>
/// <param name="log">Log entry containing the timestamp.</param>
/// <returns>Returns the formatted time stamp.</returns>
public override string FormatToken(string tokenTemplate, LogEntity log)
{
string result = null;
if (tokenTemplate.Equals(TimeStampToken.LocalStartDelimiter, System.StringComparison.InvariantCultureIgnoreCase))
{
System.DateTime localTime = log.TimeStamp.ToLocalTime();
result = localTime.ToString();
}
else if (tokenTemplate.StartsWith(TimeStampToken.LocalStartDelimiterWithFormat, System.StringComparison.InvariantCultureIgnoreCase))
{
string formatTemplate = tokenTemplate.Substring(TimeStampToken.LocalStartDelimiterWithFormat.Length);
System.DateTime localTime = log.TimeStamp.ToLocalTime();
result = localTime.ToString(formatTemplate, CultureInfo.CurrentCulture);
}
else
{
result = log.TimeStamp.ToString(tokenTemplate, CultureInfo.CurrentCulture);
}
return(result);
}
/// <summary>
/// 重载方法，写入文件
/// </summary>
/// <param name="eventCache">包含当前进程 ID、线程 ID 以及堆栈跟踪信息的 TraceEventCache 对象</param>
/// <param name="source">标识输出时使用的名称，通常为生成跟踪事件的应用程序的名称</param>
/// <param name="logEventType">TraceEventType枚举值，指定引发日志记录的事件类型</param>
/// <param name="eventID">事件的数值标识符</param>
/// <param name="data">要记录的日志数据</param>
/// <remarks>
/// <code source="..\Framework\src\DeluxeWorks.Library\Logging\Logger.cs"
/// lang="cs" region="Process Log" title="写日志"></code>
/// </remarks>
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType logEventType, int eventID, object data)
{
if (data is LogEntity)
{
LogEntity logData = data as LogEntity;
//取LogEntity对象的Source属性，如果为空则取来源于配置的缺省值
string sourceName = string.IsNullOrEmpty(logData.Source) ? this.source : logData.Source;
if (this.WriteTraceData(eventCache, this.logName, sourceName, logEventType, eventID, data) == false)
{
string registerLogName = this.RegisterSourceToLogName(sourceName, this.logName);
this.WriteTraceData(eventCache, registerLogName, sourceName, logEventType, eventID, data);
}
}
else
{
base.TraceData(eventCache, source, logEventType, eventID, data);
}
}
private void ProcessLog(LogEntity log)
{
//if (!ShouldTrace(log.LogEventType))
// return;
TraceEventCache cache = new TraceEventCache();
//bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null;
foreach (TraceListener listener in this.Listeners)
{
try
{
listener.TraceData(cache, log.Source, log.LogEventType, log.EventID, log);
listener.Flush();
}
catch (Exception ex)
{
if (listener is FormattedEventLogTraceListener)
{
try
{
string msg = string.Format("{1}[{0:yyyy-MM-dd HH:mm:ss}] \n 错误堆栈为：{2}", DateTime.Now, ex.Message, ex.StackTrace);
EventLog.WriteEntry("Application", "写事件查看器异常：" + msg, EventLogEntryType.Warning);
}
catch (Exception)
{
}
}
else
{
throw;
}
}
}
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="message">日志消息</param>
/// <param name="priority">日志优先级</param>
/// <param name="eventId">日志事件</param>
/// <param name="logEventType">日志事件类型</param>
/// <param name="title">日志标题</param>
public void Write(string message, LogPriority priority, int eventId,
TraceEventType logEventType, string title)
{
try
{
UpdateLastMsg(message);
LogEntity log = new LogEntity(title, message, eventId, priority, logEventType, this.name, string.Empty, null);
this.logger.Write(log);
}
catch (LogException ex)
{
this.WriteDebugString(ex, EventLogEntryType.Warning, ServiceLogEventID.SERVICEBASE_WRITELOG);
}
}
/// <summary> /// 抽象方法，格式化LogEntity对象成一个字符串 /// </summary> /// <param name="log">待格式化的LogEntity对象</param> /// <returns>格式化成的字符串</returns> /// <remarks> /// 由派生类具体实现 /// <code source="..\Framework\src\DeluxeWorks.Library\Logging\Formatters\TextFormatter.cs" /// lang="cs" region="Format Implementation" title="文本格式化方法"></code> /// </remarks> public abstract string Format(LogEntity log);
/// <summary>
/// 文本格式化方法
/// </summary>
/// <param name="log">待格式化的LogEntity对象</param>
/// <returns>格式化成的文本串</returns>
/// <remarks>
/// 重载方法，实现文本格式化
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\FormatterTest.cs"
/// lang="cs" region="Format Test" tittle="获取Formatter对象"></code>
/// </remarks>
public override string Format(LogEntity log)
{
return(Format(CreateTemplateBuilder(), log));
}
/// <summary>
/// 文本格式化
/// </summary>
/// <param name="templateBuilder">包含格式化模板串的StringBuilder</param>
/// <param name="log">待格式化的LogEntity对象</param>
/// <returns>格式化成的文本串</returns>
private string Format(StringBuilder templateBuilder, LogEntity log)
{
templateBuilder.Replace(TextLogFormatter.TimeStampToken, log.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss"));
templateBuilder.Replace(TextLogFormatter.TitleToken, log.Title);
templateBuilder.Replace(TextLogFormatter.MessageToken, log.Message);
templateBuilder.Replace(TextLogFormatter.EventIdToken, log.EventID.ToString(Resource.Culture));
templateBuilder.Replace(TextLogFormatter.EventTypeToken, log.LogEventType.ToString());
templateBuilder.Replace(TextLogFormatter.StackTraceToken, log.StackTrace);
templateBuilder.Replace(TextLogFormatter.PriorityToken, log.Priority.ToString());
templateBuilder.Replace(TextLogFormatter.MachineToken, log.MachineName);
templateBuilder.Replace(TextLogFormatter.ActivityidToken, log.ActivityID.ToString("D", Resource.Culture));
FormatTokenFunctions(templateBuilder, log);
templateBuilder.Replace(TextLogFormatter.NewLineToken, Environment.NewLine);
templateBuilder.Replace(TextLogFormatter.TabToken, "\t");
return templateBuilder.ToString();
}
private static void WriteExceptionToLog(System.Exception ex)
{
Logger logger = LoggerFactory.Create("webApplicationError");
LogEntity logEntity = new LogEntity(ex);
HttpContext context = HttpContext.Current;
logEntity.LogEventType = ApplicationErrorLogSection.GetSection().GetExceptionLogEventType(ex);
string[] paths = context.Request.ApplicationPath.Split('/');
logEntity.StackTrace = ex.StackTrace;
logEntity.Source = paths[paths.Length - 1];
logEntity.Title = string.Format("{0}应用页面错误", context.Request.ApplicationPath);
logEntity.ExtendedProperties.Add("RequestUrl", context.Request.Url.AbsoluteUri);
ExceptionHelper.DoSilentAction(() =>
{
if (DeluxeIdentity.CurrentUser != null)
{
logEntity.ExtendedProperties.Add("UserLogOnName", DeluxeIdentity.CurrentUser.LogOnName);
logEntity.ExtendedProperties.Add("UserFullPath", DeluxeIdentity.CurrentUser.FullPath);
logEntity.ExtendedProperties.Add("UserDisplayName", DeluxeIdentity.CurrentUser.DisplayName);
}
});
logger.Write(logEntity);
}
/// <summary> /// Abstract method to process the token value between the start and end delimiter. /// </summary> /// <param name="tokenTemplate">Token value between the start and end delimiters.</param> /// <param name="log">Log entry to process.</param> /// <returns>Formatted value to replace the token.</returns> public abstract string FormatToken(string tokenTemplate, LogEntity log);
private static void WriteExceptionToLog(System.Exception ex)
{
Logger logger = LoggerFactory.Create("webApplicationError");
LogEntity logEntity = new LogEntity(ex);
HttpContext context = HttpContext.Current;
logEntity.LogEventType = ApplicationErrorLogSection.GetSection().GetExceptionLogEventType(ex);
string[] paths = context.Request.ApplicationPath.Split('/');
logEntity.StackTrace = ex.StackTrace;
logEntity.Source = paths[paths.Length - 1];
logEntity.Title = string.Format("{0}应用页面错误", context.Request.ApplicationPath);
logEntity.ExtendedProperties.Add("RequestUrl", context.Request.Url.AbsoluteUri);
try
{
if (HttpContext.Current.User != null && HttpContext.Current.User.Identity != null && HttpContext.Current.User.Identity.IsAuthenticated)
{
logEntity.ExtendedProperties.Add("UserLogOnName", HttpContext.Current.User.Identity.Name);
}
}
catch
{
}
logger.Write(logEntity);
}
/// <summary> /// 抽象方法，格式化LogEntity对象成一个字符串 /// </summary> /// <param name="log">待格式化的LogEntity对象</param> /// <returns>格式化成的字符串</returns> /// <remarks> /// 由派生类具体实现 /// <code source="..\Framework\src\DeluxeWorks.Library\Logging\Formatters\TextFormatter.cs" /// lang="cs" region="Format Implementation" title="文本格式化方法"></code> /// </remarks> public abstract string Format(LogEntity log);
private void ProcessLog(LogEntity log)
{
//if (!ShouldTrace(log.LogEventType))
// return;
TraceEventCache cache = new TraceEventCache();
//bool isTransfer = logEntry.Severity == TraceEventType.Transfer && logEntry.RelatedActivityId != null;
foreach (TraceListener listener in this.Listeners)
{
try
{
listener.TraceData(cache, log.Source, log.LogEventType, log.EventID, log);
listener.Flush();
}
catch (Exception ex)
{
if (listener is FormattedEventLogTraceListener)
{
try
{
string msg = string.Format("{1}[{0:yyyy-MM-dd HH:mm:ss}] \n 错误堆栈为：{2}", DateTime.Now, ex.Message, ex.StackTrace);
EventLog.WriteEntry("Application", "写事件查看器异常：" + msg, EventLogEntryType.Warning);
}
catch (Exception)
{
}
}
else
throw;
}
}
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="message">日志消息</param>
/// <param name="priority">日志优先级</param>
/// <param name="eventId">日志事件ID</param>
/// <param name="logEventType">日志事件类型</param>
/// <param name="title">日志标题</param>
/// <remarks>
/// 根据传递的参数，构建LogEntity对象，并写入媒介
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\LoggerTest.cs"
/// lang="cs" region="Logger Write Test" tittle="写日志信息"></code>
/// </remarks>
public void Write(string message, LogPriority priority, int eventId,
TraceEventType logEventType, string title)
{
LogEntity log = new LogEntity(message);
log.Priority = priority;
log.EventID = eventId;
log.LogEventType = logEventType;
log.Title = title;
Write(log);
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="log">待写的日志记录</param>
/// <remarks>
/// 写日志信息的方法
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\LoggerTest.cs"
/// lang="cs" region="Logger Write Test" tittle="写日志信息"></code>
/// </remarks>
public void Write(LogEntity log)
{
lock (syncObject)
{
try
{
if (this.enableLog && this.FilterPipeline.IsMatch(log))
{
ProcessLog(log);
}
}
catch (LogException)
{
throw;
}
catch (Exception ex)
{
if (ex is LogException)
throw;
else
throw new LogException("写日志信息时出错：" + ex.Message, ex);
}
}
}
public void Write(string title, Exception ex, TraceEventType eventType, int eventId)
{
LogEntity log = new LogEntity(ex);
log.EventID = eventId;
log.Title = title;
log.LogEventType = eventType;
log.ExtendedProperties.Add("exceptionType", ex.GetType());
UpdateLastExceptionMessage(ex);
this.Write(log);
}
/// <summary> /// 抽象方法，实现日志过滤 /// </summary> /// <param name="log">日志对象</param> /// <returns>布尔值，true：通过，false：不通过</returns> public abstract bool IsMatch(LogEntity log);
/// <summary>
/// 写信息
/// </summary>
/// <param name="message">日志信息</param>
public void Write(string message)
{
LogEntity log = new LogEntity(message);
UpdateLastMsg(message);
this.Write(log);
}
public static bool TryWriteAppLog(this Exception ex, string detail)
{
bool result = false;
if (ex != null)
{
LogEntity logEntity = new LogEntity(ex);
logEntity.LogEventType = ApplicationErrorLogSection.GetSection().GetExceptionLogEventType(ex);
logEntity.EventID = ApplicationErrorEventID;
logEntity.StackTrace = detail;
HttpContext context = HttpContext.Current;
try
{
if (context != null)
{
string[] paths = context.Request.ApplicationPath.Split('/');
logEntity.Source = paths[paths.Length - 1];
logEntity.Title = string.Format("{0}应用页面错误", context.Request.ApplicationPath);
logEntity.ExtendedProperties.Add("RequestUrl", context.Request.Url.AbsoluteUri);
logEntity.ExtendedProperties.Add("UserHostAddress", context.Request.UserHostAddress);
if (HttpContext.Current.User != null)
logEntity.ExtendedProperties.Add("UserLogOnName", HttpContext.Current.User.Identity.Name);
}
}
catch
{
}
result = TryWriteAppLog(logEntity);
}
return result;
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="message">日志消息</param>
/// <param name="eventId">日志事件</param>
/// <param name="title">日志标题</param>
public void Write(string title, string message, int eventId)
{
LogEntity log = new LogEntity(title, message, eventId);
UpdateLastMsg(message);
this.Write(log);
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="log">待写的日志记录对象</param>
public void Write(LogEntity log)
{
ExceptionHelper.FalseThrow(log != null, "LogEntity对象为空");
try
{
UpdateLastMsg(log.Message);
if (string.IsNullOrEmpty(log.Source))
log.Source = this.name;
this.logger.Write(log);
}
catch (Exception ex)
{
this.WriteDebugString(ex, EventLogEntryType.Warning, ServiceLogEventID.SERVICEBASE_WRITELOG);
}
}
/// <summary>
/// 写错误日志
/// </summary>
/// <param name="ex"></param>
/// <param name="control"></param>
private static void TryWriteLog(Exception ex, Control control)
{
try
{
Logger logger = LoggerFactory.Create("webControlInvokeError");
LogEntity logEntity = new LogEntity(ex);
HttpContext context = HttpContext.Current;
logEntity.Source = control.GetType().Name;
logEntity.Title = string.Format("{0}控件回调错误", control.GetType().Name);
logEntity.ExtendedProperties.Add("RequestUrl", context.Request.Url.AbsoluteUri);
if (HttpContext.Current.User != null)
logEntity.ExtendedProperties.Add("UserLogOnName", HttpContext.Current.User.Identity.Name);
logger.Write(logEntity);
}
catch
{
}
}
/// <summary> /// 抽象方法，实现日志过滤 /// </summary> /// <param name="log">日志对象</param> /// <returns>布尔值，true：通过，false：不通过</returns> public abstract bool IsMatch(LogEntity log);
/// <summary>
/// 覆写的方法，具体实现优先级过滤
/// </summary>
/// <param name="log">日志记录</param>
/// <returns>布尔值，true：通过，false：不通过</returns>
/// <remarks>
/// 只有优先级大于等于minPriority的日志记录才能通过
/// </remarks>
public override bool IsMatch(LogEntity log)
{
return(log.Priority >= this.minPriority);
}
/// <summary>
/// 文本格式化方法
/// </summary>
/// <param name="log">待格式化的LogEntity对象</param>
/// <returns>格式化成的文本串</returns>
/// <remarks>
/// 重载方法，实现文本格式化
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\FormatterTest.cs"
/// lang="cs" region="Format Test" tittle="获取Formatter对象"></code>
/// </remarks>
public override string Format(LogEntity log)
{
return Format(CreateTemplateBuilder(), log);
}
/// <summary>
/// 实现ICloneable接口
/// </summary>
/// <returns>
/// 克隆出的LogEntity对象
/// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Test\\Logging\LogEntityTest.cs"
/// lang="cs" region="LogEntityClone Test" tittle="克隆LogEntity对象"></code>
/// </returns>
public object Clone()
{
LogEntity log = new LogEntity(this.Message);
log.EventID = this.EventID;
log.Title = this.Title;
log.Priority = this.Priority;
log.LogEventType = this.LogEventType;
log.MachineName = this.MachineName;
log.StackTrace = this.StackTrace;
log.ActivityID = this.ActivityID;
log.Source = this.Source;
if (this.extendedProperties != null)
log.extendedProperties = new Dictionary<string, object>(this.extendedProperties);
return log;
}
private void FormatTokenFunctions(StringBuilder templateBuilder, LogEntity log)
{
foreach (TokenFunction token in this.tokenFunctions)
{
token.Format(templateBuilder, log);
}
}
/// <summary>
/// 覆写的方法，具体实现优先级过滤
/// </summary>
/// <param name="log">日志记录</param>
/// <returns>布尔值，true：通过，false：不通过</returns>
/// <remarks>
/// 只有优先级大于等于minPriority的日志记录才能通过
/// </remarks>
public override bool IsMatch(LogEntity log)
{
return log.Priority >= this.minPriority;
}
/// <summary>
/// 创建Log项
/// </summary>
/// <param name="notifyData"></param>
/// <returns></returns>
protected virtual LogEntity CreateLogEntity(CacheNotifyData notifyData)
{
LogEntity logEntity = new LogEntity(notifyData.ToString());
logEntity.EventID = 7002;
logEntity.LogEventType = TraceEventType.Information;
logEntity.Source = GetLogSource();
logEntity.Title = "接收Cache";
logEntity.Priority = LogPriority.Normal;
return logEntity;
}
private static LogEntity CreateLogEntity(CacheNotifyData notifyData, UdpCacheNotifierTarget endPoint)
{
string message = string.Format("{0}, {1}",
notifyData.ToString(),
endPoint.ToString()
);
LogEntity logEntity = new LogEntity(message);
logEntity.EventID = 7001;
logEntity.LogEventType = TraceEventType.Information;
logEntity.Source = "UdpCache";
logEntity.Title = "发送UdpCache";
logEntity.Priority = LogPriority.Normal;
return logEntity;
}
