public void TestMatch1()
 {
     var filter = new SubstringFilter("Foobar", true);
     var matches = new List<LogLineMatch>();
     new Action(() => filter.Match(new LogLine(0, 0, null, LevelFlags.All), matches)).ShouldNotThrow();
     matches.Should().BeEmpty();
 }
Example #2
0
        public LogFileSearch(ITaskScheduler taskScheduler, ILogFile logFile, string searchTerm, TimeSpan maximumWaitTime)
        {
            if (taskScheduler == null)
                throw new ArgumentNullException("taskScheduler");
            if (logFile == null)
                throw new ArgumentNullException("logFile");
            if (string.IsNullOrEmpty(searchTerm))
                throw new ArgumentException("searchTerm may not be empty");

            _logFile = logFile;
            _filter = new SubstringFilter(searchTerm, true);
            _matches = new List<LogMatch>();
            _syncRoot = new object();
            _listeners = new LogFileSearchListenerCollection(this);
            _pendingModifications = new ConcurrentQueue<LogFileSection>();
            _scheduler = taskScheduler;

            const int maximumLineCount = 1000;
            _maximumWaitTime = maximumWaitTime;
            _logLinesBuffer = new LogLine[maximumLineCount];
            _matchesBuffer = new List<LogLineMatch>();
            _logFile.AddListener(this, _maximumWaitTime, maximumLineCount);

            _task = _scheduler.StartPeriodic(FilterAllPending,
                                             TimeSpan.FromMilliseconds(100),
                                             string.Format("Search {0}", logFile));
        }
Example #3
0
        public ILogEntryFilter CreateFilter()
        {
            string value = Value;
            ILogEntryFilter filter = null;
            switch (MatchType)
            {
                case QuickFilterMatchType.StringFilter:
                    if (!string.IsNullOrEmpty(value))
                        filter = new SubstringFilter(value, IgnoreCase);
                    break;

                case QuickFilterMatchType.WildcardFilter:
                    if (!string.IsNullOrEmpty(value))
                        filter = new WildcardFilter(value, IgnoreCase);
                    break;

                case QuickFilterMatchType.RegexpFilter:
                    if (!string.IsNullOrEmpty(value))
                        filter = new RegexFilter(value, IgnoreCase);
                    break;
            }

            if (filter != null && IsInverted)
                filter = new InvertFilter(filter);

            return filter;
        }
 public void TestMatch2()
 {
     var filter = new SubstringFilter("a", true);
     var matches = new List<LogLineMatch>();
     filter.Match(new LogLine(0, 0, "Foobar", LevelFlags.All), matches);
     matches.Count.Should().Be(1);
     matches[0].Index.Should().Be(4);
     matches[0].Count.Should().Be(1);
 }
 public void Test()
 {
     using (var source1 = new LogFile(_scheduler, LogFileTest.File2Entries))
     using (var source2 = new LogFile(_scheduler, LogFileTest.File2Lines))
     {
         var sources = new List<ILogFile> {source1, source2};
         using (var merged = new MergedLogFile(_scheduler, TimeSpan.FromMilliseconds(10), sources))
         {
             var filter = new SubstringFilter("foo", true);
             using (var filtered = new FilteredLogFile(_scheduler, TimeSpan.FromMilliseconds(10), merged, filter))
             {
                 filtered.Property(x => x.Count).ShouldEventually().Be(1, TimeSpan.FromSeconds(5));
             }
         }
     }
 }
Example #6
0
 public static ILogEntryFilter Create(string substringFilter)
 {
     var filter = new SubstringFilter(substringFilter, true);
     return filter;
 }