public Console(IInput input, IViewer viewer) { Command = new Command(); _Filter = LogFilter.All; _Commands = new Dictionary<string, string>(); _Initial(input, viewer); }
public fmEditFilter(LogFilter filter, IEnumerable<string> fieldNames) { Filter = filter ?? new LogFilter(); _fieldNames = fieldNames; InitializeComponent(); }
public Console(IInput input, IViewer viewer) { Command = new Command(); _Filter = LogFilter.All; _Initial(input , viewer); }
public void AsyncSetMinimalFilterBlock( LogFilter filter, int delayMilliSeconds = 0 ) { var state = Tuple.Create( TimeSpan.FromMilliseconds( delayMilliSeconds ), filter, new Flag() ); ThreadPool.QueueUserWorkItem( DoAsyncSetMinimalFilterBlock, state ); lock( state ) while( !state.Item3.Set ) Monitor.Wait( state ); }
public void Can_save_and_load_log_filter() { FilterStore store = new FilterStore(); LogFilter filter = store.CreateLogFilter(new BlockParameter(1), new BlockParameter(2)); store.SaveFilter(filter); Assert.True(store.FilterExists(0), "exists"); Assert.AreEqual(FilterType.LogFilter, store.GetFilterType(filter.Id), "type"); }
public static void outTrace(LogFilter type, string text, params object[] args) { if (!ShouldLog(type, LogLevel.Trace)) { return; } outMessage(type, LogLevel.Trace, text, args); }
public IActionResult GetLogs( [FromQuery] PageFilter pageFilter, [FromQuery] LogFilter logFilter, [FromQuery] string orderBy = "") { var logs = _mapper.Map<IEnumerable<LogFileViewModel>>(_repo.GetPage(logFilter, pageFilter, orderBy).Results); var memoryStream = logs.ToCsv(true).ToMemoryStream(); return new FileStreamResult(memoryStream, "text/plain") { FileDownloadName = "export_" + DateTime.Now + ".csv" }; }
/// <summary> /// Prints the message on your console if the LogFilter is enabled on your machine AND if the registered Custom Filters on your machine contain customFilter. /// </summary> /// <param name="message"></param> /// <param name="filter"></param> /// <param name="customFilter"></param> public static void Log(string message, LogFilter filter, string customFilter) { #if UNITY_EDITOR if (EditorPrefs.GetBool("SmartDebugIsEnabled") && EditorPrefs.GetBool("SmartDebug" + filter.ToString())) { Log(message, customFilter); } #endif }
/// <summary> /// Creates a named logger with a decorated <see cref="ILogger"/> /// implementation and a filter function that can be used to update or discard /// the message before delegating the actual logging to the decorated /// <paramref name="logger"/>. /// </summary> /// <param name="name">The logger name.</param> /// <param name="logger">A decorated logger. If the <paramref name="filter"/> /// function </param> /// <param name="filter">A filter message that can be used to transform /// a submitted <see cref="LogItem"/> before getting it logged by the /// underlying logger, or to ignore it completely (if the function returns /// false).</param> /// <exception cref="ArgumentNullException">If <paramref name="logger"/> /// is a null reference.</exception> /// <exception cref="ArgumentNullException">If <paramref name="filter"/> /// is a null reference.</exception> public DecoratorLogger(string name, ILogger logger, LogFilter filter) : base(name) { Ensure.ArgumentNotNull(logger, "logger"); Ensure.ArgumentNotNull(filter, "filter"); Filter = filter; Logger = logger; }
private bool PassLogFilter(LogEntry logEntry) { if (string.IsNullOrEmpty(LogFilter) || LogFilter.Equals(_defaultComboBoxItem)) { return(true); } return(logEntry.Message.IndexOf(LogFilter, StringComparison.OrdinalIgnoreCase) >= 0); }
public void Correctly_creates_address_filter(object address, AddressFilter expected) { BlockParameter from = new BlockParameter(100); BlockParameter to = new BlockParameter(BlockParameterType.Latest); FilterStore store = new FilterStore(); LogFilter filter = store.CreateLogFilter(from, to, address); filter.AddressFilter.Should().BeEquivalentTo(expected); }
private static IEnumerable <FilterLog> FilterLogsInBlockLowMemoryAllocation(LogFilter filter, ref ReceiptsIterator iterator, CancellationToken cancellationToken) { List <FilterLog> logList = null; using (iterator) { long logIndexInBlock = 0; while (iterator.TryGetNext(out var receipt)) { cancellationToken.ThrowIfCancellationRequested(); LogEntriesIterator logsIterator = receipt.Logs == null ? new LogEntriesIterator(receipt.LogsRlp) : new LogEntriesIterator(receipt.Logs); if (filter.Matches(ref receipt.Bloom)) { while (logsIterator.TryGetNext(out var log)) { cancellationToken.ThrowIfCancellationRequested(); if (filter.Accepts(ref log)) { logList ??= new List <FilterLog>(); Keccak[] topics = log.Topics; if (topics == null) { var topicsValueDecoderContext = new Rlp.ValueDecoderContext(log.TopicsRlp); topics = KeccakDecoder.Instance.DecodeArray(ref topicsValueDecoderContext); } logList.Add(new FilterLog( logIndexInBlock, logsIterator.Index, receipt.BlockNumber, receipt.BlockHash.ToKeccak(), receipt.Index, receipt.TxHash.ToKeccak(), log.LoggersAddress.ToAddress(), log.Data.ToArray(), topics)); } logIndexInBlock++; } } else { while (logsIterator.TrySkipNext()) { logIndexInBlock++; } } } } return(logList ?? (IEnumerable <FilterLog>)Array.Empty <FilterLog>()); }
public void CombineLogTests() { LogFilter f = new LogFilter( LogLevelFilter.None, LogLevelFilter.Error ); LogFilter f2 = f.SetGroup( LogLevelFilter.Info ); Assert.That( f2.Line == LogLevelFilter.Error && f2.Group == LogLevelFilter.Info ); LogFilter f3 = new LogFilter( LogLevelFilter.Trace, LogLevelFilter.Info ); LogFilter f4 = f2.Combine( f3 ); Assert.That( f4.Equals( f3 ) ); Assert.That( f4 == f3 ); }
/// <inheritdoc /> public void Open(LogFilter logFilter) { if (_logFilter != logFilter) { _logFilter = logFilter; DecodePattern(logFilter.AppDetails.Pattern); } _stream = GetStream(); }
public StartupWalletModule(Context context, ILoggerFactory loggerFactory, WalletStore walletStore, WalletWorker walletWorker, WalletService walletService, LogFilter logFilter) : base(context) { this.ChainIndex = context.ChainIndex; this.walletStore = walletStore; this.walletWorker = walletWorker; this.walletService = walletService; this.logFilter = logFilter; this.logger = loggerFactory.CreateLogger <StartupWalletModule>(); }
public void Initialize() { ChannelOption option = new ChannelOption(_minimalFilter); foreach (var s in _receiver.Handlers) { s.CollectChannelOption(option); } _minimalFilter = option.CurrentMinimalFilter; }
/// <summary> /// Add an AiLoggerProvider with given parameters to the logging system. /// </summary> /// <param name="factory">The logger factory.</param> /// <param name="serviceProvider">The service provider that contains TelemetryClient.</param> /// <param name="logFilter">Specific log filter that ignores tracking telemetry.</param> /// <returns>The logger factory given.</returns> public static ILoggerFactory AddAi( this ILoggerFactory factory, IServiceProvider serviceProvider, LogFilter logFilter) { return(AddAi( factory, () => serviceProvider.GetService <TelemetryClient>(), logFilter)); }
void DoAsyncSetMinimalFilter(object state) { var o = (Tuple <TimeSpan, LogFilter>)state; if (o.Item1 != TimeSpan.Zero) { Thread.Sleep(o.Item1); } MinimalFilter = o.Item2; }
public ActionResult <PageViewModel <LogItemPageViewModel> > GetLogs( [FromQuery] PageFilter pageFilter, [FromQuery] LogFilter logFilter, [FromQuery] string orderBy = "") { var logs = _repo.GetPage(logFilter, pageFilter, orderBy); return(Ok(_mapper.Map <PageViewModel <LogItemPageViewModel> >(logs))); }
public void WriteTest() { ILog log = null; // TODO: Initialize to an appropriate value LogFilter filter = null; // TODO: Initialize to an appropriate value DecoratorLog target = new DecoratorLog(log, filter); // TODO: Initialize to an appropriate value LogItem item = null; // TODO: Initialize to an appropriate value target.Write(item); Assert.Inconclusive("A method that does not return a value cannot be verified."); }
static void CreateLoggerFromConfig(string appenderName) { if (string.IsNullOrEmpty(appenderName)) { return; } LogLevel level = LogLevel.Disabled; string name = appenderName.Substring(7); string options = ConfigMgr.GetDefaultValue(appenderName, ""); if (string.IsNullOrEmpty(options)) { Console.WriteLine("Log.CreateLoggerFromConfig: Missing config option Logger.{0}", name); return; } var tokens = new StringArray(options, ','); LogFilter type = name.ToEnum <LogFilter>(); if (loggers.ContainsKey(type)) { Console.WriteLine("Error while configuring Logger {0}. Already defined", name); return; } level = (LogLevel)uint.Parse(tokens[0]); if (level > LogLevel.Fatal) { Console.WriteLine("Log.CreateLoggerFromConfig: Wrong Log Level {0} for logger {1}", type, name); return; } Logger logger = new Logger(name, level); int i = 0; var ss = new StringArray(tokens[1], ' '); while (i < ss.Length) { var str = ss[i++]; Appender appender = GetAppenderByName(str); if (appender == null) { Console.WriteLine("Error while configuring Appender {0} in Logger {1}. Appender does not exist", str, name); } else { logger.addAppender(appender.getId(), appender); } } loggers[type] = logger; }
internal StandardChannel(IGrandOutputSink commonSink, EventDispatcher dispatcher, IRouteConfigurationLock configLock, HandlerBase[] handlers, string configurationName, GrandOutputChannelConfigData configData) { _dispatcher = dispatcher; _receiver = new EventDispatcher.FinalReceiver(commonSink, handlers, configLock); _receiverNoCommonSink = new EventDispatcher.FinalReceiver(null, handlers, configLock); _configurationName = configurationName; if (configData != null) { _minimalFilter = configData.MinimalFilter; } }
/// <summary> /// Gets the LogItems /// </summary> /// <param name="logFilter"></param> /// <param name="cancellationToken"></param> /// <returns></returns> // public List<LogItem> GetLogItemsAsync(LogFilter logFilter) => Get<LogItemCollection>(ApiMethod.Do, $"onesetting?func=getAccessLog&needTotal=true&orderBy=happenedOn&orderDirection=desc&start={logFilter.Skip}&results={logFilter.Take}").AccessLogItems; public async Task <List <LogItem> > GetLogItemsAsync(LogFilter logFilter = null, CancellationToken cancellationToken = default) { // If take is specified, do only that chunk. if (logFilter == null) { logFilter = new LogFilter( 0, LogItemsMaxTake, DateTime.Parse("1970-01-01"), DateTime.UtcNow, LogFilterSortOrder.HappenedOnAsc); } if (logFilter.Skip == null) { logFilter.Skip = 0; } int maxLogItemCount; if (logFilter.Take != null) { if (logFilter.Take > LogItemsMaxTake) { maxLogItemCount = (int)logFilter.Take; logFilter.Take = LogItemsMaxTake; } else { maxLogItemCount = (int)logFilter.Take; } } else { maxLogItemCount = int.MaxValue; logFilter.Take = LogItemsMaxTake; } var allLogItems = new List <LogItem>(); do { var logItems = (await GetBySubUrlAsync <Page <LogItem> >($"setting/accesslogs?sort={EnumHelper.ToEnumString(logFilter.LogFilterSortOrder)}&offset={logFilter.Skip}&size={logFilter.Take}&filter=happenedOn%3E%3A{logFilter.StartDateTimeUtc.SecondsSinceTheEpoch()}%2ChappenedOn%3C%3A{logFilter.EndDateTimeUtc.SecondsSinceTheEpoch()}", cancellationToken).ConfigureAwait(false)).Items; allLogItems.AddRange(logItems.Where(item => !allLogItems.Select(li => li.Id).Contains(item.Id)).ToList()); if (logItems.Count == 0) { break; } logFilter.Skip += LogItemsMaxTake; logFilter.Take = Math.Min(LogItemsMaxTake, maxLogItemCount - allLogItems.Count); }while (logFilter.Take != 0); // Return the lot return(allLogItems); }
void DoAsyncSetMinimalFilterBlock( object state ) { var o = (Tuple<TimeSpan, LogFilter,Flag>)state; if( o.Item1 != TimeSpan.Zero ) Thread.Sleep( o.Item1 ); MinimalFilter = o.Item2; lock( o ) { o.Item3.Set = true; Monitor.Pulse( o ); } }
public void GetActivityWithEventObjectFilter_HasEntries() { var client = TodoistClientFactory.Create(); var logFilter = new LogFilter(); logFilter.ObjectEventTypes.Add(new ObjectEventTypes() { ObjectType = "project" }); var logEntries = client.Activity.GetAsync(logFilter).Result; Assert.True(logEntries.Any()); }
public void AsyncSetMinimalFilterBlock(LogFilter filter, int delayMilliSeconds = 0) { var state = Tuple.Create(TimeSpan.FromMilliseconds(delayMilliSeconds), filter, new Flag()); ThreadPool.QueueUserWorkItem(DoAsyncSetMinimalFilterBlock, state); lock (state) while (!state.Item3.Set) { Monitor.Wait(state); } }
private IEnumerable <FilterLog> FindLogsInBlock(LogFilter filter, Keccak blockHash, long blockNumber) { if (blockHash != null) { return(_receiptFinder.TryGetReceiptsIterator(blockNumber, blockHash, out var iterator) ? FilterLogsInBlockLowMemoryAllocation(filter, ref iterator) : FilterLogsInBlockHighMemoryAllocation(filter, blockHash, blockNumber)); } return(Array.Empty <FilterLog>()); }
public IEnumerable <FilterLog> GetLogs( BlockParameter fromBlock, BlockParameter toBlock, object address = null, IEnumerable <object> topics = null, CancellationToken cancellationToken = default) { LogFilter filter = _filterStore.CreateLogFilter(fromBlock, toBlock, address, topics, false); return(_logFinder.FindLogs(filter, cancellationToken)); }
public IActionResult Create() { try { return(View("Create", new Setting())); } catch (Exception ex) { LogFilter.Write(db, HttpContext.Request.QueryString.ToString(), HttpContext.Request.Path, HttpContext.Session.GetString("UserID"), ex); return(View("Error", ex)); } }
public void FilterTest() { PrivateObject param0 = null; // TODO: Initialize to an appropriate value DecoratorLog_Accessor target = new DecoratorLog_Accessor(param0); // TODO: Initialize to an appropriate value LogFilter expected = null; // TODO: Initialize to an appropriate value LogFilter actual; target.Filter = expected; actual = target.Filter; Assert.AreEqual(expected, actual); Assert.Inconclusive("Verify the correctness of this test method."); }
public async Task QuerySingleLog() { var serverOptions = new ServerContentIntegrationOption { CVarOverrides = { [CCVars.AdminLogsQueueSendDelay.Name] = "0" } }; var(client, server) = await StartConnectedServerClientPair(serverOptions : serverOptions); await Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()); var sSystems = server.ResolveDependency <IEntitySystemManager>(); var sPlayers = server.ResolveDependency <IPlayerManager>(); var sAdminLogSystem = sSystems.GetEntitySystem <AdminLogSystem>(); var sGamerTicker = sSystems.GetEntitySystem <GameTicker>(); var date = DateTime.UtcNow; var guid = Guid.NewGuid(); IPlayerSession player = default; await server.WaitPost(() => { player = sPlayers.ServerSessions.First(); sAdminLogSystem.Add(LogType.Unknown, $"{player.AttachedEntity:Entity} test log: {guid}"); }); var filter = new LogFilter { Round = sGamerTicker.RoundId, Search = guid.ToString(), Types = new HashSet <LogType> { LogType.Unknown }, After = date, AnyPlayers = new[] { player.UserId.UserId } }; await WaitUntil(server, async() => { foreach (var _ in await sAdminLogSystem.All(filter)) { return(true); } return(false); }); }
public void CombineLogTests() { LogFilter f = new LogFilter(LogLevelFilter.None, LogLevelFilter.Error); LogFilter f2 = f.SetGroup(LogLevelFilter.Info); Assert.That(f2.Line == LogLevelFilter.Error && f2.Group == LogLevelFilter.Info); LogFilter f3 = new LogFilter(LogLevelFilter.Trace, LogLevelFilter.Info); LogFilter f4 = f2.Combine(f3); Assert.That(f4.Equals(f3)); Assert.That(f4 == f3); }
void CheckFilter(bool callOnClientMinimalFilterChanged, LogFilter f) { if (_currentMinimalFilter != f) { var prev = _currentMinimalFilter; _currentMinimalFilter = f; if (callOnClientMinimalFilterChanged) { _monitorSource.OnClientMinimalFilterChanged(prev, f); } } }
LogFilter SetGlobalDefaultFilter(LogFilter defaultFilter) { Debug.Assert(_target != null); if (defaultFilter.Group == LogLevelFilter.None || defaultFilter.Line == LogLevelFilter.None) { _target.ExternalLog(Core.LogLevel.Error, message: $"Invalid GlobalDefaultFilter = '{defaultFilter}'. using default 'Trace'."); defaultFilter = LogFilter.Trace; } _target.ExternalLog(Core.LogLevel.Info, message: $"Configuring ActivityMonitor.DefaultFilter to GlobalDefaultFilter = '{defaultFilter}'."); ActivityMonitor.DefaultFilter = defaultFilter; return(defaultFilter); }
public void Log_GetByFilter_Homologation() { LogFilter filter = new LogFilter { Enviroment = (int)Log.TypeEnviroment.Homologation }; IEnumerable <Log> result = _logService.Get(filter); Assert.IsNotNull(result); Assert.AreEqual(1, result.Count()); }
public void GetPage_ShouldWork() { var context = _contextFake.GetContext("GetPage_ShouldWork") .AddFakeEnvironments() .AddFakeLevels() .AddFakeUsers(); var logs = new List <Log>() { new Log { Id = 1, Title = "599 Network connect timeout error", Origin = "216.3.128.12", Archived = false, LevelId = 3, EnvironmentId = 1, ApiUserId = 3 }, new Log { Id = 2, Title = "413 Request Entity Too Large", Origin = "158.113.248.85", Archived = false, LevelId = 3, EnvironmentId = 2, ApiUserId = 1 }, new Log { Id = 3, Title = "512 Disconnected Operation", Origin = "227.39.42.158", Archived = false, LevelId = 1, EnvironmentId = 2, ApiUserId = 4 } }; context.Logs.AddRange(logs); context.SaveChanges(); var logsFind = context.Logs.ToList(); var logFilter = new LogFilter() { LevelId = null, Title = null, Origin = null }; var pageFilter = new PageFilter() { PageLength = 3, PageNumber = 1, }; var expected = new Page <Log>() { Total = logsFind.Count(), TotalPages = 1, Results = logsFind.Take(3) }; var repo = new LogRepository(context); var result = repo.GetPage(logFilter, pageFilter, null); Assert.NotNull(result); Assert.Equal(expected.Total, result.Total); Assert.Equal(expected.TotalPages, result.TotalPages); Assert.Equal(expected.Results, result.Results, new LogComparer()); }
static bool DisplayTimestamp(LogFilter filter) { switch (filter.Flags) { case(LogFilters.APP_OBJECT_RX): case(LogFilters.APP_OBJECT_TX): case(LogFilters.LINK_RX_HEX): case(LogFilters.LINK_TX_HEX): return false; default: return true; } }
/// <summary> /// Filters and returns a copy of the collection. /// </summary> /// <param name="filters"></param> /// <returns></returns> public FlashLogEntryCollection GetFilteredSet(LogFilter[] filters) { FlashLogEntryCollection ret = new FlashLogEntryCollection(); // // Cycle through the entries to determine which // entries match the criteria imposed. // foreach (FlashLogEntry entry in this) { if (PassesFilters(entry, filters)) ret.Add(entry); } return ret; }
static DisplayHint GetDisplayHint(LogFilter filter) { switch (filter.Flags) { case(LogFilters.ERROR): return DisplayHint.ERROR; case(LogFilters.WARNING): return DisplayHint.WARNING; case (LogFilters.APP_OBJECT_RX): case (LogFilters.APP_OBJECT_TX): case (LogFilters.LINK_RX_HEX): case (LogFilters.LINK_TX_HEX): return DisplayHint.ALT1; default: return DisplayHint.INFO; } }
public void when_bridging_unbalanced_close_groups_are_automatically_handled_more_tests() { IActivityMonitor monitor = new ActivityMonitor(); var allDump = monitor.Output.RegisterClient( new StupidStringClient() ); LogFilter InfoInfo = new LogFilter( LogLevelFilter.Info, LogLevelFilter.Info ); // The pseudoConsole is a string dump of the console. // Both the console and the pseudoConsole accepts at most Info level. IActivityMonitor pseudoConsole = new ActivityMonitor(); var consoleDump = pseudoConsole.Output.RegisterClient( new StupidStringClient() ); pseudoConsole.MinimalFilter = InfoInfo; TestHelper.ConsoleMonitor.MinimalFilter = InfoInfo; // The monitor that is bridged to the Console accepts everything. monitor.MinimalFilter = LogFilter.Debug; int i = 0; for( ; i < 60; i++ ) monitor.OpenInfo().Send( "Not Bridged n°{0}", i ); int j = 0; using( monitor.Output.CreateBridgeTo( TestHelper.ConsoleMonitor.Output.BridgeTarget ) ) using( monitor.Output.CreateBridgeTo( pseudoConsole.Output.BridgeTarget ) ) { for( ; i < 62; i++ ) monitor.OpenInfo().Send( "Bridged n°{0} (appear in Console)", i ); for( ; i < 64; i++ ) monitor.OpenTrace().Send( "Bridged n°{0} (#NOT appear# in Console since level is Trace)", i ); for( ; i < 66; i++ ) monitor.OpenWarn().Send( "Bridged n°{0} (appear in Console)", i ); // Now close the groups, but not completely. for( ; j < 2; j++ ) monitor.CloseGroup( String.Format( "Close n°{0} (Close Warn appear in Console)", j ) ); monitor.CloseGroup( String.Format( "Close n°{0} (Close Trace does #NOT appear# in Console)", j++ ) ); // Disposing: This removes the bridge to the console: the Trace is not closed (not opened because of Trace level), but the 2 Info are automatically closed. } string consoleText = consoleDump.ToString(); Assert.That( consoleText, Is.Not.Contains( "#NOT appear#" ) ); Assert.That( Regex.Matches( consoleText, "Close Warn appear" ).Count, Is.EqualTo( 2 ) ); Assert.That( Regex.Matches( consoleText, Impl.ActivityMonitorResources.ClosedByBridgeRemoved ).Count, Is.EqualTo( 2 ), "The 2 Info groups have been automatically closed, but not the Warn nor the 60 first groups." ); for( ; j < 66; j++ ) monitor.CloseGroup( String.Format( "CLOSE NOT BRIDGED - {0}", j ) ); monitor.CloseGroup( "NEVER OPENED Group" ); string allText = allDump.ToString(); Assert.That( allText, Is.Not.Contains( Impl.ActivityMonitorResources.ClosedByBridgeRemoved ) ); Assert.That( Regex.Matches( allText, "#NOT appear#" ).Count, Is.EqualTo( 3 ), "The 2 opened Warn + the only explicit close." ); Assert.That( Regex.Matches( allText, "CLOSE NOT BRIDGED" ).Count, Is.EqualTo( 63 ), "The 60 opened groups at the beginning + the last Trace and the 2 Info." ); Assert.That( allText, Is.Not.Contains( "NEVER OPENED" ) ); }
public void SetUp() { settings = (LoggingSettings)Context.GetConfiguration(LoggingSettings.SectionName); originalMinPriority = settings.MinimumPriority; SetDenyAllExceptAllowedMode(); CategoryFilterData cat = new CategoryFilterData(); cat.Name = "foo"; settings.CategoryFilters.Add(cat); filter = new LogFilter(new LoggingConfigurationView(Context)); log = CommonUtil.GetDefaultLogEntry(); }
/// <summary> /// Initializes a new instance of the <see cref="ShellViewModel"/> class. /// </summary> public ShellViewModel(ILogAnalyzerService logAnalyzerService, IFileWatcherService fileWatcherService, IDispatcherService dispatcherService, IOpenFileService openFileService, IPleaseWaitService pleaseWaitService, IMessageService messageService) { _logAnalyzerService = logAnalyzerService; _fileWatcherService = fileWatcherService; _dispatcherService = dispatcherService; _openFileService = openFileService; _pleaseWaitService = pleaseWaitService; _messageService = messageService; ParseCommand = new Command(OnParseCommandExecute, OnParseCommandCanExecute); LoadFile = new Command<string>(OnLoadFileExecute); OpenFileCommand = new Command(OnOpenFileCommandExecute); ExitCommand = new Command(OnExitCommandExecute); Document = new TextDocument(); Filter = new LogFilter { EnableDebug = true, EnableError = true, EnableInfo = true, EnableWarning = true }; Filter.PropertyChanged += OnFilterPropertyChanged; Document.Changed += DocumentChanged; _logEntries = new FastObservableCollection<LogEntry>(); using (var reader = new XmlTextReader("Resources\\HighlightingDefinition.xshd")) { HighlightingDefinition = HighlightingLoader.Load(reader, HighlightingManager.Instance); } HighlightingManager.Instance.RegisterHighlighting("CatelHighlighting", new[] { ".cool" }, HighlightingDefinition); }
void DoAsyncSetMinimalFilter( object state ) { var o = (Tuple<TimeSpan, LogFilter>)state; if( o.Item1 != TimeSpan.Zero ) Thread.Sleep( o.Item1 ); MinimalFilter = o.Item2; }
private bool PassesFilters(FlashLogEntry entry, LogFilter[] filters) { foreach (LogFilter f in filters) { if (f == null) continue; switch (f.Type) { case FilterType.Class: if (entry.ClassName != (string) f.Criteria) return false; break; case FilterType.Namespace: if (entry.Namespace != (string) f.Criteria) return false; break; case FilterType.LogLevel: if (entry.Level < (LogLevel) f.Criteria) return false; break; } } return true; }
public void FilterLevel() { LogFilter FatalFatal = new LogFilter( LogLevelFilter.Fatal, LogLevelFilter.Fatal ); LogFilter WarnWarn = new LogFilter( LogLevelFilter.Warn, LogLevelFilter.Warn ); IActivityMonitor l = new ActivityMonitor( false ); using( l.Output.CreateBridgeTo( TestHelper.ConsoleMonitor.Output.BridgeTarget ) ) { var log = l.Output.RegisterClient( new StupidStringClient() ); using( l.SetMinimalFilter( LogLevelFilter.Error, LogLevelFilter.Error ) ) { l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "NO SHOW" ); l.Error().Send( "Error n°1." ); using( l.SetMinimalFilter( WarnWarn ) ) { l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "Warn n°1." ); l.Error().Send( "Error n°2." ); using( l.OpenWarn().Send( "GroupWarn: this appears." ) ) { Assert.That( l.MinimalFilter, Is.EqualTo( WarnWarn ), "Groups does not change the current filter level." ); l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "Warn n°2." ); l.Error().Send( "Error n°3." ); // Changing the level inside a Group. l.MinimalFilter = FatalFatal; l.Error().Send( "NO SHOW" ); l.Fatal().Send( "Fatal n°1." ); } using( l.OpenInfo().Send( "GroupInfo: NO SHOW." ) ) { Assert.That( l.MinimalFilter, Is.EqualTo( WarnWarn ), "Groups does not change the current filter level." ); l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "Warn n°2-bis." ); l.Error().Send( "Error n°3-bis." ); // Changing the level inside a Group. l.MinimalFilter = FatalFatal; l.Error().Send( "NO SHOW" ); l.Fatal().Send( "Fatal n°1." ); using( l.OpenError().Send( "GroupError: NO SHOW." ) ) { } } Assert.That( l.MinimalFilter, Is.EqualTo( WarnWarn ), "But Groups restores the original filter level when closed." ); l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "Warn n°3." ); l.Error().Send( "Error n°4." ); l.Fatal().Send( "Fatal n°2." ); } l.Trace().Send( "NO SHOW" ); l.Info().Send( "NO SHOW" ); l.Warn().Send( "NO SHOW" ); l.Error().Send( "Error n°5." ); } Assert.That( log.Writer.ToString(), Does.Not.Contain( "NO SHOW" ) ); Assert.That( log.Writer.ToString(), Does.Contain( "Error n°1." ) .And.Contain( "Error n°2." ) .And.Contain( "Error n°3." ) .And.Contain( "Error n°3-bis." ) .And.Contain( "Error n°4." ) .And.Contain( "Error n°5." ) ); Assert.That( log.Writer.ToString(), Does.Contain( "Warn n°1." ) .And.Contain( "Warn n°2." ) .And.Contain( "Warn n°2-bis." ) .And.Contain( "Warn n°3." ) ); Assert.That( log.Writer.ToString(), Does.Contain( "Fatal n°1." ) .And.Contain( "Fatal n°2." ) ); } }
private void ApplyFiltersAndDisplay() { // // Form construction not yet complete // if (m_entries == null) return; LogFilter[] filters = new LogFilter[3]; int index = 0; if (cbClasses.SelectedIndex != 0) filters[index++] = new LogFilter(FilterType.Class, cbClasses.SelectedItem.ToString()); if (cbNamespaces.SelectedIndex != 0) filters[index++] = new LogFilter(FilterType.Namespace, cbNamespaces.SelectedItem.ToString()); if (cbLogLevel.SelectedIndex != 0) { filters[index++] = new LogFilter(FilterType.LogLevel, cbLogLevel.SelectedIndex + 1); } ClearGridContents(); FlashLogEntryCollection filtered = m_entries.GetFilteredSet(filters); foreach (FlashLogEntry e in filtered) { AddLogEntryToGrid(e); } }
public void SetLogFilter(LogFilter flag) { _Filter = flag; }
public static bool Execute(MiniLogger logger, String cmd, String args, string[] warningsToSuppress, string errorPrefix) { Process commandProcess = new Process(); commandProcess.StartInfo.FileName = cmd; commandProcess.StartInfo.Arguments = args; logger.CommandLine(cmd + " " + args); // Set UseShellExecute to false for redirection. commandProcess.StartInfo.UseShellExecute = false; // Redirect the standard output and error streams. // They are read asynchronously using an event handler. commandProcess.StartInfo.RedirectStandardOutput = true; commandProcess.StartInfo.RedirectStandardError = true; LogFilter logFilter = new LogFilter(warningsToSuppress, errorPrefix, logger); commandProcess.OutputDataReceived += new DataReceivedEventHandler(logFilter.OutputFilter); commandProcess.ErrorDataReceived += new DataReceivedEventHandler(logFilter.ErrorHandler); // Let's go do the real work commandProcess.Start(); commandProcess.BeginOutputReadLine(); commandProcess.BeginErrorReadLine(); commandProcess.WaitForExit(); // How'd it go? bool bOut = commandProcess.ExitCode == 0; commandProcess.Close(); return bOut; }
void DrawConsoleWindow(int id) { Color defaultContentColor = GUI.contentColor; GUIStyle buttonStyle = new GUIStyle("button"); buttonStyle.alignment = TextAnchor.MiddleLeft; buttonStyle.fixedHeight = 30; buttonStyle.margin = new RectOffset(0,0,0,0); GUI.contentColor = Color.white; GUILayout.BeginVertical(); GUILayout.BeginHorizontal(); GUILayout.Label("Logs"); GUILayout.Space(20); _filter = (LogFilter)GUILayout.SelectionGrid((int)_filter,Enum.GetNames(typeof(LogFilter)),Enum.GetValues(typeof(LogFilter)).Length); GUILayout.EndHorizontal(); List<LogData> dataList = new List<LogData>(_logQueue.ToArray()).FindAll(m => _filter == LogFilter.All || m.type.GetFilter() == _filter); int listItemHeight = (int)buttonStyle.fixedHeight; // TODO Use Margin. int listScrollBottomPos = (listItemHeight * dataList.Count) - (int)_listScrollRect.height; Vector2 scrollPos = new Vector2(_listScrollPosition.x, _autoListScroll ? listScrollBottomPos :_listScrollPosition.y); _listScrollPosition = GUILayout.BeginScrollView(scrollPos,false,true,GUILayout.MaxHeight(_scrollHeight)); if(listScrollBottomPos <= _listScrollPosition.y) { _autoListScroll = true; } GUILayout.Box(GUIContent.none,GUIStyle.none,GUILayout.ExpandWidth(true),GUILayout.Height(0)); Rect listRect = GUILayoutUtility.GetLastRect(); GUI.contentColor = defaultContentColor; foreach(LogData data in dataList) { GUI.contentColor = data.type.GetFilter().GetContentColor(); if (GUILayout.Button(data.condition,buttonStyle,GUILayout.Width(listRect.width),GUILayout.ExpandWidth(true))) { _selectedLogData = data; } GUI.contentColor = defaultContentColor; } GUILayout.EndScrollView(); Rect listLastRect = GUILayoutUtility.GetLastRect(); if(!(listLastRect.x == 0 && listLastRect.y == 0 && listLastRect.width == 1 && listLastRect.height == 1)) { _listScrollRect = GUILayoutUtility.GetLastRect(); } GUILayout.Space(10); GUILayout.Label("Detail"); _detailScrollPosition = GUILayout.BeginScrollView(_detailScrollPosition,false,true,GUILayout.MaxHeight(_scrollHeight)); if (_selectedLogData != null) { GUI.contentColor = _selectedLogData.type.GetFilter().GetContentColor(); GUILayout.Label(_selectedLogData.condition + "\n" + _selectedLogData.stackTrace); GUI.contentColor = defaultContentColor; } GUILayout.EndScrollView(); _detailScrollRect = GUILayoutUtility.GetLastRect(); GUILayout.Space(10); // Export Menu GUILayout.BeginHorizontal(); GUI.contentColor = defaultContentColor; if (_selectedLogData == null) { GUI.contentColor = Color.gray; GUILayout.Button("Log Export (Select a Log!)"); } else { if (GUILayout.Button("Log Export")) { ExportLog(_selectedLogData); } } GUI.contentColor = defaultContentColor; GUILayout.EndHorizontal(); // Clear & Close GUILayout.BeginHorizontal(); if (GUILayout.Button("Clear")) { _selectedLogData = null; _logQueue = new Queue<LogData>(); } if(GUILayout.Button("Close")) { isShow = false; } GUILayout.EndHorizontal(); GUILayout.EndVertical(); GUI.DragWindow(new Rect(0,0,_consoleRect.width,30)); GUI.contentColor = defaultContentColor; }
/// <summary> /// Initializes a new instance of the <see cref="FilterViewModel"/> class. /// </summary> /// <param name="logFilter">The log filter.</param> public FilterViewModel(LogFilter logFilter) { Argument.IsNotNull(() => logFilter); LogFilter = logFilter; }