幸福框架：我是如何使用日志的

日志的用途

• 跟踪，监控应用程序的执行（框架开发人员需要关注这点）。
• 审计，监控用户的行为（应用开发人员需要关注这点）。

日志的使用原则

• 使用或不适用日志，不应当对系统行为产生影响。
• 可以通过配置修改日志的记录方式和记录哪些日志。

适合AOP的日志场景

• 记录“某些”异常。
• 性能监控。
• 操作日志。

不适合AOP的场景

• 执行跟踪。
• SQL监控。

下边介绍一下“幸福框架”中的日志API和使用原则

日志接口拷贝了Log4Net

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Logging
{
    public interface ILoger
    {
        void Debug(object message);

        void Info(object message);

        void Warn(object message);

        void Error(object message);

        void Fatal(object message);


        void Debug(object message, Exception ex);

        void Info(object message, Exception ex);

        void Warn(object message, Exception ex);

        void Error(object message, Exception ex);

        void Fatal(object message, Exception ex);


        bool IsDebugEnabled { get; }

        bool IsInfoEnabled { get; }

        bool IsWarnEnabled { get; }

        bool IsErrorEnabled { get; }

        bool IsFatalEnabled { get; }
    }
}

日志实现采用了EnterpriseLibrary

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Microsoft.Practices.EnterpriseLibrary.Logging;

using Happy.DesignByContract;
using Happy.Logging;

namespace Happy.EnterpriseLibrary.Logging
{
    public sealed class Loger : ILoger
    {
        private const int CONST_Priority = 10;
        private readonly LogWriter _writer;
        private readonly string _name;

        public Loger(LogWriter writer, string name)
        {
            Check.RequireNotNull(writer, "writer");
            Check.RequireNotNull(name, "name");

            _writer = writer;
            _name = name;
        }

        public void Debug(object message)
        {
            this.Write(message, TraceEventType.Verbose);
        }

        public void Info(object message)
        {
            this.Write(message, TraceEventType.Information);
        }

        public void Warn(object message)
        {
            this.Write(message, TraceEventType.Warning);
        }

        public void Error(object message)
        {
            this.Write(message, TraceEventType.Error);
        }

        public void Fatal(object message)
        {
            this.Write(message, TraceEventType.Critical);
        }


        public void Debug(object message, Exception ex)
        {
            this.Write(message, ex, TraceEventType.Verbose);
        }

        public void Info(object message, Exception ex)
        {
            this.Write(message, ex, TraceEventType.Information);
        }

        public void Warn(object message, Exception ex)
        {
            this.Write(message, ex, TraceEventType.Warning);
        }

        public void Error(object message, Exception ex)
        {
            this.Write(message, ex, TraceEventType.Error);
        }

        public void Fatal(object message, Exception ex)
        {
            this.Write(message, ex, TraceEventType.Critical);
        }


        public bool IsDebugEnabled
        {
            get
            {
                return _writer.TraceSources[_name].Level >= SourceLevels.Verbose;
            }
        }

        public bool IsInfoEnabled
        {
            get
            {
                return _writer.TraceSources[_name].Level >= SourceLevels.Information;
            }
        }

        public bool IsWarnEnabled
        {
            get
            {
                return _writer.TraceSources[_name].Level >= SourceLevels.Warning;
            }
        }

        public bool IsErrorEnabled
        {
            get
            {
                return _writer.TraceSources[_name].Level >= SourceLevels.Error;
            }
        }

        public bool IsFatalEnabled
        {
            get
            {
                return _writer.TraceSources[_name].Level == SourceLevels.Critical;
            }
        }


        private void Write(object message, TraceEventType traceEventType)
        {
            _writer.Write(message, _name, CONST_Priority, 0, traceEventType);
        }

        private void Write(object message, Exception ex, TraceEventType traceEventType)
        {
            var properties = GetProperties(ex);

            _writer.Write(message, _name, CONST_Priority, 0, traceEventType, ex.Message, properties);
        }

        private static Dictionary<string, object> GetProperties(Exception ex)
        {
            return
                    new Dictionary<string, object>
                    {
                        { "异常", ex }
                    };
        }
    }
}

