/// <summary>
/// Filter log events to include only those that has specified property
/// </summary>
/// <param name="configuration">configuration</param>
/// <param name="propertyName">Name of property</param>
/// <param name="propertyValue">Expected property value</param>
/// <returns>LoggerConfiguration</returns>
public static LoggerConfiguration FilterOnlyLogRequests(this LoggerFilterConfiguration configuration)
{
return(configuration.ByIncludingOnly(logEvent =>
{
var propertyName = nameof(LogRequestAttribute);
var contains = logEvent.Properties.ContainsKey(propertyName); //Matching.WithProperty(propertyName)(logEvent);
logEvent.RemovePropertyIfPresent(propertyName);
return contains;
}));
}
/// <summary>
/// Filter log events to include only cache logs
/// </summary>
/// <param name="configuration">configuration</param>
/// <returns>LoggerConfiguration</returns>
public static LoggerConfiguration FilterOnlyCacheLogs(this LoggerFilterConfiguration configuration)
{
return(configuration.ByIncludingOnly(logEvent =>
{
var propertyName = LogConstants.LogCache;
var contains = logEvent.Properties.ContainsKey(propertyName);
logEvent.RemovePropertyIfPresent(propertyName);
return contains;
}));
}
public static LoggerConfiguration ByExcludingHealthCheck(
this LoggerFilterConfiguration filterConfiguration)
{
if (filterConfiguration == null)
{
throw new ArgumentNullException(nameof(filterConfiguration));
}
return(filterConfiguration.With <HealthCheckFilter>());
}
/// <summary>
/// Filter log events to include only those that has specified property
/// </summary>
/// <param name="configuration">configuration</param>
/// <param name="propertyName">Name of property</param>
/// <param name="propertyValue">Expected property value</param>
/// <returns>LoggerConfiguration</returns>
public static LoggerConfiguration FilterByProperty(this LoggerFilterConfiguration configuration, string propertyName, string propertyValue)
{
return(configuration.ByIncludingOnly(Matching.WithProperty(propertyName, propertyValue))); //new ScalarValue(propertyValue)
//var scalarValue = new ScalarValue(propertyValue);
//return configuration.ByIncludingOnly(logEvent =>
//{
// if (logEvent.Properties.TryGetValue(propertyName, out var prop) && prop is ScalarValue value)
// return scalarValue.Equals(value);
// return false;
//});
}
/// <summary>
/// Use a <see cref="LoggingFilterSwitch"/> to dynamically control filtering.
/// </summary>
/// <param name="loggerFilterConfiguration">Filter configuration.</param>
/// <param name="switch">A <see cref="LoggingFilterSwitch"/> that can be used to dynamically control
/// log filtering.</param>
/// <returns>The underlying <see cref="LoggerConfiguration"/>.</returns>
public static LoggerConfiguration ControlledBy(this LoggerFilterConfiguration loggerFilterConfiguration, LoggingFilterSwitch @switch)
{
if (loggerFilterConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerFilterConfiguration));
}
if (@switch == null)
{
throw new ArgumentNullException(nameof(@switch));
}
return(loggerFilterConfiguration.With(@switch));
}
/// <summary>
/// Filter log events to include only those that has EventId with specified id
/// </summary>
/// <param name="configuration">configuration</param>
/// <param name="id">The id of EventId</param>
/// <returns>LoggerConfiguration</returns>
public static LoggerConfiguration FilterByEventId(this LoggerFilterConfiguration configuration, int id)
{
var scalarValue = new ScalarValue(id);
return(configuration.ByIncludingOnly(logEvent =>
{
if (logEvent.Properties.TryGetValue(nameof(EventId), out var propertyValue) && propertyValue is StructureValue structureValue)
{
var idValue = structureValue.Properties.Where(cc => cc.Name == nameof(EventId.Id)).FirstOrDefault();
return scalarValue.Equals(idValue.Value);
}
return false;
}));
}
/// <summary>
/// Exclude log events that match the provided expression.
/// </summary>
/// <param name="loggerFilterConfiguration">Filter configuration.</param>
/// <param name="expression">The expression to apply.</param>
/// <returns>The underlying <see cref="LoggerConfiguration"/>.</returns>
public static LoggerConfiguration ByExcluding(this LoggerFilterConfiguration loggerFilterConfiguration, string expression)
{
if (loggerFilterConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerFilterConfiguration));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var compiled = SerilogExpression.Compile(expression);
return(loggerFilterConfiguration.ByExcluding(e => Coerce.IsTrue(compiled(e))));
}
/// <summary>
/// Exclude log events that match the provided expression.
/// </summary>
/// <param name="loggerFilterConfiguration">Filter configuration.</param>
/// <param name="expression">The expression to apply.</param>
/// <returns>The underlying <see cref="LoggerConfiguration"/>.</returns>
public static LoggerConfiguration ByExcluding(this LoggerFilterConfiguration loggerFilterConfiguration, string expression)
{
if (loggerFilterConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerFilterConfiguration));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var compiled = FilterLanguage.CreateFilter(expression);
return(loggerFilterConfiguration.ByExcluding(e => true.Equals(compiled(e))));
}
public static LoggerConfiguration UniqueOverSpan(this LoggerFilterConfiguration loggerFilterConfiguration, string expression, TimeSpan span)
{
if (loggerFilterConfiguration == null)
{
throw new ArgumentNullException(nameof(loggerFilterConfiguration));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
var compiled = FilterLanguage.CreateFilter(expression);
return
(loggerFilterConfiguration
.UniqueOverSpan
(
e => true.Equals(compiled(e)),
span
));
}
// don't support (yet?) arrays in the parameter list (ILogEventEnricher[]) internal static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration, ILogEventFilter filter) => loggerFilterConfiguration.With(filter);
internal static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration,
ILogEventFilter filter)
{
return(loggerFilterConfiguration.With(filter));
}
/// <summary>
/// Filter log events to include only those that has specified property
/// </summary>
/// <param name="configuration">configuration</param>
/// <param name="propertyName">Name of property</param>
/// <param name="propertyValue">Expected property value</param>
/// <returns>LoggerConfiguration</returns>
public static LoggerConfiguration FilterByHasProperty(this LoggerFilterConfiguration configuration, string propertyName)
{
return(configuration.ByIncludingOnly(Matching.WithProperty(propertyName)));
//return configuration.ByIncludingOnly(logEvent => logEvent.Properties.ContainsKey(propertyName));
}
public static LoggerConfiguration UniqueOverSpan(this LoggerFilterConfiguration configuration, Func <LogEvent, bool> inclusionPredicate, TimeSpan span)
{
return
(configuration
.With(new UniqueOverSpanFilter(inclusionPredicate, span)));
}
public static LoggerConfiguration ByExcludingLevel(this LoggerFilterConfiguration loggerFilterConfiguration,
LogEventLevel excludedLevel)
{
return(loggerFilterConfiguration.With(new DummyEventLevelFilter(excludedLevel)));
}
