/// <summary> /// /// </summary> /// <typeparam name="TState"></typeparam> /// <param name="logLevel"></param> /// <param name="eventId"></param> /// <param name="state"></param> /// <param name="exception"></param> /// <param name="formatter"></param> public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { LoggerInformation[] loggers = this.Loggers; bool flag = loggers == null; if (!flag) { List <Exception> exceptions = null; bool loged = false; foreach (LoggerInformation loggerInfo in loggers) { bool flag2 = !loggerInfo.IsEnabled(logLevel); if (!flag2) { try { loggerInfo.Logger.Log <TState>(logLevel, eventId, state, exception, formatter); bool flag3 = !loged; if (flag3) { loged = true; AspNetCore.FileLog.LoggerFilterRule rule = loggerInfo.Rule; bool flag4 = exception == null && rule.LogType.HasFlag(LogType.Trace); StackFrame[] stackFrames; if (flag4) { stackFrames = new StackTrace(false).GetFrames(rule.TraceCount, new Func <StackFrame, MethodBase, bool>(this.CanSkip)); } else { stackFrames = Array.Empty <StackFrame>(); } HttpContext context = null; bool flag5 = rule.LogType.HasFlag(LogType.HttpContext); if (flag5) { IHttpContextAccessor httpContextAccessor = this._httpContextAccessor; context = ((httpContextAccessor != null) ? httpContextAccessor.HttpContext : null); } this._logAdapter.Log(rule.CategoryName, eventId.Name, logLevel, LoggerSettings.Format, formatter(state, exception), stackFrames, exception, context); } } catch (Exception ex) { bool flag6 = exceptions == null; if (flag6) { exceptions = new List <Exception>(); } exceptions.Add(ex); } } } bool flag7 = exceptions != null && exceptions.Count > 0; if (flag7) { throw new AggregateException("An error occurred while writing to logger(s).", exceptions); } } }
public void Select(LoggerFilterOptions options, Type providerType, string category, out LogType logType, out LogLevel?minLevel, out Func <string, string, LogLevel, bool> filter) { filter = null; minLevel = options.MinLevel; logType = options.MiniType; // Filter rule selection: // 1. Select rules for current logger type, if there is none, select ones without logger type specified // 2. Select rules with longest matching categories // 3. If there nothing matched by category take all rules without category // 3. If there is only one rule use it's level and filter // 4. If there are multiple rules use last // 5. If there are no applicable rules use global minimal level var providerAlias = LoggerProviderAliasUtilities.GetAlias(providerType); LoggerFilterRule current = null; foreach (LoggerFilterRule rule in options.Rules) { if (IsBetter(rule, current, providerType.FullName, category) || (!string.IsNullOrEmpty(providerAlias) && IsBetter(rule, current, providerAlias, category))) { current = rule; } } if (current != null) { filter = current.Filter; minLevel = current.LogLevel; logType = current.LogType; } }
public void Select(LoggerFilterOptions options, Type providerType, string category, out LogType logType, out LogLevel?minLevel, out int traceCount, out Func <string, string, LogLevel, bool> filter) { filter = null; minLevel = new Microsoft.Extensions.Logging.LogLevel?(options.MinLevel); logType = options.MiniType; traceCount = options.TraceCount; string providerAlias = LoggerProviderAliasUtilities.GetAlias(providerType); LoggerFilterRule current = null; foreach (LoggerFilterRule loggerFilterRule in options.Rules) { LoggerFilterRule rule = (LoggerFilterRule)loggerFilterRule; bool flag = LoggerRuleSelector.IsBetter(rule, current, providerType.FullName, category) || (!string.IsNullOrEmpty(providerAlias) && LoggerRuleSelector.IsBetter(rule, current, providerAlias, category)); if (flag) { current = rule; } } bool flag2 = current != null; if (flag2) { filter = current.Filter; minLevel = current.LogLevel; logType = current.LogType; traceCount = current.TraceCount; } }
private static bool IsBetter(LoggerFilterRule rule, LoggerFilterRule current, string logger, string category) { bool flag = rule.ProviderName != null && rule.ProviderName != logger; bool result; if (flag) { result = false; } else { bool flag2 = rule.CategoryName != null && !category.StartsWith(rule.CategoryName, StringComparison.OrdinalIgnoreCase); if (flag2) { result = false; } else { bool flag3 = ((current != null) ? current.ProviderName : null) != null; if (flag3) { bool flag4 = rule.ProviderName == null; if (flag4) { return(false); } } else { bool flag5 = rule.ProviderName != null; if (flag5) { return(true); } } bool flag6 = ((current != null) ? current.CategoryName : null) != null; if (flag6) { bool flag7 = rule.CategoryName == null; if (flag7) { return(false); } bool flag8 = current.CategoryName.Length > rule.CategoryName.Length; if (flag8) { return(false); } } result = true; } } return(result); }
public LoggerFilterOptions(LoggerFilterOptions options) { base.MinLevel = LogLevel.Information; this.MiniType = LogType.None; foreach (LoggerFilterRule loggerFilterRule in options.Rules) { LoggerFilterRule rule = (LoggerFilterRule)loggerFilterRule; bool flag = rule.CategoryName.Equals("Default"); if (flag) { this.MiniType = rule.LogType; base.MinLevel = (rule.LogLevel ?? LogLevel.Information); this.TraceCount = rule.TraceCount; } base.Rules.Add(rule); } }
public void Configure(Microsoft.Extensions.Logging.LoggerFilterOptions options) { if (LoggerSettings.JsonConfiguration == null) { return; } var source = LoggerSettings.JsonConfiguration?.Source; var file = source?.FileProvider.GetFileInfo(source.Path); if (file != null && !file.IsDirectory && file.Exists) { using (var reader = new System.IO.StreamReader(file.CreateReadStream())) { var content = reader.ReadToEnd(); var jToken = JsonConvert.DeserializeObject <JToken>(content); if (jToken != null) { try { var rules = jToken.SelectToken(LoggerSettings.RulesKey, false) .ToObject <List <LoggerFilterRule> >(); foreach (var _rule in rules) { options.Rules.Add(_rule); } return; } catch { } } } System.IO.File.WriteAllText(file.PhysicalPath, LoggerSettings.LoggingJsonContent); var rule = new LoggerFilterRule(string.Empty, "Default", LogLevel.Information, null); rule.LogType = LogType.All; options.Rules.Add(rule); } else { var rule = new LoggerFilterRule(LoggerSettings.DefaultProviderName, LoggerSettings.DefaultName, LogLevel.Information, null); rule.LogType = LogType.All; options.Rules.Add(rule); } }
private static bool IsBetter(LoggerFilterRule rule, LoggerFilterRule current, string logger, string category) { // Skip rules with inapplicable type or category if (rule.ProviderName != null && rule.ProviderName != logger) { return(false); } if (rule.CategoryName != null && !category.StartsWith(rule.CategoryName, StringComparison.OrdinalIgnoreCase)) { return(false); } if (current?.ProviderName != null) { if (rule.ProviderName == null) { return(false); } } else { // We want to skip category check when going from no provider to having provider if (rule.ProviderName != null) { return(true); } } if (current?.CategoryName != null) { if (rule.CategoryName == null) { return(false); } if (current.CategoryName.Length > rule.CategoryName.Length) { return(false); } } return(true); }
public async Task Invoke(HttpContext context) { LoggerFilterOptions _filterOption = LoggerFactory._filterOptions; bool flag = context.Request.Path.StartsWithSegments(this.SavePath); if (flag) { string logFilePath = null; bool flag2 = LoggerSettings.JsonConfiguration != null; if (flag2) { IFileInfo fi = LoggerSettings.JsonConfiguration.Source.FileProvider.GetFileInfo(LoggerSettings.JsonConfiguration.Source.Path); bool flag3 = !fi.IsDirectory; if (flag3) { logFilePath = fi.PhysicalPath; } FileInfo fileInfo = new FileInfo(logFilePath); bool flag4 = !fileInfo.Directory.Exists; if (flag4) { fileInfo.Directory.Create(); } fi = null; fileInfo = null; } bool flag5 = string.IsNullOrEmpty(logFilePath); if (flag5) { logFilePath = Path.Combine(LoggerSettings.LogDirectory, "_logging.json"); } string json = string.Empty; using (StreamReader _sr = new StreamReader(context.Request.Body)) { json = _sr.ReadToEnd(); } File.WriteAllText(logFilePath, json); context.Response.ContentType = "application/json"; await context.Response.WriteAsync("{message:'ok',status:200}", default(CancellationToken)); logFilePath = null; json = null; } else { StringBuilder sb = new StringBuilder(); string[] levels = Enum.GetNames(typeof(LogLevel)); string[] types = Enum.GetNames(typeof(LogType)); sb.AppendLine("<header><h1><a href=\"" + LoggerSettings.LogRequestPath + "\">Logs</a></h1><br>Set Default : <select id='defaltLevel' onchange='_setDefault(this,\"_level\")'><option>--Log Level--</option>"); sb.Append(string.Join("", from t in levels select "<option>" + t + "</option>")); sb.Append("</select> Default Type: <select id='defaltType' onchange='_setDefault(this,\"_type\")'><option>--Log Type--</option>"); sb.Append(string.Join("", from t in types select "<option>" + t + "</option>")); sb.Append("</select>"); sb.Append(" TraceCount: <input type=text id='traceCount' value='' onchange='_setDefault(this,\"_count\")'/>"); sb.Append(" <button type='button' onclick='_save()'>Save</button></header>"); SortedDictionary <string, LoggerFilterRule> rules = new SortedDictionary <string, LoggerFilterRule>(); SortedDictionary <string, LogLevel> levelValues = new SortedDictionary <string, LogLevel>(); SortedDictionary <string, LogType> typeValues = new SortedDictionary <string, LogType>(); foreach (LoggerFilterRule loggerFilterRule in _filterOption.Rules) { LoggerFilterRule rule = (LoggerFilterRule)loggerFilterRule; rules[rule.CategoryName ?? "Default"] = rule; rule = null; } foreach (KeyValuePair <string, Logger> log in from t in LoggerFactory._loggers orderby t.Key select t) { if (log.Value.Loggers.Length != 0) { rules[log.Key] = log.Value.Loggers[0].Rule; } } sb.AppendLine(); var objs = from k in rules select k.Value into t select new { Name = t.CategoryName, LogType = t.LogType.ToString(), LogLevel = t.LogLevel.ToString(), TraceCount = t.TraceCount }; sb.AppendLine("<script>var rules=" + objs.ToJson() + ";</script>"); await context.Response.WriteAsync(LoggerSettings.html.Replace("{{url}}", this.SavePath).Replace("{{body}}", sb.ToString()), default(CancellationToken)); sb = null; levels = null; types = null; rules = null; objs = null; } }