日志的使用场景（Debug）

        private void RegistBundleToUnity(Bundle bundle)
        {
            foreach (var convention in _conventions)
            {
                convention.AutoRegist(bundle.Assembly);
            }

            foreach (var register in bundle.Assembly.GetConcreteDescendentInstances<IUnityRegister>())
            {
                register.Regist(UnityBundleContainerExtensions.ChildContainer);
            }

            this.LogChildContainer();
        }

        private void LogChildContainer()
        {
            var registrationsInfo =
                                    UnityBundleContainerExtensions
                                    .ChildContainer
                                    .Registrations
                                    .JoinToString(x => string.Format("{0}->{1}（{2}）", x.RegisteredType.FullName, x.MappedToType.FullName, x.LifetimeManagerType.Name), ",\r\n\t");

            LogHelper.Debug(string.Format("“{0}”中的注册的类型信息：\r\n\t{1}。", UnityBundleContainerExtensions.ChildContainer.GetType().Name, registrationsInfo));
        }

日志的使用场景（Info）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Diagnostics;

using Happy.Logging;
using Happy.DesignByContract;

namespace Happy.Messaging
{
    public sealed class LoggingFilter : IMessageFilter
    {
        public void Intercept(IMessagePipeLine pipeLine)
        {
            Check.RequireNotNull(pipeLine, "pipeLine");

            try
            {
                var watch = Stopwatch.StartNew();
                pipeLine.Next();
                watch.Stop();

                LogHelper.Info(string.Format("执行消息“{0}”耗费了“{1}”。", pipeLine.Message.GetType().FullName, watch.Elapsed));
            }
            catch (Exception ex)
            {
                LogHelper.Info(string.Format("执行消息“{0}”时出现异常。", pipeLine.Message.GetType().FullName), ex);

                throw;
            }
        }
    }
}

日志的使用场景（Warn）

        private IEnumerable<IMessageHandler> GetMessageHandlers(MessageScene scene, IMessage message)
        {
            var handlerType = GetMessageHandler(message);

            var hanlders = _serviceLocator.GetAllInstances(handlerType);

            if (hanlders == null)
            {
                LogHelper.Warn(string.Format("没有找到消息“{0}”对应的Handler", message.GetType().FullName));

                return Enumerable.Empty<IMessageHandler>();
            }

            return
                    hanlders
                    .Cast<IMessageHandler>()
                    .Where(hanlder => hanlder.Scene == scene);
        }

日志的使用场景（Fatal）

        private void LoadAssemblies()
        {
            try
            {
                new DirectoryInfo(_bundleDirectoryPath).LoadAssemblies(_includeSubdirectories);
            }
            catch (TypeLoadException ex)
            {
                LogHelper.Fatal(string.Format("类型“{0}”加载失败。", ex.TypeName), ex);

                throw;
            }
            catch (ReflectionTypeLoadException ex)
            {
                var extraMessages = ex.LoaderExceptions.Select(x => x.Message).JoinToString();
                LogHelper.Fatal(string.Format("类型“{0}”加载失败，更多信息：{1}。", ex.Types.JoinToString(), extraMessages), ex);

                throw;
            }
        }

日志的使用场景（Error）

            _dbContext.OnError(x =>
                LogHelper.Error(
                    string.Format("数据库查询（语句：{0}，类型：{1}，参数：{2}）执行出错。", x.Command.CommandText, x.Command.CommandType, this.GetCommandParameters(x.Command)),
                    x.Exception
                )
            );

日志的使用场景（监控SQL）

            Stopwatch watch = null;

            _dbContext.OnExecuting(x =>
            {
                watch = Stopwatch.StartNew();

                LogHelper.Debug(
                    string.Format("数据库查询（语句：{0}，类型：{1}，参数：{2}）正在查询。", x.Command.CommandText, x.Command.CommandType, this.GetCommandParameters(x.Command))
                );
            });

            _dbContext.OnExecuted(x =>
            {
                watch.Stop();

                LogHelper.Debug(
                    string.Format("数据库查询（语句：{0}，类型：{1}，执行时间：{2}，参数：{3}）执行完毕。", x.Command.CommandText, x.Command.CommandType, watch.Elapsed,
                                    this.GetCommandParameters(x.Command))
                );
            });

备注

没有用日志的朋友，请赶快使用日志。