/// <summary>
/// 重写ToString
/// </summary>
/// <returns>String</returns>
public override string ToString()
{
string logMsg;
try
{
logMsg = this.Message;
if (string.IsNullOrWhiteSpace(logMsg))
{
if (this.Exception != null)
{
logMsg = this.Exception.ToString();
}
}
else
{
if (this.Exception != null)
{
logMsg = string.Format("{0},{1}", logMsg, this.Exception.ToString());
}
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog("LogItem", ex);
logMsg = "日志异常";
}
return(logMsg);
}
/// <summary>
/// 实例添加日志
/// </summary>
/// <param name="skipFrames"></param>
/// <param name="level">日志级别</param>
/// <param name="eventId">事件ID</param>
/// <param name="tag">与对象关联的用户定义数据</param>
/// <param name="ex">异常</param>
/// <param name="format">复合格式字符串,参数为空或null表示无格式化</param>
/// <param name="args">一个对象数组，其中包含零个或多个要设置格式的对象</param>
protected override void PrimitiveAddLog(int skipFrames, LogLevel level, int eventId, object tag, Exception ex, string format, params object[] args)
{
try
{
if (!this.Enable || level < this.Level)
{
return;
}
var item = new LogItem(DateTime.Now, Thread.CurrentThread, skipFrames, true, this.Name, level, eventId, tag, ex, format, args);
if (this._thread)
{
this._logDispatcherQueue.Enqueue(item);
}
else
{
lock (this._lock)
{
this.RecordLogCallback(item);
}
}
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(this, exi);
}
}
private List <FileInfo> GetAllLogFileInfo()
{
List <FileInfo> srcFileInfos = new List <FileInfo>();
try
{
if (this._pathItems.Length == 1)
{
//存放于日志根目录
srcFileInfos.AddRange(base.RootDirectoryInfo.GetFiles(base._searchPattern, SearchOption.TopDirectoryOnly));
}
else
{
//存放于需要实时创建目录的子目录
var dirInfos = base.RootDirectoryInfo.GetDirectories("*.*", SearchOption.TopDirectoryOnly);
foreach (var dirInfo in dirInfos)
{
try
{
srcFileInfos.AddRange(dirInfo.GetFiles(base._searchPattern, SearchOption.AllDirectories));
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(this, exi);
}
}
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
return(srcFileInfos);
}
/// <summary>
/// 初始化
/// </summary>
private void Init()
{
this._fileLogWriter = null;
var fileAppenderConfig = (FileAppenderConfig)base._config;
this._fileAppenderConfig = fileAppenderConfig;
var pathManager = new FileAppenderPathManager(this._fileAppenderConfig);
switch (this._fileAppenderConfig.LockingModel)
{
case LockingModel.Exclusive:
this._fileLogWriter = new ExclusiveFileLogWriter(fileAppenderConfig, pathManager);
break;
case LockingModel.Minimal:
this._fileLogWriter = new MinimalFileLogWriter(fileAppenderConfig, pathManager);
break;
case LockingModel.InterProcess:
this._fileLogWriter = new InterProcessFileLogWriter(fileAppenderConfig, pathManager);
break;
default:
LogSysInnerLog.OnRaiseLog(this, new NotSupportedException(string.Format("不支持的锁模型:{0}", this._fileAppenderConfig.LockingModel.ToString())));
break;
}
}
private void RecoverIndex()
{
try
{
string[] logFilePaths = Directory.GetFiles(base._rootDir, base._searchPattern, SearchOption.TopDirectoryOnly);
int index = 1, tmpIndex;
string indexStr;
foreach (var logFilePath in logFilePaths)
{
try
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(logFilePath);
indexStr = fileNameWithoutExtension.Substring(this._fileNameWithoutExtension.Length);
if (int.TryParse(indexStr, out tmpIndex))
{
if (tmpIndex > index)
{
index = tmpIndex;
}
}
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(this, exi);
}
}
this._index = index + 1;
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
/// <summary>
/// 清理过期的日志文件
/// </summary>
private void ClearExpireLogFile(string currentLogDir)
{
try
{
List <FileInfo> fileInfos = this.GetAllLogFileInfos();
var hsDelLogFileFullPathDirs = new HashSet <string>();
//按日志保留天数删除
base.DeleteLogFileByDays(fileInfos, hsDelLogFileFullPathDirs);
//按日志文件个数删除日志
base.DeleteLogFileByFileCount(fileInfos, hsDelLogFileFullPathDirs);
//排除本次写日志目录
if (hsDelLogFileFullPathDirs.Contains(currentLogDir))
{
hsDelLogFileFullPathDirs.Remove(currentLogDir);
}
//删除空目录
this.DeleteEmptyDirectory(hsDelLogFileFullPathDirs);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog("清除过期日志异常", ex);
}
}
/// <summary>
/// 获取进程锁
/// </summary>
/// <returns>进程锁</returns>
private Mutex GetMutex(string logFilePath)
{
string mutexName = logFilePath.Replace("\\", "_").Replace(":", "_").Replace("/", "_");
Mutex mutex = null;
while (mutex == null)
{
try
{
//如果此命名互斥对象已存在则请求打开
try
{
//如果此命名互斥对象已存在则请求打开
mutex = Mutex.OpenExisting(mutexName);
}
catch (WaitHandleCannotBeOpenedException)
{
//打开失败则创建一个
mutex = new Mutex(false, mutexName);
}
mutex.WaitOne();
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
Thread.Sleep(10);
}
}
return(mutex);
}
/// <summary>
/// 日志输出
/// </summary>
/// <param name="logItem">要输出的日志项</param>
internal void OnRaiseLogOutput(RedirectOuputItem logItem)
{
try
{
if (!string.IsNullOrEmpty(this._loggerName) &&
!string.Equals(this._loggerName, logItem.Item.LogerName))
{
//日志记录器名称不为空或null,且与产生日志的日志记录器名称不匹配，直接返回
return;
}
if (!string.IsNullOrEmpty(this._appenderName) &&
!string.Equals(this._appenderName, logItem.AppenderName))
{
//日志重定制追加器名称不为空或null,且与重定向日志追加器名称不匹配，直接返回
return;
}
var handler = this._logOutput;
if (handler == null || logItem == null)
{
//重定向委托为空，直接返回
return;
}
handler(logItem);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
protected void DeleteLogFileByFileCount(List <FileInfo> fileInfos, HashSet <string> hsDelLogFileFullPathDirs)
{
if (this._config.MaxFileCount < 1 || fileInfos.Count < this._config.MaxFileCount)
{
return;
}
int delCount = fileInfos.Count - this._config.MaxFileCount;
if (delCount < 1)
{
return;
}
var delFileInfos = fileInfos.OrderBy(t => { return(t.LastWriteTime); }).Take(delCount).ToArray();
foreach (var delFileInfo in delFileInfos)
{
try
{
delFileInfo.Delete();
if (hsDelLogFileFullPathDirs != null)
{
hsDelLogFileFullPathDirs.Add(delFileInfo.Directory.FullName);
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
}
/// <summary>
/// 日志输出线程方法
/// </summary>
/// <param name="obj">参数</param>
private static void LogOutputThreadMethod(object obj)
{
var token = _cts.Token;
RedirectOuputItem item;
while (!token.IsCancellationRequested)
{
try
{
if (_logOutputQueue.Count == 0)
{
_logOutputAutoResetEvent.WaitOne();
}
if (_logOutputQueue.Count == 0)
{
continue;
}
if (_logOutputQueue.TryDequeue(out item))
{
LogOutput(item);
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(null, ex);
}
}
}
protected string GetLastWriteLogFilePath(string dir)
{
try
{
string[] filePaths = Directory.GetFiles(dir, this._searchPattern, SearchOption.TopDirectoryOnly);
if (filePaths.Length == 0)
{
return(null);
}
DateTime currenttime = DateTime.Now;
TimeSpan tsCurrentTime = currenttime - this._defaultTime;
DateTime createTime;
TimeSpan tsCreateTime;
List <LogFileInfo> orderLogFilePathList = new List <LogFileInfo>();
foreach (var filePath in filePaths)
{
if (this.CheckPath(filePath, out createTime))
{
//createTime = File.GetCreationTime(filePath);
if ((currenttime - createTime).Days > 2)
{
//如果日志文件时间在两天之外,不作为参考
continue;
}
tsCreateTime = createTime - this._defaultTime;
if (tsCreateTime.TotalDays <= tsCurrentTime.TotalDays)
{
orderLogFilePathList.Add(new LogFileInfo(createTime, filePath));
}
}
}
if (orderLogFilePathList.Count == 0)
{
//当前日志目录下没有符合路径标准的日志文件
return(null);
}
var lastLogFilePath = orderLogFilePathList.OrderByDescending(t => { return(t.CreateTime); }).FirstOrDefault().FilePath;
if (this.CompareLastLogFilePath(new FileInfo(lastLogFilePath)))
{
//最后一个文件符合追加
return(lastLogFilePath);
}
else
{
//最后一个文件不符合追加
return(null);
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog("获取最后一个日志文件路径异常", ex);
return(null);
}
}
/// <summary>
/// 释放进程锁
/// </summary>
/// <param name="mutex">进程锁</param>
private void ReleaseMutex(Mutex mutex)
{
try
{
if (mutex != null)
{
mutex.ReleaseMutex();
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
private static void CreateAppender(XElement appenderEle, Loger loger)
{
string appenderName = LogUtil.GetAttributeValue(appenderEle, "name");
try
{
string appenderTypeName = LogUtil.GetAttributeValue(appenderEle, "type");
if (string.IsNullOrWhiteSpace(appenderTypeName))
{
return;
}
appenderTypeName = appenderTypeName.Trim();
AppenderBase appender;
if (appenderTypeName.Length == 1)
{
appender = CreateAppenderByAppenderPattern(appenderTypeName, appenderEle);
}
else
{
if (!appenderTypeName.Contains('.') && !appenderTypeName.Contains(','))
{
Type appenderBaseType = typeof(AppenderBase);
appenderTypeName = string.Format("{0}.{1},{2}", appenderBaseType.Namespace, appenderTypeName, Path.GetFileName(appenderBaseType.Assembly.Location));
}
Type appenderType = LogUtil.GetType(appenderTypeName);
if (appenderType == null)
{
return;
}
appender = Activator.CreateInstance(appenderType, new object[] { (object)appenderEle }) as AppenderBase;
}
if (appender == null)
{
return;
}
appender.Name = appenderName;
loger._appenders.Add(appender);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(string.Format("解析:{0}日志追加器异常", appenderName), ex);
}
}
/// <summary>
/// 加载配置,加载前清空旧的配置
/// </summary>
/// <param name="configFilePath">配置文件路径</param>
public static void LoadConfig(string configFilePath)
{
if (!File.Exists(configFilePath))
{
return;
}
try
{
var xdoc = XDocument.Load(configFilePath);
PrimitiveLoadConfig(xdoc);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog("加载配置文件异常", ex);
}
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="item">日志项</param>
protected override void PrimitiveWriteLog(LogItem item)
{
try
{
if (this._consoleAppenderConfig == null || !base.Validate(this._consoleAppenderConfig, item))
{
return;
}
string logMsg = base.LayoutLog(item);
Console.WriteLine(logMsg);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
public FileLogWriterBase(FileAppenderConfig fileAppenderConfig, FileAppenderPathManager pathManager)
{
this._fileAppenderConfig = fileAppenderConfig;
this._pathManager = pathManager;
try
{
Type type = LogUtil.GetType(fileAppenderConfig.SecurityPolicy);
if (type != null && type.GetInterface(typeof(ILogSecurityPolicy).FullName) != null)
{
this._securityPolicy = Activator.CreateInstance(type) as ILogSecurityPolicy;
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
private void ClearExpireLogFile(string currentLogDir)
{
try
{
List <FileInfo> fileInfos = this.GetAllLogFileInfos();
//按日志保留天数删除
base.DeleteLogFileByDays(fileInfos, null);
//按日志文件个数删除日志
base.DeleteLogFileByFileCount(fileInfos, null);
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog("清除过期日志异常", ex);
}
}
private static void SAddLog(LogLevel level, int eventId, object tag, Exception ex, string format, params object[] args)
{
try
{
var loger = _defaultLoger as LogerBase;
if (loger == null)
{
return;
}
loger.ObjectAddLog(level, eventId, tag, ex, format, args);
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(null, exi);
}
}
/// <summary>
/// 获取类型名称字符串
/// </summary>
/// <param name="type">类型</param>
/// <returns>类型名称字符串</returns>
private string GetTypeNameStr(Type type)
{
string typeNameStr;
try
{
if (type.IsPrimitive)
{
typeNameStr = type.Name;
}
else
{
if (type.IsGenericType)
{
int splitIndex = type.Name.IndexOf('`');
if (splitIndex < 1)
{
typeNameStr = type.FullName;
}
else
{
typeNameStr = type.Name.Substring(0, splitIndex);
}
}
else
{
if (TypeCode.String == Type.GetTypeCode(type))
{
typeNameStr = type.Name;
}
else
{
typeNameStr = type.FullName;
}
}
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(null, ex);
typeNameStr = type.FullName;
}
return(typeNameStr);
}
private static void StaticStructLoadLogConfig()
{
try
{
const string logConfigFileName = LogConstant.DEFAULT_CONFIG_FILE_NAME;
if (File.Exists(logConfigFileName))
{
LoadConfig(logConfigFileName);
}
else
{
string[] xmlFilePathArr = Directory.GetFiles(LogConstant.CurrentAssemblyDirectory, "*.xml", SearchOption.TopDirectoryOnly);
if (xmlFilePathArr.Length == 0)
{
CreateDefaultLoger();
}
else
{
foreach (var xmlFilePath in xmlFilePathArr)
{
try
{
var xdoc = XDocument.Load(xmlFilePath);
if (PrimitiveLoadConfig(xdoc))
{
return;
}
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog($"加载日志配置[{xmlFilePath}]异常", exi);
}
}
LogSysInnerLog.OnRaiseLog("没有可用的日志配置文件,使用默认配置", null);
CreateDefaultLoger();
}
}
}
catch (Exception ex)
{
CreateDefaultLoger();
LogSysInnerLog.OnRaiseLog("加载日志配置异常,使用默认配置", ex);
}
}
private void RecordLogCallback(LogItem item)
{
item.LogProcess();
lock (base._appendersLock)
{
foreach (var appender in base._appenders)
{
try
{
appender.WriteLog(item);
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(this, exi);
}
}
}
}
private void GenerateContent(Exception ex)
{
StringBuilder sbContent = new StringBuilder();
string message = this.Format;
if (!string.IsNullOrEmpty(message))
{
if (this.Args != null && this.Args.Length > 0)
{
try
{
message = string.Format(message, this.Args);
}
catch (Exception exi)
{
LogSysInnerLog.OnRaiseLog(this, exi);
}
}
sbContent.Append(message);
}
this.Message = message;
if (ex != null)
{
if (sbContent.Length > 0)
{
sbContent.Append("。");
}
Exception innerEx = ex;
while (innerEx != null)
{
sbContent.Append(string.Format("{0}: {1}", innerEx.GetType().FullName, innerEx.Message));
innerEx = innerEx.InnerException;
if (innerEx != null)
{
sbContent.Append(" ---> ");
}
}
}
this.Content = sbContent.ToString();
}
/// <summary>
/// 获得方法参数字符串
/// </summary>
/// <param name="parameters">参数数组</param>
/// <returns>方法参数字符串</returns>
private string GetMethodParamtersString(ParameterInfo[] parameters)
{
StringBuilder sbParameter = new StringBuilder();
bool getStackTraceMethodParameterNameType = _getStackTraceMethodParameterNameType;
StringBuilder sbGenericTypeParameter = new StringBuilder();
string parameterTypeName;
foreach (ParameterInfo parameter in parameters)
{
if (getStackTraceMethodParameterNameType)
{
if (parameter.ParameterType.IsGenericType)
{
try
{
sbGenericTypeParameter.Clear();
this.AppendGenericArgumentType(sbGenericTypeParameter, parameter.ParameterType);
parameterTypeName = sbGenericTypeParameter.ToString();
}
catch (Exception ex)
{
parameterTypeName = this.GetTypeNameStr(parameter.ParameterType);
LogSysInnerLog.OnRaiseLog(null, ex);
}
}
else
{
parameterTypeName = this.GetTypeNameStr(parameter.ParameterType);
}
}
else
{
parameterTypeName = parameter.ParameterType.Name;
}
sbParameter.Append(parameterTypeName);
sbParameter.Append(MethodParameterTypeParameterNameSpacing);
sbParameter.Append(parameter.Name);
sbParameter.Append(MethodParameterSpacing);
}
sbParameter = sbParameter.Remove(sbParameter.Length - MethodParameterSpacing.Length, MethodParameterSpacing.Length);
return(sbParameter.ToString());
}
private void DeleteEmptyDirectory(HashSet <string> hsDelLogFileFullPathDirs)
{
if (hsDelLogFileFullPathDirs.Count == 0)
{
return;
}
foreach (var delLogFileFullPathDir in hsDelLogFileFullPathDirs)
{
try
{
//级联删除空目录
var delDirInfo = new DirectoryInfo(delLogFileFullPathDir);
while (true)
{
if (!delDirInfo.Exists)
{
delDirInfo = delDirInfo.Parent;
continue;
}
if (delDirInfo.GetFileSystemInfos("*.*", SearchOption.AllDirectories).Length == 0)
{
delDirInfo.Delete();
}
else
{
break;
}
delDirInfo = delDirInfo.Parent;
if (string.Equals(this._rootDir, delDirInfo.FullName, StringComparison.OrdinalIgnoreCase))
{
break;
}
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
}
/// <summary>
/// 释放日志资源
/// </summary>
public static void Release()
{
try
{
foreach (var loger in _logerDic.Values)
{
loger.Dispose();
}
if (_defaultLoger != null)
{
_defaultLoger.Dispose();
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(null, ex);
}
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="item">日志项</param>
protected override void PrimitiveWriteLog(LogItem item)
{
try
{
if (this._fileAppenderConfig == null ||
this._fileLogWriter == null ||
!base.Validate(this._fileAppenderConfig, item) ||
!this._fileAppenderConfig.Enable)
{
return;
}
string logMsg = base.LayoutLog(item);
this._fileLogWriter.WriteLog(new LogMessageItem(item.LogerName, logMsg));
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="item">日志项</param>
protected override void PrimitiveWriteLog(LogItem item)
{
try
{
if (this._redirectAppendConfig == null ||
!base.Validate(this._redirectAppendConfig, item))
{
return;
}
var handler = this.RedirectOuput;
if (handler != null)
{
handler(this, new RedirectOuputArgs(item));
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
protected void DeleteLogFileByDays(List <FileInfo> fileInfos, HashSet <string> hsDelLogFileFullPathDirs)
{
int days = this._config.Days;
if (days < 1)
{
return;
}
var currentClearTime = DateTime.Now;
if (currentClearTime.Year != this._lastClearExpireDaysTime.Year ||
currentClearTime.Month != this._lastClearExpireDaysTime.Month ||
currentClearTime.Day != this._lastClearExpireDaysTime.Day)
{
TimeSpan tsDuration;
foreach (var fileInfo in fileInfos.ToArray())
{
tsDuration = currentClearTime - fileInfo.LastWriteTime;
if (tsDuration.TotalDays - days > 0)
{
try
{
fileInfo.Delete();
fileInfos.Remove(fileInfo);
if (hsDelLogFileFullPathDirs != null)
{
hsDelLogFileFullPathDirs.Add(fileInfo.Directory.FullName);
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
}
this._lastClearExpireDaysTime = currentClearTime;
}
}
/// <summary>
/// 线程方法
/// </summary>
private void LogThreadMethod()
{
try
{
T item;
var token = this._cts.Token;
while (!token.IsCancellationRequested)
{
try
{
if (this._queue.Count == 0)
{
try
{
this._enqueueEventHandler.WaitOne();
continue;
}
catch (ObjectDisposedException)
{
break;
}
}
if (this._queue.TryDequeue(out item))
{
this._processAction(item);
}
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
}
catch (Exception e)
{
LogSysInnerLog.OnRaiseLog(this, e);
}
}
/// <summary>
/// 释放资源方法
/// </summary>
/// <param name="isDisposing">是否释放标识</param>
protected override void Dispose(bool isDisposing)
{
if (this._thread)
{
this._logDispatcherQueue.Dispose();
}
lock (this._appendersLock)
{
foreach (var appender in this._appenders)
{
try
{
appender.Dispose();
}
catch (Exception ex)
{
LogSysInnerLog.OnRaiseLog(this, ex);
}
}
}
}
