Asp.NET MVC,自定义TextWriterTraceListener不会创建文件

时间:2016-03-05 23:56:19

标签: c# .net asp.net-mvc configuration tracesource

对于MVC应用程序,当使用initializeData =“CustomWeblog.txt”参数时,自定义侦听器不会创建日志文件,但initializeData =“d:\ CustomWeblog.txt”会触发文件创建。这种行为的原因是什么?控制台应用程序为所有类型的侦听器生成文件。

自定义类:

public class CustomTextWriterTraceListener : TextWriterTraceListener 
{ 
     public CustomTextWriterTraceListener(string fileName) : base(fileName)
}

Web.config(mvc application,web.config)

<trace autoflush="true" />
<sources>
  <source name="Trace">    
      <listeners>
        <add name="TextWriterListner"
             type="System.Diagnostics.TextWriterTraceListener, WebTracing" initializeData="Weblog.txt"/>
        <!-- the file is created -->
        <add name="CustomTextWriterListner"
             type="WebTracing.CustomTextWriterTraceListener, WebTracing" initializeData="CustomWeblog.txt"/>
        <!-- the file is not created in MVC application ?! -->
        <add name="CustomTextWriterListnerAbsolutePath"
             type="WebTracing.CustomTextWriterTraceListener, WebTracing" initializeData="d:\CustomWeblog.txt"/>
        <!-- the file is created -->
      </listeners>      
  </source>
</sources>

Cutom侦听器不会创建日志文件。

来电者:

TraceSource obj = new TraceSource("Trace", SourceLevels.All);
obj.TraceEvent(TraceEventType.Critical,0,"This is a critical message");

我尝试添加一些额外配置:来自this blogthis one。但没有成功。我应该提供绝对路径吗?是否有为自定义侦听器创建单独程序集的解决方法?

2 个答案:

答案 0 :(得分:2)

好的,最后,我已经将调查转换为生成侦听器路径的方式。我在调试时注意到的是源侦听器列表包含不同的路径。

  • System.Diagnostics.TextWriterTraceListener侦听器对象生成完整路径;
  • WebTracing.CustomTextWriterTraceListener只有文件名。没有生成的错误。

自定义侦听吞噬UnauthorisedAccessException异常的原因导致的不同值,以便应用程序继续工作而不通知我们权限问题。

  

但是存储自定义侦听器日志文件的位置是什么?是吗   生成与否?

TextWriterTraceListener source code的以下链接帮助我找出了路径。以下代码:

//initializeData="CustomWeblog.txt", so fileName == "CustomWeblog.txt" here
string fullPath = Path.GetFullPath(fileName); 
string dirPath = Path.GetDirectoryName(fullPath); 
string fileNameOnly = Path.GetFileName(fullPath);

实际存储路径取决于项目&gt;属性&gt;网络&gt;服务器:IIS Express:

  

c:\ Program Files(x86)\ IIS Express \ CustomWeblog.txt

我一直在讨论MVC应用程序(作为管理员:vs以管理员身份运行)在该文件夹中正确生成日志文件。当我在没有管理员权限的情况下运行VS时,自定义侦听器根本不会创建文件。

如上所述,我执行了源代码监听器,发现在catch(UnauthorisedAccessException) { break; }构造函数调用时触发了new StreamWriter(...)

作为另一种解决方法,您可以在initializeData="d:\CustomWeblog.txt"属性中声明整个路径。但请记住,您必须拥有适当的权限。

答案 1 :(得分:2)

当我遇到您描述的相同问题时,我正在尝试创建自己的滚动文本编写器跟踪侦听器。长话短说,毕竟在这里跑来跑去是我想出来的。

public class RollingTextWriterTraceListener : TextWriterTraceListener {
    string fileName;
    private static string[] _supportedAttributes = new string[] 
        { 
            "template", "Template", 
            "convertWriteToEvent", "ConvertWriteToEvent",
            "addtoarchive","addToArchive","AddToArchive",
        };

    public RollingTextWriterTraceListener(string fileName)
        : base() {
        this.fileName = fileName;
    }
    /// <summary>
    /// This makes sure that the writer exists to be written to.
    /// </summary>
    private void ensureWriter() {
        //Resolve file name given. relative paths (if present) are resolved to full paths.
        // Also allows for paths like this: initializeData="~/Logs/{ApplicationName}_{DateTime:yyyy-MM-dd}.log"
        var logFileFullPath = ServerPathUtility.ResolvePhysicalPath(fileName);
        var writer = base.Writer;
        if (writer == null && createWriter(logFileFullPath)) {
            writer = base.Writer;
        }
        if (!File.Exists(logFileFullPath)) {
            if (writer != null) {
                try {
                    writer.Flush();
                    writer.Close();
                    writer.Dispose();
                } catch (ObjectDisposedException) { }
            }
            createWriter(logFileFullPath);
        }
        //Custom code to package the previous log file(s) into a zip file.
        if (AddToArchive) {
            TextFileArchiveHelper.Archive(logFileFullPath);
        }
    }

    bool createWriter(string logFileFullPath) {
        try {
            logFileFullPath = ServerPathUtility.ResolveOrCreatePath(logFileFullPath);
            var writer = new StreamWriter(logFileFullPath, true);
            base.Writer = writer;
            return true;
        } catch (IOException) {
            //locked as already in use
            return false;
        } catch (UnauthorizedAccessException) {
            //ERROR_ACCESS_DENIED, mostly ACL issues
            return false;
        }
    }

