asp.net mvc实现 错误异常记录功能

创建LogExceptionAttribute 类，继承HandleErrorAttribute 错误异常过滤器

using System;
using System.Web.Mvc;

namespace SXF.Utils.MVC
{
/// <summary>
/// 错误日志记录
/// </summary>
[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
public class LogExceptionAttribute : HandleErrorAttribute
{
public override void OnException(ExceptionContext filterContext)
{
if (!filterContext.ExceptionHandled)
{
#region 记录错误日志
string controllerName = (string)filterContext.RouteData.Values["controller"];
string actionName = (string)filterContext.RouteData.Values["action"];
string msgTemplate = string.Format("在执行 controller[{0}] 的 action[{1}] 时产生异常", controllerName, actionName);
EventLog.LogItem item = new EventLog.LogItem();
item.Title = msgTemplate;
LogManage.WriteException(filterContext.Exception, item);
#endregion
}
base.OnException(filterContext);
}
}
}


此方法中用到了EventLog类中的方法，代码如下：
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Text;
using System.Web;

namespace SXF.Utils
{
/// <summary>
/// 写日志
/// 不想自动记录Context信息请调用Log(string message, string typeName, false)
/// </summary>
public class EventLog
{
/// <summary>
/// 是否使用上下文信息写日志
/// </summary>
static bool UseContext = true;
static string _thisDomain = "";

#region LogItem
[Serializable]
public class LogItem
{
public DateTime Time
{
get;
set;
}
public string Title
{
get;
set;
}
public string Detail
{
get;
set;
}
public string RequestUrl
{
get;
set;
}
public string UrlReferrer
{
get;
set;
}
public string HostIP
{
get;
set;
}
public string UserAgent
{
get;
set;
}
public override string ToString()
{
string s = Time.ToString("yyyy-MM-dd HH:mm:ss");
if (string.IsNullOrEmpty(Title))
{
Title = Detail;
Detail = "";
}
if (!string.IsNullOrEmpty(Title))
{
s += " " + Title;
}
if (!string.IsNullOrEmpty(RequestUrl))
{
s += "\r\nUrl:" + RequestUrl;
}
if (!string.IsNullOrEmpty(UrlReferrer))
{
s += "\r\nUrlReferrer:" + UrlReferrer;
}
if (!string.IsNullOrEmpty(HostIP))
{
s += "\r\nHostIP:" + HostIP;
}
if (!string.IsNullOrEmpty(UserAgent))
{
s += "\r\n" + UserAgent;
}
if (!string.IsNullOrEmpty(Detail))
{
s += "\r\n" + Detail;
}
s += "\r\n";
return s;
}
}
#endregion

static object lockObj = new object();
/// <summary>
/// 检查目录并建立
/// </summary>
/// <param name="path"></param>
public static void CreateFolder(string path)
{
if (path.IsNullOrEmpty())
{
return;
}
string folder = "";
string[] arry = path.Split('\\');
for (int i = 0; i < arry.Length; i++)
{
folder += arry[i] + "\\";
if (!Directory.Exists(folder))
Directory.CreateDirectory(folder);
}
}
/// <summary>
/// 自定义文件名前辍写入日志
/// </summary>
/// <param name="message"></param>
/// <param name="typeName"></param>
/// <param name="useContext"></param>
/// <returns></returns>
public static bool Log(string message, string typeName, bool useContext)
{
LogItem logItem = new LogItem();
logItem.Detail = message;
return Log(logItem, typeName, useContext);
}
public static bool Log(string message, string typeName)
{
return Log(message, typeName, true);
}
/// <summary>
/// 指定日志类型名生成日志
/// </summary>
/// <param name="logItem"></param>
/// <param name="typeName"></param>
/// <returns></returns>
public static bool Log(LogItem logItem, string typeName)
{
return Log(logItem, typeName, true);
}
/// <summary>
/// 指定日志类型名生成日志
/// </summary>
/// <param name="logItem"></param>
/// <param name="typeName"></param>
/// <param name="useContext">是否使用当前上下文信息</param>
/// <returns></returns>
public static bool Log(LogItem logItem, string typeName, bool useContext)
{
string fileName = DateTime.Now.ToString("yyyy-MM-dd");
if (!string.IsNullOrEmpty(typeName))
{
fileName += "." + typeName;
}
HttpContext context = HttpContext.Current;
logItem.Time = DateTime.Now;

if (context != null)
{
try
{
if (string.IsNullOrEmpty(_thisDomain))
{
_thisDomain = context.Request.Url.Host;
}
if (UseContext)
{
if (useContext)
{
logItem.HostIP = RequestHelper.GetCdnIP();

logItem.RequestUrl = context.Request.Url.ToString();
logItem.UserAgent = context.Request.UserAgent;
logItem.UrlReferrer = context.Request.UrlReferrer + "";
}
}
}
catch
{
}
}
return WriteLog(GetLogFolder(), logItem, fileName);
}
/// <summary>
/// 生成日志,默认文件名
/// </summary>
/// <param name="message"></param>
/// <param name="sendToServer">是否发送到服务器</param>
/// <returns></returns>
public static bool Log(string message, bool sendToServer)
{
//if (sendToServer)
//{
// SendToServer(message, "");
//}
return WriteLog(message);
}
/// <summary>
/// 生成日志,默认文件名
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static bool Log(string message)
{
return WriteLog(message);
}
/// <summary>
/// 生成日志,文件名以Error开头
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static bool Error(string message)
{
return Log(message, "Error");
}
/// <summary>
/// 生成日志,文件名以Info开头
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static bool Info(string message)
{
return Log(message, "Info");
}
/// <summary>
/// 生成日志,文件名以Debug开头
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static bool Debug(string message)
{
return Log(message, "Debug");
}
/// <summary>
/// 在当前网站目录生成日志
/// </summary>
/// <param name="message"></param>
public static bool WriteLog(string message)
{
return Log(message, "");
}

static bool Writing = false;
//static DateTime lastWriteTime = DateTime.Now;
static Dictionary<string, LogItemArry> logCaches = new Dictionary<string, LogItemArry>();
static System.Timers.Timer timer;
private static void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
if (!Writing)
{
WriteLogFromCache();
}

}
/// <summary>
/// 指定路径,文件名,写入日志
/// </summary>
/// <param name="path"></param>
/// <param name="logItem"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public static bool WriteLog(string path, LogItem logItem, string fileName)//建立日志
{
try
{
if (timer == null)
{
timer = new System.Timers.Timer();
timer.Interval = 2000;
timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
timer.Start();
}
if (!System.IO.Directory.Exists(path))
CreateFolder(path);
string filePath = "";

filePath = path + fileName + ".txt";

if (!logCaches.ContainsKey(filePath))
logCaches.Add(filePath, new LogItemArry() { savePath = filePath });

logCaches[filePath].Add(logItem);
return true;
}
catch
{
return false;
}
}
public static string LastError;
public static void WriteLogFromCache()
{
lock (lockObj)
{
Writing = true;
//累加上次记录的日志
if (logCaches.Count > 0)
{
Dictionary<string, LogItemArry> list = new Dictionary<string, LogItemArry>(logCaches);
foreach (KeyValuePair<string, LogItemArry> entry in list)
{
LogItemArry logitemArry = entry.Value;
LastError = null;
try
{
WriteLine(logitemArry.ToString(), entry.Key);
}
catch (Exception ero)
{
LastError = ero.ToString();
}
logCaches.Remove(entry.Key);
}
}
//System.Threading.Thread.Sleep(6000);
Writing = false;
}
}

/// <summary>
/// 写信息到指定文件
/// </summary>
/// <param name="message"></param>
/// <param name="filePath"></param>
private static void WriteLine(string message, string filePath)
{

using (FileStream fs = File.OpenWrite(filePath))
{
//根据上面创建的文件流创建写数据流
StreamWriter w = new StreamWriter(fs, System.Text.Encoding.Default);
//设置写数据流的起始位置为文件流的末尾
w.BaseStream.Seek(0, SeekOrigin.End);
//w.Write(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));
w.Write(message);
w.Flush();
w.Close();
}
Console.WriteLine(message);
}
static string secondFolder = null;
/// <summary>
/// 获取日志二级目录
/// </summary>
/// <returns></returns>
public static string GetSecondFolder()
{
if (secondFolder == null)
{
string address = RequestHelper.GetServerIp();

string[] arry = address.Split('.');
secondFolder = arry[arry.Length - 1];
}
return secondFolder;
}
static string rootPath = null;
/// <summary>
/// 获取日志绝对目录
/// </summary>
/// <returns></returns>
public static string GetLogFolder()
{
if (rootPath == null)
{
rootPath = System.Web.Hosting.HostingEnvironment.MapPath(@"\log\");
if (string.IsNullOrEmpty(rootPath))
{
rootPath = AppDomain.CurrentDomain.BaseDirectory + @"\log\";
}
rootPath += GetSecondFolder() + @"\";
//如果节点有设置,则按节点设置读取
NameValueCollection appSettings = ConfigurationManager.AppSettings;
string settingPath = appSettings["EventLogFolder"];
if (!string.IsNullOrEmpty(settingPath))
{
rootPath = settingPath + @"\";
}
}
return rootPath;
}

/// <summary>
/// 项集合
/// </summary>
public class LogItemArry
{
public string savePath;
List<LogItem> logs = new List<LogItem>();
public void Add(LogItem log)
{
logs.Add(log);
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
foreach (LogItem item in logs)
{
sb.Append(item.ToString());
}
return sb.ToString() + "\r\n";
}
}
}
}


用到了LogManage 类的方法，代码如下：
using System;
using System.Text;
using System.Web;

namespace SXF.Utils.MVC
{
/// <summary>
/// mvc日志管理
/// </summary>
public class LogManage
{
public static Exception GetInnerException(Exception exp)
{
if (exp.InnerException != null)
{
exp = exp.InnerException;
return GetInnerException(exp);
}
return exp;
}

static long exceptionId = 0;
static object lockObj = new object();

/// <summary>
/// 内部记录日志
/// </summary>
/// <param name="ero"></param>
/// <returns></returns>
static string InnerLogException(Exception ero, EventLog.LogItem item)
{
string host = HttpContext.Current.Request.Url.Host.ToUpper();
string errorCode = host.Replace(".", "_");
lock (lockObj)
{
exceptionId += 1;
errorCode += ":" + EventLog.GetSecondFolder() + ":" + exceptionId;
}

ero = GetInnerException(ero);

item.Title = item.Title + ",错误代码:" + errorCode;
if (ero != null)
{
item.Detail = ero.Message + "\r\n" + ero.StackTrace + "\r\n";
}
EventLog.Log(item, "Error");
if (host == "LOCALHOST")
{
return errorCode;
}

return errorCode;
}

/// <summary>
/// 页面输出并写入错误日志
/// </summary>
/// <param name="ero"></param>
public static void WriteException(Exception ero, EventLog.LogItem item)
{
//EventLog.Log("start1", "error");
bool logError = true;
if (ero is HttpException)
{
HttpException he = ero as HttpException;
int code = he.GetHttpCode();
if (code == 404)
{
logError = false;
}
}
if (ero is HttpRequestValidationException)
{
logError = false;
}
//EventLog.Log("start2", "error");
string errorCode = string.Empty;
if (logError)
{
//EventLog.Log("start6", "error");
errorCode = InnerLogException(ero, item);
}

}

}
}


写好后需要在FilterConfig 中注册：
public static class FilterConfig
{
public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
//错误处理
filters.Add(new HandleErrorAttribute());
//日志记录
filters.Add(new SXF.Utils.MVC.LogExceptionAttribute());

}
}

global.asax.cs中已经在application_start中默认有调用代码：
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);

另外 web.config 中设置：
<customErrors mode="Off" />

这样就设置好了，一旦在网站中出现mvc 错误，会在网站根目录的 log 文件夹下，自动创建一个类似这样的txt 日志文件：2017-08-02.Error.txt ，每天都会创建一个。若没创建，要么是没有log 文件夹，要么是log 文件夹网站默认用户没创建文件及文件夹的权限