日志系统设计

一、前言

日志记录对于一个系统而言,重要性不言而喻。日志记录功能在系统开发阶段,往往容易被忽略。因为开发阶段,程序可以调试,可以反复的运行以查找问题。但在系统进入正常的运行维护阶段,特别是在进行审计统计的时候,追踪问题的时候,在追溯责任的时候,在系统出错的时候等等场景中,日志记录才会显示出它不可替代的作用。记录的日志,平时看似累赘,只有在需要的时候,才会拍大腿后悔当初为什么不把日志记录得详细些。

日志系统,是一个非常基础的系统,但由于需求的复杂性,各个场景需要的日志分类,来源,输出方式各有不同,日志系统又是一个相对复杂的系统。下面我们就来解说一下,OSharp开发框架的日志系统设计中,怎样来应对这些复杂性。

二、系统架构设计图

OSharp 开发框架的日志部分定义了一套基础的通用的日志记录协议,来创建并管理日志记录对象,并处理日志的输入逻辑,没有日志的输出实现,日志的输出完全由第三方日志组件来完成。基本架构图如下图所示:

项目代码组成:

日志记录的过程按如下步骤进行:

  1. 日志管理器 LogManager 中定义了两个仓库:日志记录者仓库 ConcurrentDictionary<string, ILogger> 与 日志输出者适配器仓库 ICollection<ILoggerAdapter>

  2. 具体的日志输出方式实现相应的日志输出适配器 ILoggerAdapter,并添加到 LogManager 的日志输出适配器仓库中

  3. 日志记录点使用名称通过 LogManager 创建(提取)日志记录者 Logger,并存回到 LogManager 的仓库中等下次备用

  4. 日志输出者调用 LogManager 中的所有 ILoggerAdapter 适配器(例如 Log4NetLoggerAdapter)输出日志

  5. 日志适配器 ILoggerAdapter 调用具体的日志输出者 LogBase(例如 Log4NetLog)进行日志的输出

OSharp 的日志系统在设计上有如下特点:

  1. 整个OSharp 日志系统只负责收集日志信息,并不关心日志的输出行为

  2. 具体的日志输出行为由各个输出方案实现 日志输出适配器 来完成

  3. 一条日志信息,可以有一个或多个日志输出途径

三、核心设计

下面我们来一步一步解析上图的设计思路。

(一)日志记录行为约定

在OSharp的设计中,为了满足各种应用场景对日志输出级别的控制,定义了 8 个日志输出的级别:

  1. All:输出所有级别的日志

  2. Trace:输出跟踪级别的日志

  3. Debug:输出调试级别的日志

  4. Info:输出消息级别的日志

  5. Warn:输出警告级别的日志

  6. Error:输出错误级别的日志

  7. Fatal:输出严重错误级别的日志

  8. Off:关闭所有日志级别,不输出日志

/// <summary>
/// 表示日志输出级别的枚举
/// </summary>
public enum LogLevel
{
    /// <summary>
    /// 输出所有级别的日志
    /// </summary>
    All = 0,

    /// <summary>
    /// 表示跟踪的日志级别
    /// </summary>
    Trace = 1,

    /// <summary>
    /// 表示调试的日志级别
    /// </summary>
    Debug = 2,

    /// <summary>
    /// 表示消息的日志级别
    /// </summary>
    Info = 3,

    /// <summary>
    /// 表示警告的日志级别
    /// </summary>
    Warn = 4,

    /// <summary>
    /// 表示错误的日志级别
    /// </summary>
    Error = 5,

    /// <summary>
    /// 表示严重错误的日志级别
    /// </summary>
    Fatal = 6,

    /// <summary>
    /// 关闭所有日志,不输出日志
    /// </summary>
    Off = 7
}

对于各个日志级别,日志系统都有相应的日志记录行为规范。各个级别都支持 泛型、格式化字符串 的输出,对于错误与严重错误的级别,支持 Exception 异常信息的支持。

日志记录行为定义为 ILogger 接口:

