/// 
/// ���������������(������NLog.Mongo������)/// Author������������/// Date���2017/12/11/// 
public class LogUtil{    private NLog.Logger _Logger = null;    private const string cacheKey_NLogConfigFlag = "NLogConfigFlag";    private const string defaultMongoDbName = "LogDB";    private static readonly object syncLocker = new object();    private static readonly ConcurrentDictionary
    
      cacheLogUitls = new ConcurrentDictionary
     
      ();    private string loggerCacheDependencyFilePath = "";    private bool needWriteLogToFile = true;    private string mongoDbName = defaultMongoDbName;    private string mongoDbCollectionName = "";    private bool asyncWriteLog = true;    private string loggerName = null;    private bool needReConfigLogger = false;    public static LogUtil GetInstance(string mongoDbCollName, string loggerCacheDependencyFilePath = null, bool needWriteLogToFile = true)    {        string key = string.Format("{0}_{1}", defaultMongoDbName, mongoDbCollName);        return cacheLogUitls.GetOrAdd(key, new LogUtil(mongoDbCollName)        {            LoggerCacheDependencyFilePath = string.IsNullOrEmpty(loggerCacheDependencyFilePath) ? HttpContext.Current.Server.MapPath("~/Web.config") : loggerCacheDependencyFilePath,            NeedWriteLogToFile = needWriteLogToFile,            MongoDbName = defaultMongoDbName,            MongoDbCollectionName = mongoDbCollName        });    }    public LogUtil(string loggerName)    {        this.loggerName = loggerName;        this.needReConfigLogger = true;    }    public string LoggerCacheDependencyFilePath    {        get        {            return loggerCacheDependencyFilePath;        }        set        {            if (!File.Exists(value))            {                throw new FileNotFoundException("������������������������������������������" + value);            }            string oldValue = loggerCacheDependencyFilePath;            loggerCacheDependencyFilePath = value;            PropertyChanged(oldValue, loggerCacheDependencyFilePath);        }    }    public bool NeedWriteLogToFile    {        get        {            return needWriteLogToFile;        }        set        {            bool oldValue = needWriteLogToFile;            needWriteLogToFile = value;            PropertyChanged(oldValue, needWriteLogToFile);        }    }    public string MongoDbCollectionName    {        get        {            return mongoDbCollectionName;        }        set        {            string oldValue = mongoDbCollectionName;            mongoDbCollectionName = value;            PropertyChanged(oldValue, mongoDbCollectionName);        }    }    /// 
      
    /// ������������������������������DB���������������������������������DB    /// 
    private string MongoDbName    {        get        {            return mongoDbName;        }        set        {            string oldValue = mongoDbName;            mongoDbName = value;            PropertyChanged(oldValue, mongoDbName);        }    }    public bool AsyncWriteLog    {        get        {            return asyncWriteLog;        }        set        {            bool oldValue = asyncWriteLog;            asyncWriteLog = value;            PropertyChanged(oldValue, asyncWriteLog);        }    }    private void PropertyChanged
      
       (T oldValue, T newValue) where T : IEquatable
       
