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;
}
