封裝一個基於NLog+NLog.Mongo的日誌記錄工具類LogUtil

来源:https://www.cnblogs.com/zuowj/archive/2018/03/24/8641403.html
-Advertisement-
Play Games

封裝一個基於NLog+NLog.Mongo的日誌記錄工具類LogUtil，代碼比較簡單，主要是把MongoTarget的配置、FileTarget的配置集成到類中，同時利用緩存依賴來判斷是否需要重新創建Logger類，完整代碼如下： 封裝這個日誌工具類的目的就是為了保證日誌格式的統一，同時可以快速的 ...


封裝一個基於NLog+NLog.Mongo的日誌記錄工具類LogUtil，代碼比較簡單，主要是把MongoTarget的配置、FileTarget的配置集成到類中，同時利用緩存依賴來判斷是否需要重新創建Logger類，完整代碼如下：

using NLog;
using NLog.Config;
using NLog.Mongo;
using NLog.Targets;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Collections.Concurrent;
using NLog.Targets.Wrappers;

/// <summary>
/// 日誌工具類(基於NLog.Mongo組件)
/// Author：左文俊
/// Date：2017/12/11
/// </summary>
public class LogUtil
{
    private NLog.Logger _Logger = null;
    private const string cacheKey_NLogConfigFlag = "NLogConfigFlag";
    private const string defaultMongoDbName = "SysLog";
    private static readonly object syncLocker = new object();
    private static readonly ConcurrentDictionary<string, LogUtil> cacheLogUitls = new ConcurrentDictionary<string, LogUtil>();
    private string loggerCacheDependencyFilePath = "";
    private bool needWriteLogToFile = true;
    private string mongoDbName = defaultMongoDbName;
    private string mongoDbCollectionName = "";
    private bool asyncWriteLog = true;

    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()
        {
            LoggerCacheDependencyFilePath = string.IsNullOrEmpty(loggerCacheDependencyFilePath) ? HttpContext.Current.Server.MapPath("~/Web.config") : loggerCacheDependencyFilePath,
            NeedWriteLogToFile = needWriteLogToFile,
            MongoDbName = defaultMongoDbName,
            MongoDbCollectionName = mongoDbCollName
        });
    }
    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);
        }
    }

    /// <summary>
    /// 同一個項目只會用一個DB，故不對外公開，取預設DB
    /// </summary>
    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>(T oldValue, T newValue) where T : IEquatable<T>
    {
        if (!oldValue.Equals(newValue) && _Logger != null)
        {
            lock (syncLocker)
            {
                _Logger = null;
            }
        }
    }

    private Logger GetLogger()
    {

        if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null)
        {
            lock (syncLocker)
            {
                if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null)
                {
                    string mongoDbConnectionSet = ConfigUtil.GetAppSettingValue("MongoDbConnectionSet");
                    if (!string.IsNullOrEmpty(mongoDbConnectionSet))
                    {
                        mongoDbConnectionSet = AESDecrypt(mongoDbConnectionSet);//解密字元串,若未加密則無需解密
                    }

                    LoggingConfiguration config = new LoggingConfiguration();

                    #region 配置MONGODB的日誌輸出對象

                    try
                    {
                        MongoTarget mongoTarget = new MongoTarget();
                        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("*", LogLevel.Debug, mongoTargetNew);
                        config.LoggingRules.Add(rule1);
                    }
                    catch
                    { }

                    #endregion

                    #region 配置File的日誌輸出對象

                    if (NeedWriteLogToFile)
                    {
                        try
                        {
                            FileTarget fileTarget = new 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);
                            config.LoggingRules.Add(rule2);
                        }
                        catch
                        { }
                    }

                    #endregion


                    LogManager.Configuration = config;

                    _Logger = LogManager.GetCurrentClassLogger();

                    HttpRuntime.Cache.Insert(cacheKey_NLogConfigFlag, "Nlog", new System.Web.Caching.CacheDependency(loggerCacheDependencyFilePath));
                }
            }
        }

        return _Logger;

    }

    private void AppendLogMongoFields(IList<MongoField> 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; }
        }
    }


}

封裝這個日誌工具類的目的就是為了保證日誌格式的統一，同時可以快速的複製到各個項目中使用，而省去需要配置文件或因配置文件修改導致日誌記錄信息不一致的情況。

從代碼中可以看出，若一旦屬性發生改變，則緩存標識會失效，意味著會重新生成Logger對象，這樣保證了Logger時刻與設置的規則相同。

另一點就是非同步日誌記錄功能AsyncWriteLog，如果是基於配置文件，則只需要更改配置文件targets中配置async="true"即為非同步。預設或寫false都為同步，而代碼上如何實現非同步網上並沒有介紹，我通過分析NLOG源代碼找到關鍵點，即通過AsyncTargetWrapper非同步目標包裹器來包裝一次即可。

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 模擬瀏覽器——Headers屬性
    方法一、使用build_opener()修改報頭 方法二、使用add_header()添加報頭 ...
  • Python : Module
    在Python中，一個.py文件代表一個Module。在Module中可以是任何的符合Python文件格式的Python腳本。瞭解Module導入機制大有用處。 1 Module 組成 1.1 Module 內置全局變數 2 Module 導入 2.1 導入及其使用 2.2 一次載入多次導入 2.3 ...
  • 學習Python第一份筆記--數據類型
    Python從技術上來說有以下幾方面的優點： （1）面向對象：它的類模塊支持多態、操作符重載和多重繼承等高級概念，並且以Python特有的簡潔的語法和類型，OOP十分適用。就像C++一樣，Python既支持面向對象編程又支持面向過程編程的模式 （2）免費：Python的使用和分發是完全免費的； （3 ...
  • Python基礎數據類型考試題
    升級作業： 程式: 三級菜單 要求: ...
  • springboot集成swagger2
    介紹： Swagger是全球最大的OpenAPI規範（OAS）API開發工具框架，支持從設計和文檔到測試和部署的整個API生命周期的開發。（摘自Swagger官網）Swagger說白了就是幫助開發者省去了維護介面文檔的時間，用來調試介面非常方便。 一、創建項目 在上一篇博客中介紹了怎麼創建sprin ...
  • flask鉤子
    請求鉤子 從請求到響應的過程中，設置了一些方法來實現某些功能 before_first_request 在處理第一個請求前運行 before_request 在每次請求前運行 after_request 在每次請求後運行 teardown_request 有未處理的異常的時候拋出 @app.befo ...
  • UWP：可滾動的PivotHeader
    通過修改Style，實現使用滑鼠滾輪滾動Pivot的Header ...
  • c# json轉換成dynamic對象，然後在dynamic對象中動態獲取指定字元串列表中的值
    using Newtonsoft.Json;using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks; namespace Consol ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類