    /// <summary>
    /// Get the add to archive flag
    /// </summary>
    public bool AddToArchive {
        get {
            // Default behaviour is not to add to archive.
            var addToArchive = false;
            var key = Attributes.Keys.Cast<string>().
                FirstOrDefault(s => string.Equals(s, "addtoarchive", StringComparison.InvariantCultureIgnoreCase));
            if (!string.IsNullOrWhiteSpace(key)) {
                bool.TryParse(Attributes[key], out addToArchive);
            }
            return addToArchive;
        }
    }

    #region Overrides
    /// <summary>
    /// Allowed attributes for this trace listener.
    /// </summary>
    protected override string[] GetSupportedAttributes() {
        return _supportedAttributes;
    }

    public override void Flush() {
        ensureWriter();
        base.Flush();
    }

    public override void Write(string message) {
        ensureWriter();
        base.Write(message);
    }

    public override void WriteLine(string message) {
        ensureWriter();
        base.WriteLine(message);
    }
    #endregion
}

UPDATE:这是我为解析路径而编写的实用程序类。

public static class ServerPathUtility {

    public static string ResolveOrCreatePath(string pathToReplace) {
        string rootedFileName = ResolvePhysicalPath(pathToReplace);
        FileInfo fi = new FileInfo(rootedFileName);
        try {
            DirectoryInfo di = new DirectoryInfo(fi.DirectoryName);
            if (!di.Exists) {
                di.Create();
            }
            if (!fi.Exists) {
                fi.CreateText().Close();
            }
        } catch {
            // NO-OP
            // TODO: Review what should be done here.
        }
        return fi.FullName;
    }

    public static string ResolvePhysicalPath(string pathToReplace) {
        string rootedPath = ResolveFormat(pathToReplace);
        if (rootedPath.StartsWith("~") || rootedPath.StartsWith("/")) {
            rootedPath = System.Web.Hosting.HostingEnvironment.MapPath(rootedPath);
        } else if (!Path.IsPathRooted(rootedPath)) {
            rootedPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, rootedPath);
        }
        return rootedPath;
    }

    public static string ResolveFormat(string format) {
        string result = format;

        try {
            result = ExpandApplicationVariables(format);
        } catch (System.Security.SecurityException) {
            // Log?
        }

        try {
            string variables = Environment.ExpandEnvironmentVariables(result);
            // If an Environment Variable is not found then remove any invalid tokens
            Regex filter = new Regex("%(.*?)%", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);

            string filePath = filter.Replace(variables, "");

            if (Path.GetDirectoryName(filePath) == null) {
                filePath = Path.GetFileName(filePath);
            }
            result = filePath;
        } catch (System.Security.SecurityException) {
            // Log?
        }

        return result;
    }

    public static string ExpandApplicationVariables(string input) {
        var filter = new Regex("{(.*?)}", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
        var result = filter.Replace(input, evaluateMatch());
        return result;
    }

    private static MatchEvaluator evaluateMatch() {
        return match => {
            var variableName = match.Value;
            var value = GetApplicationVariable(variableName);
            return value;
        };
    }

    public static string GetApplicationVariable(string variable) {
        string value = string.Empty;
        variable = variable.Replace("{", "").Replace("}", "");
        var parts = variable.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
        variable = parts[0];
        var parameter = string.Empty;
        if (parts.Length > 1) {
            parameter = string.Join("", parts.Skip(1));
        }

        Func<string, string> resolve = null;
        value = VariableResolutionStrategies.TryGetValue(variable.ToUpperInvariant(), out resolve) && resolve != null
            ? resolve(parameter)
            : string.Empty;

        return value;
    }

    public static readonly IDictionary<string, Func<string, string>> VariableResolutionStrategies =
        new Dictionary<string, Func<string, string>> {
            {"MACHINENAME", p => Environment.MachineName },
            {"APPDOMAIN", p => AppDomain.CurrentDomain.FriendlyName },
            {"DATETIME", getDate},
            {"DATE", getDate},
            {"UTCDATETIME", getUtcDate},
            {"UTCDATE", getUtcDate},
        };

    static string getDate(string format = "yyyy-MM-dd") {
        var value = string.Empty;
        if (string.IsNullOrWhiteSpace(format))
            format = "yyyy-MM-dd";
        value = DateTime.Now.ToString(format);
        return value;
    }

    static string getUtcDate(string format = "yyyy-MM-dd") {
        var value = string.Empty;
        if (string.IsNullOrWhiteSpace(format))
            format = "yyyy-MM-dd";
        value = DateTime.Now.ToString(format);
        return value;
    }
}

因此,此实用程序类允许我解析相对路径并自定义格式。例如,如果您查看代码,您会看到此路径中不存在应用程序名称ApplicationName变量

"~/Logs/{ApplicationName}_{DateTime:yyyy-MM-dd}.log"

我可以在应用程序的启动时配置它以及我想添加的任何其他变量,如此

public partial class Startup {
    public void Configuration(IAppBuilder app) {
        //... Code removed for brevity           
        // Add APPLICATIONNAME name to path Utility
        ServerPathUtility.VariableResolutionStrategies["APPLICATIONNAME"] = p => {
            var assembly = System.Reflection.Assembly.GetExecutingAssembly();
            if (assembly != null)
                return assembly.GetName().Name;
            return string.Empty;
        };           
    }
}