public void Should_be_able_to_apply_filter_using_delegatefilter()
{
var filter = new TextLogMaskingFilter(new TextMaskingRule()
{
Field = "txid", Mask = Masks.DefaultMask
});
var delegateFilter = new DelegateFilter(filter.Apply);
var id = Convert.ToString(Guid.NewGuid());
var apiLog = Utility.GetApiLog();
apiLog.Id = id;
var filteredLog = delegateFilter.Apply(apiLog);
var formatter = JsonLogFormatter.Instance;
var firehoseSink = Utility.GetFirehoseSink();
var redisSink = Utility.GetRedisSink();
var compositeSink = Utility.GetCompositeSink(formatter, redisSink, firehoseSink);
var logWriter = new LogWriter(formatter, compositeSink);
logWriter.WriteAsync(filteredLog).GetAwaiter().GetResult();
//Thread.Sleep(60000);
var logData = Utility.GetEsLogDataById(id);
var esLogId = string.Empty;
var expected = "1*********3";
string actual;
logData.TryGetValue("txid", out actual);
Assert.Equal(expected, actual);
}
public void VerifyWhenCustomMaskSpecified_FieldsAreMaskedCorrectly()
{
var apiLog = new ApiLog();
var filter = new DelegateFilter((ILog log) =>
{
var copy = new List <KeyValuePair <string, object> >();
var fields = log.GetFields();
foreach (var field in fields)
{
if (field.Key == "fieldToMask")
{
copy.Add(new KeyValuePair <string, object>(field.Key, Masks.DefaultMask.Mask(field.Value.ToString())));
}
else if (field.Key == "fieldNotToMask")
{
copy.Add(field);
}
}
return(new SimpleLog(log.Id, log.LogTime, copy));
});
apiLog.TrySetValue("fieldToMask", "ValueToMask");
apiLog.TrySetValue("fieldNotToMask", "ValueNotToMask");
var masked = filter.Apply(apiLog);
var maskedFields = masked.GetFields();
var maskedField = maskedFields.First(x => x.Key == "fieldToMask").Value;
var notMaskedField = maskedFields.First(x => x.Key == "fieldNotToMask").Value;
Assert.Equal(maskedField, "V*********k");
Assert.Equal(notMaskedField, "ValueNotToMask");
}
public void SetUp()
{
_filter = new DelegateFilter(
type =>
{
_executed = true;
return(true);
});
_filter.MatchesAsync(typeof(object));
}
public void SetUp()
{
_filter = new DelegateFilter(
type =>
{
_executed = true;
return(true);
});
_filter.MatchesAsync(new DynamicMethod("test", typeof(void), null));
}
public void AFilterPreventsMatchedEventsFromPassingToTheSink()
{
var excluded = Some.InformationEvent();
var included = Some.InformationEvent();
var filter = new DelegateFilter(e => e.MessageTemplate != excluded.MessageTemplate);
var events = new List<LogEvent>();
var sink = new DelegatingSink(events.Add);
var logger = new LoggerConfiguration()
.WriteTo.Sink(sink)
.Filter.With(filter)
.CreateLogger();
logger.Write(included);
logger.Write(excluded);
Assert.AreEqual(1, events.Count);
Assert.That(events.Contains(included));
}
public override Filter Preprocess()
{
Filter delegateFilter;
if (string.IsNullOrEmpty(this.SqlExpression))
{
throw new FilterException(SRClient.PropertyIsNullOrEmpty("SqlExpression"));
}
if (this.SqlExpression.Length > 1024)
{
throw new FilterException(SRClient.SqlFilterStatmentTooLong(this.SqlExpression.Length, 1024));
}
this.EnsureCompatibilityLevel();
try
{
SqlFilter.CompiledItem compiledItem = (SqlFilter.CompiledItem)SqlFilter.compiledDelegateCache.Get(this.SqlExpression, null);
if (compiledItem == null)
{
SqlFilterParserOutput sqlFilterParserOutput = SqlFilterParser.Parse(this.SqlExpression);
(new SqlFilter.ExpressionValidator()).Validate(sqlFilterParserOutput.ExpressionTree);
Func <BrokeredMessage, IDictionary <string, object>, bool?> func = sqlFilterParserOutput.ExpressionTree.Compile();
compiledItem = new SqlFilter.CompiledItem(func, sqlFilterParserOutput.RequiredParameters);
SqlFilter.CompiledItem compiledItem1 = (SqlFilter.CompiledItem)SqlFilter.compiledDelegateCache.AddOrGetExisting(this.SqlExpression, compiledItem, SqlFilter.defaultCachePolicy, null);
if (compiledItem1 != null)
{
compiledItem = compiledItem1;
}
}
ParametersValidator.Validate(true, compiledItem.RequiredParameters, this.Parameters);
delegateFilter = new DelegateFilter(compiledItem.Delegate, this.Parameters);
}
catch (FilterException filterException)
{
throw;
}
catch (Exception exception1)
{
Exception exception = exception1;
if (!Fx.IsFatal(exception))
{
throw new FilterException(exception.Message, exception);
}
throw;
}
return(delegateFilter);
}
public void AFilterPreventsMatchedEventsFromPassingToTheSink()
{
var excluded = Some.InformationEvent();
var included = Some.InformationEvent();
var filter = new DelegateFilter(e => e.MessageTemplate != excluded.MessageTemplate);
var events = new List <LogEvent>();
var sink = new DelegatingSink(events.Add);
var logger = new LoggerConfiguration()
.WriteTo.Sink(sink)
.Filter.With(filter)
.CreateLogger();
logger.Write(included);
logger.Write(excluded);
Assert.Single(events);
Assert.Contains(included, events);
}
public static IAsyncResult BeginFilter(AddressCollection addresses, AsyncCallback callback)
{
_delegateFilter = Filter;
return(_delegateFilter.BeginInvoke(addresses, callback, _delegateFilter));
}
public static IAsyncResult BeginFilter(AddressCollection addresses, AsyncCallback callback)
{
SmtpValidator._delegateFilter = SmtpValidator.Filter;
return SmtpValidator._delegateFilter.BeginInvoke(addresses, callback, SmtpValidator._delegateFilter);
}
public static IAsyncResult BeginFilter(AddressCollection addresses, AsyncCallback callback)
{
SmtpValidator._delegateFilter = SmtpValidator.Filter;
return(SmtpValidator._delegateFilter.BeginInvoke(addresses, callback, SmtpValidator._delegateFilter));
}
