public void MatchesAllInnerFilters()
{
var expected = new[]
{
new EventExpectation
{
Level = Level.Debug,
Logger = "Root.ChildB.LoggerB2",
Thread = "Thread-2",
Timestamp = 1411231353792L,
Message = "#2. Test event B.",
Throwable = null,
Id = 164
}
};
var subject = Filter.All
(
Filter.Level(Level.MinValue, Level.Info),
Filter.Timestamp(1411231353792L, Int64.MaxValue)
);
using (var sourceStream = new MemoryStream(sampleBytes))
using (var source = Log4JFile.Create(sourceStream))
{
source.Encoding = Encoding.GetEncoding(1251);
var actual = source.GetEvents().Where(subject);
Assert.That(actual, Is.EqualTo(expected));
}
}
void buildTest(Filter <string> bf)
{
var len = 20;
var array = new string[len];
for (int i = 0; i < len; i++)
{
array[i] = Utilitiy.GenerateString(10);
}
Assert.All(bf.Add(array), r => Assert.True(r));
Assert.All(bf.Contains(array), r => Assert.True(r));
Assert.True(bf.All(array));
bf.Clear();
Assert.All(bf.Contains(array), r => Assert.False(r));
Assert.False(bf.All(array));
}
void IFilterVisitor.Visit(FilterAll filter)
{
var childrenFilters = filter.Children
.Select(Apply)
.Where(c => c != null)
.ToList();
lastResult_ = childrenFilters.Any()
? Filter.All(childrenFilters)
: null;
}
/// <summary>
/// Filters the specified queryable.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queryable">The queryable.</param>
/// <param name="filter">The filter.</param>
/// <returns>IQueryable{``0}.</returns>
private static IQueryable <T> Filter <T>(IQueryable <T> queryable, Filter filter)
{
if (filter == null || filter.Logic == null)
{
return(queryable);
}
var filters = filter.All();
var objArray = filters.Select(f => f.Value).ToArray();
objArray = ConvertData(objArray);
var predicate = filter.ToExpression(filters);
queryable = queryable.Where(predicate, objArray);
return(queryable);
}
public Filter CreateFilter()
{
var filters = new List <Filter> (4);
if (MinLevel.Value != Level.Debug)
{
var filter = Filter.Level(MinLevel.Value, Level.MaxValue);
filters.Add(filter);
}
if (!String.IsNullOrWhiteSpace(Logger))
{
var filter = Filter.Logger(Logger);
filters.Add(filter);
}
if (!String.IsNullOrWhiteSpace(Message))
{
var filter = Filter.Message(Message);
filters.Add(filter);
}
if (MinTime > DateTime.MinValue || MaxTime < DateTime.MaxValue)
{
var filter = Filter.Timestamp(MinTime, MaxTime);
filters.Add(filter);
}
Filter result;
switch (filters.Count)
{
case 0:
result = null;
break;
case 1:
result = filters.Single();
break;
default:
result = Filter.All(filters);
break;
}
return(result);
}
public void IsNotEqualToDifferentFilter()
{
var subjectA = Filter.All
(
Filter.Level(Level.MinValue, Level.Info),
Filter.Timestamp(1411231353792L, 1411231353792L)
);
var subjectB = Filter.All
(
Filter.Level(Level.MinValue, Level.Error),
Filter.Timestamp(1411231353792L, 1411231353792L)
);
var actualEquals = Equals(subjectA, subjectB);
Assert.That(actualEquals, Is.False);
}
private static void ParseXml(string filename)
{
using (new TimeTrace("total"))
{
using (new TimeTrace("process with E/S init"))
{
using (var eventSource = Log4JFile.Create(filename))
using (new TimeTrace("process inner"))
{
var filterAll = Filter.All
(
Filter.Timestamp(1411231371536L, 1411231371556L),
Filter.Not(Filter.Level("INFO", "ERROR")),
Filter.Any
(
Filter.Message("#2"),
Filter.Message("#3")
),
Filter.Logger("Root.ChildB")
);
var matchingEvents = eventSource
.GetEvents()
.Where(filterAll)
.Take(20)
.ToList();
foreach (var @event in matchingEvents)
{
PrintEvent(@event);
}
Console.WriteLine("Found events: {0}", matchingEvents.Count);
}
}
using (new TimeTrace("count all events"))
using (var eventSource = Log4JFile.Create(filename))
{
var count = eventSource.GetEvents().Count();
Console.WriteLine("Found events: {0}", count);
}
}
}
private static IQueryable <T> Filter <T>(IQueryable <T> queryable, Filter filter)
{
if (filter != null)
{
// Collect a flat list of all filters
var filters = filter.All();
// Get all filter values as array (needed by the Where method of Dynamic Linq)
var values = filters.Select(f => f.Value).ToArray();
// Create a predicate expression e.g. Field1 = @0 And Field2 > @1
string predicate = filter.ToExpression(filters);
// Use the Where method of Dynamic Linq to filter the data
queryable = queryable.Where(predicate, values);
}
return(queryable);
}
public void IsEqualToSameFilter()
{
var subjectA = Filter.All
(
Filter.Level(Level.MinValue, Level.Info),
Filter.Timestamp(1411231353792L, 1411231353792L)
);
var subjectB = Filter.All
(
Filter.Level(Level.MinValue, Level.Info),
Filter.Timestamp(1411231353792L, 1411231353792L)
);
var actualEquals = Equals(subjectA, subjectB);
var actualHashCodeEquals = subjectA.GetHashCode() == subjectB.GetHashCode();
Assert.That(actualEquals, Is.True);
Assert.That(actualHashCodeEquals, Is.True);
}
private static string Filter(string queryable, Filter filter, IList <DataExtension> dataExtensions, bool hasWhereClause)
{
if (filter != null && filter.Logic != null)
{
// Collect a flat list of all filters
var filters = filter.All();
if (dataExtensions != null)
{
filters.ToList().ForEach(c =>
{
var dataExtension = dataExtensions.SingleOrDefault(p => p.Field == c.Field);
if (dataExtension == null)
{
return;
}
if (!string.IsNullOrEmpty(dataExtension.ActualField))
{
c.Field = dataExtension.ActualField;
}
if (dataExtension.FieldType != null)
{
c.Value = dataExtension.FieldType.IsEnum ? Enum.Parse(dataExtension.FieldType, c.Value.ToString()) : Convert.ChangeType(c.Value, dataExtension.FieldType);
}
});
}
var values = filters.Select(f => f.Value).ToArray();
var predicate = filter.ToSql(filters);
if (!hasWhereClause)
{
queryable += " where ";
}
else
{
queryable += " and ";
}
queryable += string.Format(predicate, values);
}
return(queryable);
}
public void GatheredStatsRespectUnstatableFilters()
{
using (var file = new StringLogFile("sample", Sample))
{
var filter = Filter.All
(
Filter.Logger("Root.ChildA.LoggerA2"),
Filter.Timestamp(1500000003000L, 1500000003000L),
Filter.Message("Test event B.")
);
var subject = new LogFileStatsCache();
var actual = subject.GetStats(file, filter);
Assert.That(actual.EventCount, Is.EqualTo(2));
Assert.That(actual.GroupStats.Count, Is.EqualTo(1));
Assert.That(actual.GroupStats[new LogFileStats.EventGroupKey("DEBUG", "Root.ChildB.LoggerB2")], Is.EqualTo(2));
Assert.That(actual.EarliestTimestamp, Is.EqualTo(1500000002000L));
Assert.That(actual.LatestTimestamp, Is.EqualTo(1500000006000L));
}
}
public static IQueryable <T> Filter <T>(this IQueryable <T> queryable, Filter filter)
{
if (filter?.Logic == null)
{
return(queryable);
}
var filters = filter.All();
// Get all filter values as array (needed by the Where method of Dynamic Linq)
var values = filters.Select(f => f.Value).ToArray();
// Create a predicate expression e.g. Field1 = @0 And Field2 > @1
var predicate = filter.ToExpression(filters);
// Use the Where method of Dynamic Linq to filter the data
queryable = queryable.Where(predicate, values);
return(queryable);
}
public static IQueryable <T> ApplyFiltering <T>(this IQueryable <T> query, Filter filter)
{
Guard.ArgumentNotNull(query, nameof(query));
if (filter?.Logic == null)
{
return(query);
}
var filters = filter.All();
// Get all filter values as array (needed by the Where method of Dynamic Linq)
var values = filters.Select(f => f.Value).ToArray();
// Create a predicate expression e.g. Field1 = @0 And Field2 > @1
var predicate = filter.ToExpression(filters);
// Use the Where method of Dynamic Linq to filter the data
query = query.Where(predicate, values);
return(query);
}
private static IQueryable <T> Filter <T>(IQueryable <T> queryable, Filter filter, IList <DataExtension> dataExtensions)
{
if (filter == null || filter.Logic == null)
{
return(queryable);
}
if (dataExtensions != null && filter.Filters != null)
{
if (dataExtensions.Any(p => p.CustomType == "MCS"))
{
dataExtensions.Where(p => p.CustomType == "MCS").ToList().ForEach(oim =>
{
var str = filter.Filters.SingleOrDefault(c => c.Field == oim.Field);
if (str == null)
{
return;
}
queryable = queryable.MultiValueContainsAnyAll(new Collection <string>()
{
str.Value.ToString()
},
false, (Expression <Func <T, string[]> >)oim.Columns, str.Operator);
filter.Filters = filter.Filters.Except(new List <Filter>()
{
str
});
if (filter.Filters.Any() == false)
{
return;
}
});
if (filter.Filters.Any() == false)
{
return(queryable);
}
}
}
// Collect a flat list of all filters
var filters = filter.All();
var ignorestring = "Ignore-Filter";
if (dataExtensions != null)
{
filters.ToList().ForEach(c =>
{
var dataExtension = dataExtensions.SingleOrDefault(p => p.Field == c.Field);
if (dataExtension == null)
{
return;
}
if (dataExtension.Ignore)
{
c.Field = ignorestring;
}
if (!string.IsNullOrEmpty(dataExtension.ActualField))
{
c.Field = dataExtension.ActualField;
}
if (dataExtension.FieldType != null)
{
c.Value = dataExtension.FieldType.IsEnum ? Enum.Parse(dataExtension.FieldType, c.Value.ToString()) : Convert.ChangeType(c.Value, dataExtension.FieldType);
}
});
}
filters = filters.Where(c => c.Field != ignorestring).ToList();
filter.Filters = filter.Filters.Where(c => c.Field != ignorestring).ToList();
if (!filter.Filters.Any())
{
return(queryable);
}
// Get all filter values as array (needed by the Where method of Dynamic Linq)
var values = filters.Select(f => f.Value).ToArray();
// Create a predicate expression e.g. Field1 = @0 And Field2 > @1
string predicate = filter.ToExpression(filters);
// Use the Where method of Dynamic Linq to filter the data
queryable = queryable.Where(predicate, values);
return(queryable);
}