/// <summary>
/// 定义日志记录行为
/// </summary>
public interface ILogger
{
    #region 方法

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Trace<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Trace(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Debug<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Debug(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Info<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Info(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Warn<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Warn(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Error<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Error(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    void Error<T>(T message, Exception exception);

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    void Error(string format, Exception exception, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    void Fatal<T>(T message);

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    void Fatal(string format, params object[] args);

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    void Fatal<T>(T message, Exception exception);

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    void Fatal(string format, Exception exception, params object[] args);

    #endregion
}

(二)日志输出适配设计

1.日志输出适配器

不同的需求有不同的日志输出需求,通常我们会遇到如下的场景:

  1. 操作类日志,常常与业务相关,需要输出到数据库中,便于查看与追溯

  2. 实时监控系统中,日志需要实时输出到控制台,便于即时的反馈给观察者

  3. 对于错误异常类的信息,基查看人员通常是开发人员与运维人员,与业务相关度不大,用文本文件按天记录即可

  4. ...

面对众多的需求场景,日志信息的输出形式就需灵活多变,必须能灵活替换或添加一个或多个输出行为。为应对这些需求,并充分把现有的输出行为利用上,OSharp 的日志系统的日志输出行为是灵活的,主要通过定义一系列的日志输出适配器来完成。

日志输出适配器 ILoggerAdapter 定义如下,主要是定义获取 日志输出者适配对象 ILog 的创建行为:

/// <summary>
/// 由指定类型获取<see cref="ILog"/>日志实例
/// </summary>
/// <param name="type">指定类型</param>
/// <returns></returns>
ILog GetLogger(Type type);

/// <summary>
/// 由指定名称获取<see cref="ILog"/>日志实例
/// </summary>
/// <param name="name">指定名称</param>
/// <returns></returns>
ILog GetLogger(string name);

每一个日志输出适配器,都对应着一系列具体的日志输出实现技术的日志输出适配对象(如Log4Net中的 log4net.Core.ILogger 类的对象),适配器需要自行管理这些对象的创建与销毁行为,并把创建的日志输出适配对象按名称缓存起来。OSharp中通过定义一个通用适配器基类 LoggerAdapterBase 来规范这些行为。

/// <summary>
/// 按名称缓存的日志输出适配器基类,用于创建并管理指定类型的日志输出者实例
/// </summary>
public abstract class LoggerAdapterBase : ILoggerAdapter
{
    private readonly ConcurrentDictionary<string, ILog> _cacheLoggers;

    /// <summary>
    /// 初始化一个<see cref="LoggerAdapterBase"/>类型的新实例
    /// </summary>
    protected LoggerAdapterBase()
    {
        _cacheLoggers = new ConcurrentDictionary<string, ILog>();
    }

    #region Implementation of ILoggerFactoryAdapter

    /// <summary>
    /// 由指定类型获取<see cref="ILog"/>日志实例
    /// </summary>
    /// <param name="type">指定类型</param>
    /// <returns></returns>
    public ILog GetLogger(Type type)
    {
        type.CheckNotNull("type");
        return GetLoggerInternal(type.FullName);
    }

    /// <summary>
    /// 由指定名称获取<see cref="ILog"/>日志实例
    /// </summary>
    /// <param name="name">指定名称</param>
    /// <returns></returns>
    public ILog GetLogger(string name)
    {
        name.CheckNotNullOrEmpty("name");
        return GetLoggerInternal(name);
    }

    #endregion

    /// <summary>
    /// 创建指定名称的缓存实例
    /// </summary>
    /// <param name="name">指定名称</param>
    /// <returns></returns>
    protected abstract ILog CreateLogger(string name);

    /// <summary>
    /// 清除缓存中的日志实例
    /// </summary>
    protected virtual void ClearLoggerCache()
    {
        _cacheLoggers.Clear();
    }

    private ILog GetLoggerInternal(string name)
    {
        ILog log;
        if (_cacheLoggers.TryGetValue(name, out log))
        {
            return log;
        }
        log = CreateLogger(name);
        if (log == null)
        {
            throw new NotSupportedException(Resources.Logging_CreateLogInstanceReturnNull.FormatWith(name, GetType().FullName));
        }
        _cacheLoggers[name] = log;
        return log;
    }
}

适配器基类中,定义了一个 ConcurrentDictionary< string , ILog> 仓库通过名称来管理适配之后的 ILog 对象,并向派生类开放了一个 protected abstract ILog CreateLogger( string name); 来获取 ILog 对象的具体适配实现。

2.日志输出者适配对象

日志输出者适配对象 ILog 接口派生自 ILogger ,添加了日志输出的许可属性,用于定义具体的日志输出者对象:

/// <summary>
/// 表示日志实例的接口
/// </summary>
public interface ILog : ILogger
{
    #region 属性

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Trace"/>级别的日志
    /// </summary>
    bool IsTraceEnabled { get; }

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Debug"/>级别的日志
    /// </summary>
    bool IsDebugEnabled { get; }

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Info"/>级别的日志
    /// </summary>
    bool IsInfoEnabled { get; }

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Warn"/>级别的日志
    /// </summary>
    bool IsWarnEnabled { get; }

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Error"/>级别的日志
    /// </summary>
    bool IsErrorEnabled { get; }

    /// <summary>
    /// 获取 是否允许<see cref="LogLevel.Fatal"/>级别的日志
    /// </summary>
    bool IsFatalEnabled { get; }

    #endregion

}

日志输出者适配类,主要是使用现有的日志输出实现类(如 log4net.Core.ILogger )去实现具体的日志输出行为,在下面这个 日志输出者适配基类 LogBase 中,主要是通过重写 Write 方法来实现。

/// <summary>
/// 日志输出者适配基类,用于定义日志输出的处理业务
/// </summary>
public abstract class LogBase : ILog
{
    /// <summary>
    /// 获取日志输出处理委托实例
    /// </summary>
    /// <param name="level">日志输出级别</param>
    /// <param name="message">日志消息</param>
    /// <param name="exception">日志异常</param>
    protected abstract void Write(LogLevel level, object message, Exception exception);

    #region Implementation of ILog

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Trace"/>级别的日志
    /// </summary>
    public abstract bool IsTraceEnabled { get; }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Debug"/>级别的日志
    /// </summary>
    public abstract bool IsDebugEnabled { get; }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Info"/>级别的日志
    /// </summary>
    public abstract bool IsInfoEnabled { get; }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Warn"/>级别的日志
    /// </summary>
    public abstract bool IsWarnEnabled { get; }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Error"/>级别的日志
    /// </summary>
    public abstract bool IsErrorEnabled { get; }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Fatal"/>级别的日志
    /// </summary>
    public abstract bool IsFatalEnabled { get; }

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Trace<T>(T message)
    {
        if (IsTraceEnabled)
        {
            Write(LogLevel.Trace, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public virtual void Trace(string format, params object[] args)
    {
        if (IsTraceEnabled)
        {
            Write(LogLevel.Trace, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Debug<T>(T message)
    {
        if (IsDebugEnabled)
        {
            Write(LogLevel.Debug, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public virtual void Debug(string format, params object[] args)
    {
        if (IsDebugEnabled)
        {
            Write(LogLevel.Debug, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Info<T>(T message)
    {
        if (IsInfoEnabled)
        {
            Write(LogLevel.Info, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public virtual void Info(string format, params object[] args)
    {
        if (IsInfoEnabled)
        {
            Write(LogLevel.Info, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Warn<T>(T message)
    {
        if (IsWarnEnabled)
        {
            Write(LogLevel.Warn, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public virtual void Warn(string format, params object[] args)
    {
        if (IsWarnEnabled)
        {
            Write(LogLevel.Warn, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Error<T>(T message)
    {
        if (IsErrorEnabled)
        {
            Write(LogLevel.Error, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Error(string format, params object[] args)
    {
        if (IsErrorEnabled)
        {
            Write(LogLevel.Error, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    public virtual void Error<T>(T message, Exception exception)
    {
        if (IsErrorEnabled)
        {
            Write(LogLevel.Error, message, exception);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    public virtual void Error(string format, Exception exception, params object[] args)
    {
        if (IsErrorEnabled)
        {
            Write(LogLevel.Error, string.Format(format, args), exception);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public virtual void Fatal<T>(T message)
    {
        if (IsFatalEnabled)
        {
            Write(LogLevel.Fatal, message, null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Fatal(string format, params object[] args)
    {
        if (IsFatalEnabled)
        {
            Write(LogLevel.Fatal, string.Format(format, args), null);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    public virtual void Fatal<T>(T message, Exception exception)
    {
        if (IsFatalEnabled)
        {
            Write(LogLevel.Fatal, message, exception);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    public virtual void Fatal(string format, Exception exception, params object[] args)
    {
        if (IsFatalEnabled)
        {
            Write(LogLevel.Fatal, string.Format(format, args), exception);
        }
    }

    #endregion
}

需要将日志输出应用到具体的技术实现时,只要以相应的技术实现 CachingLoggerAdapterBase 与 LogBase 两个基类即可。

(三)日志记录处理

有了上面定义的 ILoggerAdapter 与 ILog 以及 LogManager 对日志输出适配器的管理,实现日志记录已经是呼之欲出了。日志记录的执行,主要通过下面这个内部类来完成。

/// <summary>
/// 日志记录者,日志记录输入端
/// </summary>
internal sealed class Logger : ILogger
{
    internal Logger(Type type)
        : this(type.FullName)
    { }

    internal Logger(string name)
    {
        Name = name;
        EntryLevel = ConfigurationManager.AppSettings.Get("OSharp-EntryLogLevel").CastTo(LogLevel.Off);
    }

    /// <summary>
    /// 获取 日志记录者名称
    /// </summary>
    public string Name { get; private set; }

    /// <summary>
    /// 获取或设置 日志级别的入口控制,级别决定是否执行相应级别的日志记录功能
    /// </summary>
    public LogLevel EntryLevel { get; set; }

    #region Implementation of ILogger

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Trace<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Trace))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Trace(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Trace"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Trace(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Trace))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Trace(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Debug<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Debug))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Debug(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Debug"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Debug(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Debug))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Debug(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Info<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Info))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Info(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Info"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Info(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Info))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Info(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Warn<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Warn))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Warn(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Warn"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Warn(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Warn))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Warn(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Error<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Error))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Error(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Error(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Error))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Error(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    public void Error<T>(T message, Exception exception)
    {
        if (!IsEnabledFor(LogLevel.Error))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Error(message, exception);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Error"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    public void Error(string format, Exception exception, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Error))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Error(format, exception, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息
    /// </summary>
    /// <param name="message">日志消息</param>
    public void Fatal<T>(T message)
    {
        if (!IsEnabledFor(LogLevel.Fatal))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Fatal(message);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="args">格式化参数</param>
    public void Fatal(string format, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Fatal))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Fatal(format, args);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>日志消息,并记录异常
    /// </summary>
    /// <param name="message">日志消息</param>
    /// <param name="exception">异常</param>
    public void Fatal<T>(T message, Exception exception)
    {
        if (!IsEnabledFor(LogLevel.Fatal))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Fatal(message, exception);
        }
    }

    /// <summary>
    /// 写入<see cref="LogLevel.Fatal"/>格式化日志消息,并记录异常
    /// </summary>
    /// <param name="format">日志消息格式</param>
    /// <param name="exception">异常</param>
    /// <param name="args">格式化参数</param>
    public void Fatal(string format, Exception exception, params object[] args)
    {
        if (!IsEnabledFor(LogLevel.Fatal))
        {
            return;
        }
        foreach (ILog log in LogManager.Adapters.Select(adapter => adapter.GetLogger(Name)))
        {
            log.Fatal(format, exception, args);
        }
    }

    #endregion

    #region 私有方法

    private bool IsEnabledFor(LogLevel level)
    {
        return level >= EntryLevel;
    }

    #endregion
}

这个日志记录类 Logger ,使用引用类(需要进行日志记录的类)的名称来获取具体的实例,并缓存到 LogManager 中。

在执行日志记录的时候, Logger 类将按如下逻辑进行处理:

  1. 先检查日志输入级别许可( EntryLevel 属性,通过键名“OSharp-EntryLogLevel”的AppSettings来定义,默认为 LogLevel.Off ),如果记录级别小于允许级别,则拦截。

  2. 从 LogManager 的日志输出适配器仓库中筛选出所有名称 Name 与当前 Logger 对象名称相同的适配器

  3. 使用筛选出来的适配器获取具体的 日志输出者适配对象(ILog)

  4. 使用获取到的适配对象(ILog)中的具体日志记录实现(重写的Write方法)进行日志内容的输出

四、日志系统的应用(以log4net为例)

下面来以log4net为实例,看看怎样来使用 OSharp 中定义的日志系统。

(一)日志输出者适配类

日志输出者适配类,主要是根据 log4net 的现有配置定义OSharp中的日志输出级别,并使用log4net实现日志输出的 Write 操作。

/// <summary>
/// log4net 日志输出者适配类
/// </summary>
internal class Log4NetLog : LogBase
{
    private static readonly Type DeclaringType = typeof(Log4NetLog);
    private readonly ILogger _logger;

    /// <summary>
    /// 初始化一个<see cref="Log4NetLog"/>类型的新实例
    /// </summary>
    public Log4NetLog(ILoggerWrapper wrapper)
    {
        _logger = wrapper.Logger;
    }

    #region Overrides of LogBase

    /// <summary>
    /// 获取日志输出处理委托实例
    /// </summary>
    /// <param name="level">日志输出级别</param>
    /// <param name="message">日志消息</param>
    /// <param name="exception">日志异常</param>
    protected override void Write(LogLevel level, object message, Exception exception)
    {
        Level log4NetLevel = GetLevel(level);
        _logger.Log(DeclaringType, log4NetLevel, message, exception);
    }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Trace"/>级别的日志
    /// </summary>
    public override bool IsTraceEnabled { get { return _logger.IsEnabledFor(Level.Trace); } }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Debug"/>级别的日志
    /// </summary>
    public override bool IsDebugEnabled { get { return _logger.IsEnabledFor(Level.Debug); } }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Info"/>级别的日志
    /// </summary>
    public override bool IsInfoEnabled { get { return _logger.IsEnabledFor(Level.Info); } }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Warn"/>级别的日志
    /// </summary>
    public override bool IsWarnEnabled { get { return _logger.IsEnabledFor(Level.Warn); } }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Error"/>级别的日志
    /// </summary>
    public override bool IsErrorEnabled { get { return _logger.IsEnabledFor(Level.Error); } }

    /// <summary>
    /// 获取 是否允许输出<see cref="LogLevel.Fatal"/>级别的日志
    /// </summary>
    public override bool IsFatalEnabled { get { return _logger.IsEnabledFor(Level.Fatal); } }

    #endregion

    private static Level GetLevel(LogLevel level)
    {
        switch (level)
        {
            case LogLevel.All:
                return Level.All;
            case LogLevel.Trace:
                return Level.Trace;
            case LogLevel.Debug:
                return Level.Debug;
            case LogLevel.Info:
                return Level.Info;
            case LogLevel.Warn:
                return Level.Warn;
            case LogLevel.Error:
                return Level.Error;
            case LogLevel.Fatal:
                return Level.Fatal;
            case LogLevel.Off:
                return Level.Off;
            default:
                return Level.Off;
        }
    }
}

(二)日志输出适配器

日志输出适配器,主要是实现怎样创建 log4net 日志对象,并把日志对象转换为上面定义的 日志输出者适配对象:

/// <summary>
/// log4net 日志输出适配器
/// </summary>
public class Log4NetLoggerAdapter : LoggerAdapterBase
{
    /// <summary>
    /// 初始化一个<see cref="Log4NetLoggerAdapter"/>类型的新实例
    /// </summary>
    public Log4NetLoggerAdapter()
    {
        RollingFileAppender appender = new RollingFileAppender
        {
            Name = "root",
            File = "logs\\log_",
            AppendToFile = true,
            LockingModel = new FileAppender.MinimalLock(),
            RollingStyle = RollingFileAppender.RollingMode.Date,
            DatePattern = "yyyyMMdd-HH\".log\"",
            StaticLogFileName = false,
            Threshold = Level.Debug,
            MaxSizeRollBackups = 10,
            Layout = new PatternLayout("%n[%d{yyyy-MM-dd HH:mm:ss.fff}] %-5p %c %t %w %n%m%n")
        };
        appender.ClearFilters();
        appender.AddFilter(new LevelMatchFilter { LevelToMatch = Level.Info });
        BasicConfigurator.Configure(appender);
        appender.ActivateOptions();
    }


    #region Overrides of LoggerAdapterBase

    /// <summary>
    /// 创建指定名称的缓存实例
    /// </summary>
    /// <param name="name">指定名称</param>
    /// <returns></returns>
    protected override ILog CreateLogger(string name)
    {
        log4net.ILog log = log4net.LogManager.GetLogger(name);
        return new Log4NetLog(log);
    }

    #endregion
}

(三)日志环境初始化

日志系统的运行环境初始化工作在Global中进行,要做的事很简单,只是把日志输出适配器 Log4NetLoggerAdapter 的实例加入到 LogManager 中的 日志输出适配器仓库中。

private static void LoggingInitialize()
{
    Log4NetLoggerAdapter adapter = new Log4NetLoggerAdapter();
    LogManager.AddLoggerAdapter(adapter);
}

(四)日志输出

进行初始化之后,就可以在业务代码中使用日志记录功能了。以类名从 LogManager 获取 日志记录对象 的 ILogger 实例,再调用相应的日志记录方法来记录日志信息。

在网站首页获取日志记录实例,输出日志信息:

在网站后台管理首页获取日志记录实例,输出日志信息:

运行项目,得到我们预想中的日志输出结果:

五、开源说明

(一)github.com

OSharp项目已在github.com上开源,地址为:https://github.com/i66soft/osharp,欢迎阅读代码,欢迎 Fork,如果您认同 OSharp 项目的思想,欢迎参与 OSharp 项目的开发。

在Visual Studio 2013中,可直接获取 OSharp 的最新源代码,获取方式如下,地址为:https://github.com/i66soft/osharp.git

(二)nuget

OSharp的相关类库已经发布到nuget上,欢迎试用,直接在nuget上搜索 “osharp” 关键字即可找到