            {        if (!oldValue.Equals(newValue) && _Logger != null)        {            lock (syncLocker)            {                _Logger = null;            }        }    }    private Logger GetLogger()    {        if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null || needReConfigLogger)        {            lock (syncLocker)            {                if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null || needReConfigLogger)                {                    LoggingConfiguration config = LogManager.Configuration;                    if (config == null)                    {                        config = new LoggingConfiguration();                    }                    #region ������MONGODB���������������������                    if (!IsExistTarget(config, "mongoTarget" + mongoDbCollectionName)) //������������loggerName���������������MongoTarget                    {                        try                        {                            string mongoDbConnectionSet = ConfigUtil.GetAppSettingValue("MongoDbConnectionSet");                            if (!string.IsNullOrEmpty(mongoDbConnectionSet))                            {                                mongoDbConnectionSet = CrtyAES.AESDecrypt(mongoDbConnectionSet);                            }                            MongoTarget mongoTarget = new MongoTarget();                            mongoTarget.Name = "mongoTarget" + mongoDbCollectionName;                            mongoTarget.ConnectionString = mongoDbConnectionSet;                            mongoTarget.DatabaseName = mongoDbName;                            mongoTarget.CollectionName = mongoDbCollectionName;                            mongoTarget.IncludeDefaults = false;                            AppendLogMongoFields(mongoTarget.Fields);                            Target mongoTargetNew = mongoTarget;                            if (AsyncWriteLog)                            {                                mongoTargetNew = WrapWithAsyncTargetWrapper(mongoTarget);//���������������������������������������������������������                            }                            LoggingRule rule1 = new LoggingRule(loggerName, LogLevel.Debug, mongoTargetNew);//������������������������loggerName���                            config.LoggingRules.Add(rule1);                        }                        catch                        { }                    }                    #endregion                    #region ������File���������������������                    if (NeedWriteLogToFile && !IsExistTarget(config, "fileTarget")) //���������Logger������������FileTarget                    {                        try                        {                            FileTarget fileTarget = new FileTarget();                            fileTarget.Name = "fileTarget";                            fileTarget.Layout = @"[${date}] <${threadid}> - ${level} - ${event-context:item=Source} - ${event-context:item=UserID}: ${message};                                                  StackTrace:${stacktrace};Other1:${event-context:item=Other1};Other2:${event-context:item=Other2};Other3:${event-context:item=Other3}";                            string procName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;                            fileTarget.FileName = "${basedir}/Logs/" + procName + ".log";                            fileTarget.ArchiveFileName = "${basedir}/archives/" + procName + ".{#}.log";                            fileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;                            fileTarget.ArchiveAboveSize = 1024 * 1024 * 10;                            fileTarget.ArchiveDateFormat = "yyyyMMdd";                            fileTarget.ArchiveEvery = FileArchivePeriod.Day;                            fileTarget.MaxArchiveFiles = 30;                            fileTarget.ConcurrentWrites = true;                            fileTarget.KeepFileOpen = false;                            fileTarget.Encoding = System.Text.Encoding.UTF8;                            Target fileTargetNew = fileTarget;                            if (AsyncWriteLog)                            {                                fileTargetNew = WrapWithAsyncTargetWrapper(fileTarget);//���������������������������������������������������������                            }                            LoggingRule rule2 = new LoggingRule("*", LogLevel.Debug, fileTargetNew); //������������������logger                            config.LoggingRules.Add(rule2);                        }                        catch                        { }                    }                    #endregion                    LogManager.Configuration = config;                    _Logger = LogManager.GetLogger(loggerName);                    HttpRuntime.Cache.Insert(cacheKey_NLogConfigFlag, "Nlog", new System.Web.Caching.CacheDependency(loggerCacheDependencyFilePath));                    needReConfigLogger = false;                }            }        }        return _Logger;    }    private bool IsExistTarget(LoggingConfiguration config, string targetName)    {        targetName += (AsyncWriteLog ? "_wrapped" : "");        return (config.FindTargetByName(targetName) != null);    }    private void AppendLogMongoFields(IList
        
          mongoFields)    {        mongoFields.Clear();        Type logPropertiesType = typeof(SysLogInfo.LogProperties);        foreach (var pro in typeof(SysLogInfo).GetProperties(BindingFlags.Public | BindingFlags.Instance))        {            if (pro.PropertyType == logPropertiesType) continue;            string layoutStr = string.Empty; //"${event-context:item=" + pro.Name + "}";            if (pro.Name.Equals("ThreadID") || pro.Name.Equals("Level") || pro.Name.Equals("MachineName"))            {                layoutStr = "${" + pro.Name.ToLower() + "}";            }            else if (pro.Name.Equals("LogDT"))            {                layoutStr = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}";            }            else if (pro.Name.Equals("Msg"))            {                layoutStr = "${message}";            }            if (!string.IsNullOrEmpty(layoutStr))            {                mongoFields.Add(new MongoField(pro.Name, layoutStr, pro.PropertyType.Name));            }        }    }    private Target WrapWithAsyncTargetWrapper(Target target)    {        var asyncTargetWrapper = new AsyncTargetWrapper();        asyncTargetWrapper.WrappedTarget = target;        asyncTargetWrapper.Name = target.Name;        target.Name = target.Name + "_wrapped";        target = asyncTargetWrapper;        return target;    }    private LogEventInfo BuildLogEventInfo(LogLevel level, string msg, string source, string uid, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)    {        var eventInfo = new LogEventInfo();        eventInfo.Level = level;        eventInfo.Message = msg;        eventInfo.Properties["DetailTrace"] = detailTrace;        eventInfo.Properties["Source"] = source;        eventInfo.Properties["Other1"] = other1;        eventInfo.Properties["Other2"] = other2;        eventInfo.Properties["Other3"] = other3;        eventInfo.Properties["UserID"] = uid;        return eventInfo;    }    public void Info(string msg, string source, string uid, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)    {        try        {            var eventInfo = BuildLogEventInfo(LogLevel.Info, msg, source, uid, detailTrace, other1, other2, other3);            var logger = GetLogger();            logger.Log(eventInfo);        }        catch        { }    }    public void Warn(string msg, string source, string uid, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)    {        try        {            var eventInfo = BuildLogEventInfo(LogLevel.Warn, msg, source, uid, detailTrace, other1, other2, other3);            var logger = GetLogger();            logger.Log(eventInfo);        }        catch        { }    }    public void Error(string msg, string source, string uid, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)    {        try        {            var eventInfo = BuildLogEventInfo(LogLevel.Error, msg, source, uid, detailTrace, other1, other2, other3);            var logger = GetLogger();            logger.Log(eventInfo);        }        catch        { }    }    public void Error(Exception ex, string source, string uid, string other1 = null, string other2 = null, string other3 = null)    {        try        {            var eventInfo = BuildLogEventInfo(LogLevel.Error, ex.Message, source, uid, ex.StackTrace, other1, other2, other3);            var logger = GetLogger();            logger.Log(eventInfo);        }        catch        { }    }    public void Log(LogLevel level, string msg, string source, string uid, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)    {        try        {            var eventInfo = BuildLogEventInfo(level, msg, source, uid, detailTrace, other1, other2, other3);            var logger = GetLogger();            logger.Log(eventInfo);        }        catch        { }    }    public class SysLogInfo    {        public DateTime LogDT { get; set; }        public int ThreadID { get; set; }        public string Level { get; set; }        public string Msg { get; set; }        public string MachineName { get; set; }        public LogProperties Properties { get; set; }        public class LogProperties        {            public string Source { get; set; }            public string DetailTrace { get; set; }            public string UserID { get; set; }            public string Other1 { get; set; }            public string Other2 { get; set; }            public string Other3 { get; set; }        }    }}
        
       
      
     
    

/// 
    /// ���������������NLog���������������������������������������������������������������������������������������������    /// author:zuowenjun    /// date:2020-12-30    /// 
    public class LogUtils    {        private static Logger _Logger = null;        private static bool _AsyncWriteLog = true;        static LogUtil()        {            InitLogger();        }        private static void InitLogger()        {            LoggingConfiguration config = LogManager.Configuration;            if (config == null)            {                config = new LoggingConfiguration();            }            if (!IsExistTarget(config, "fileTarget")) //���������Logger������������FileTarget            {                try                {                    FileTarget fileTarget = new FileTarget();                    fileTarget.Name = "fileTarget";                    fileTarget.Layout = @"[${date}] <${threadid}> - ${level} - ${event-context:item=Source} - ${event-context:item=UserID}: ${message};Other:${event-context:item=Other};${newline}   ${exception:format=TOSTRING}${newline} ";                    string procName = System.Diagnostics.Process.GetCurrentProcess().ProcessName;                    fileTarget.FileName = "${basedir}/Logs/" + procName +"-${shortdate}" + ".log";                    fileTarget.ArchiveFileName = "${basedir}/archives/" + procName + ".{#}.log";                    fileTarget.ArchiveNumbering = ArchiveNumberingMode.DateAndSequence;                    fileTarget.ArchiveAboveSize = 1024 * 1024 * 10;                    fileTarget.ArchiveDateFormat = "yyyyMMdd";                    fileTarget.ArchiveEvery = FileArchivePeriod.Day;                    fileTarget.MaxArchiveFiles = 30;                    fileTarget.ConcurrentWrites = true;                    fileTarget.KeepFileOpen = false;                    fileTarget.Encoding = System.Text.Encoding.UTF8;                                        Target fileTargetNew = fileTarget;                    if (_AsyncWriteLog)                    {                        fileTargetNew = WrapWithAsyncTargetWrapper(fileTarget);//���������������������������������������������������������                    }                    LoggingRule rule2 = new LoggingRule("*", LogLevel.Info, fileTargetNew); //������������������logger                    config.LoggingRules.Add(rule2);                }                catch                { }            }                        LogManager.Configuration = config;            _Logger = LogManager.GetLogger("LocalFileLogger");        }        private static bool IsExistTarget(LoggingConfiguration config, string targetName)        {            targetName += (_AsyncWriteLog ? "_wrapped" : "");            return (config.FindTargetByName(targetName) != null);        }        private static Target WrapWithAsyncTargetWrapper(Target target)        {            var asyncTargetWrapper = new AsyncTargetWrapper();            asyncTargetWrapper.WrappedTarget = target;            asyncTargetWrapper.Name = target.Name;            target.Name = target.Name + "_wrapped";            target = asyncTargetWrapper;            return target;        }        private static LogEventInfo BuildLogEventInfo(LogLevel level, string msg, string source, string uid, string other = null, Exception ex=null)        {            var eventInfo = new LogEventInfo();            eventInfo.Level = level;            eventInfo.Message = msg;            eventInfo.Exception = ex;            eventInfo.Properties["Source"] = source;            eventInfo.Properties["Other"] = other;            eventInfo.Properties["UserID"] = uid;            return eventInfo;        }        public static void Info(string msg, string source, string uid, string other = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Info, msg, source, uid, other);                _Logger.Log(eventInfo);            }            catch            { }        }        public static void Warn(string msg, string source, string uid, string other = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Warn, msg, source, uid, other);                _Logger.Log(eventInfo);            }            catch            { }        }        public static void Error(string msg, string source, string uid, string other = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Error, msg, source, uid, other);                _Logger.Log(eventInfo);            }            catch            { }        }        public static void Error(Exception ex, string source, string uid, string other = null)        {            try            {                var eventInfo = BuildLogEventInfo(LogLevel.Error, ex.Message, source, uid, other,ex);                _Logger.Log(eventInfo);            }            catch            { }        }    }