/// <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;
}
}
