static bool isEnabledWithAnalyzerConfigOptions( DiagnosticDescriptor descriptor, SeverityFilter severityFilter, Compilation? compilation, AnalyzerOptions? analyzerOptions, CancellationToken cancellationToken) { if (compilation != null && compilation.Options.SyntaxTreeOptionsProvider is { } treeOptions) { foreach (var tree in compilation.SyntaxTrees) { // Check if diagnostic is enabled by SyntaxTree.DiagnosticOptions or Bulk configuration from AnalyzerConfigOptions. if (treeOptions.TryGetDiagnosticValue(tree, descriptor.Id, cancellationToken, out var configuredValue) || analyzerOptions.TryGetSeverityFromBulkConfiguration(tree, compilation, descriptor, cancellationToken, out configuredValue)) { if (configuredValue != ReportDiagnostic.Suppress && !severityFilter.Contains(configuredValue)) { return true; } } } } return false; }
static void Main(string[] args) { SeverityFilter warning_filter = new SeverityFilter() { comparison = ComparisonOperator.geq, severity = SyslogSeverity.Warning }; Console.WriteLine("This program is going to listen for all messages with severity >= Warning."); Console.WriteLine("All received messages will be written on this console in their native format."); Console.WriteLine(); Console.WriteLine("You must start Logbus daemon prior to running this program."); Console.WriteLine("Please press ENTER when you are sure that Logbus daemon is already running..."); Console.ReadLine(); Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress); try { logclient = ClientHelper.CreateUnreliableClient(warning_filter); logclient.MessageReceived += new EventHandler <SyslogMessageEventArgs>(logclient_MessageReceived); logclient.Start(); Console.WriteLine("Listener is started. Press CTRL+C to exit when you are finished"); Thread.Sleep(Timeout.Infinite); } catch (Exception ex) { Console.WriteLine("Something went wrong..."); Console.WriteLine(ex); Environment.Exit(1); } }
internal static bool Contains(this SeverityFilter severityFilter, ReportDiagnostic severity) { return(severity switch { ReportDiagnostic.Hidden => (severityFilter & SeverityFilter.Hidden) != 0, ReportDiagnostic.Info => (severityFilter & SeverityFilter.Info) != 0, _ => false });
public void IsMatchTest() { { SeverityFilter target = new SeverityFilter { comparison = ComparisonOperator.neq, severity = SyslogSeverity.Emergency }; SyslogMessage message = new SyslogMessage(null, "logbus.dis.unina.it", SyslogFacility.Cron, SyslogSeverity.Error, "Kawabongaaaaa"); bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } { SeverityFilter target = new SeverityFilter { comparison = ComparisonOperator.geq, severity = SyslogSeverity.Info }; SyslogMessage message = new SyslogMessage(null, "logbus.dis.unina.it", SyslogFacility.Cron, SyslogSeverity.Error, "Kawabongaaaaa"); bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } { SeverityFilter target = new SeverityFilter { comparison = ComparisonOperator.lt, severity = SyslogSeverity.Emergency }; SyslogMessage message = new SyslogMessage(null, "logbus.dis.unina.it", SyslogFacility.Cron, SyslogSeverity.Error, "Kawabongaaaaa"); bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } }
internal bool IsDiagnosticAnalyzerSuppressed( DiagnosticAnalyzer analyzer, CompilationOptions options, Func <DiagnosticAnalyzer, bool> isCompilerAnalyzer, AnalyzerExecutor analyzerExecutor, SeverityFilter severityFilter) { if (isCompilerAnalyzer(analyzer)) { // Compiler analyzer must always be executed for compiler errors, which cannot be suppressed or filtered. return(false); } var supportedDiagnostics = GetSupportedDiagnosticDescriptors(analyzer, analyzerExecutor); var diagnosticOptions = options.SpecificDiagnosticOptions; analyzerExecutor.TryGetCompilationAndAnalyzerOptions(out var compilation, out var analyzerOptions); foreach (var diag in supportedDiagnostics) { if (HasNotConfigurableTag(diag.CustomTags)) { if (diag.IsEnabledByDefault) { // Diagnostic descriptor is not configurable, so the diagnostics created through it cannot be suppressed. return(false); } else { // NotConfigurable disabled diagnostic can be ignored as it is never reported. continue; } } // Is this diagnostic suppressed by default (as written by the rule author) var isSuppressed = !diag.IsEnabledByDefault; // Global editorconfig settings overrides the analyzer author // Compilation wide user settings (diagnosticOptions) from ruleset/nowarn/warnaserror overrides the analyzer author and global editorconfig settings. // Note that "/warnaserror-:DiagnosticId" adds a diagnostic option with value 'ReportDiagnostic.Default', // which should not alter 'isSuppressed'. if ((diagnosticOptions.TryGetValue(diag.Id, out var severity) || options.SyntaxTreeOptionsProvider is object && options.SyntaxTreeOptionsProvider.TryGetGlobalDiagnosticValue(diag.Id, analyzerExecutor.CancellationToken, out severity)) && severity != ReportDiagnostic.Default) { isSuppressed = severity == ReportDiagnostic.Suppress; }
static void Main(string[] args) { Console.WriteLine("This program monitors only heartbeats coming from any entity in the system."); Console.WriteLine("Press CTRL+C when you are finished."); PropertyFilter idFilt = new PropertyFilter { comparison = ComparisonOperator.eq, propertyName = Property.MessageID, value = "HEARTBEAT" }; SeverityFilter debugFilter = new SeverityFilter { comparison = ComparisonOperator.eq, severity = SyslogSeverity.Debug }; using (ILogClient client = ClientHelper.CreateUnreliableClient(idFilt & debugFilter)) { client.MessageReceived += client_MessageReceived; client.Start(); Thread.Sleep(Timeout.Infinite); } }
public void IsMatchTest() { { FilterBase f1 = new FacilityEqualsFilter { facility = SyslogFacility.Ftp }, f2 = new MessageRegexMatchFilter { pattern = "^FFDA" }; OrFilter target = new OrFilter(); target.filter = new FilterBase[] { f1, f2 }; SyslogMessage message = new SyslogMessage { Facility = SyslogFacility.Internally, Severity = SyslogSeverity.Error, Text = "FFDA WOW!" }; bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } { FilterBase f1 = new FacilityEqualsFilter { facility = SyslogFacility.Ftp }, f2 = new MessageRegexMatchFilter { pattern = "^FFDA" }; OrFilter target = new OrFilter(); target.filter = new FilterBase[] { f1, f2 }; SyslogMessage message = new SyslogMessage { Facility = SyslogFacility.Ftp, Severity = SyslogSeverity.Error, Text = "Nobody!" }; bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } { string msg = @"<34>1 2003-10-11T22:14:15.003Z mymachine.example.com su - ID47 - ’su root’ failed for lonvick on /dev/pts/8"; FilterBase f1 = new FacilityEqualsFilter { facility = SyslogFacility.Security }, f2 = new MessageRegexMatchFilter { //Ok, that should be the real UNIX user pattern but let's assume only letters and numbers here :) pattern = "’su root’ failed for [a-zA-Z0-9]" }, f3 = new SeverityFilter { comparison = ComparisonOperator.neq, severity = SyslogSeverity.Emergency }; OrFilter target = new OrFilter(); target.filter = new FilterBase[] { f1, f2, f3 }; SyslogMessage message = SyslogMessage.Parse(msg); bool expected = true; bool actual; actual = target.IsMatch(message); Assert.AreEqual(expected, actual); } }
public void SeverityFilterConstructorTest() { SeverityFilter target = new SeverityFilter(); Assert.IsNotNull(target); }
internal bool IsDiagnosticAnalyzerSuppressed( DiagnosticAnalyzer analyzer, CompilationOptions options, Func<DiagnosticAnalyzer, bool> isCompilerAnalyzer, AnalyzerExecutor analyzerExecutor, SeverityFilter severityFilter) { if (isCompilerAnalyzer(analyzer)) { // Compiler analyzer must always be executed for compiler errors, which cannot be suppressed or filtered. return false; } var supportedDiagnostics = GetSupportedDiagnosticDescriptors(analyzer, analyzerExecutor); var diagnosticOptions = options.SpecificDiagnosticOptions; analyzerExecutor.TryGetCompilationAndAnalyzerOptions(out var compilation, out var analyzerOptions); foreach (var diag in supportedDiagnostics) { if (HasNotConfigurableTag(diag.CustomTags)) { if (diag.IsEnabledByDefault) { // Diagnostic descriptor is not configurable, so the diagnostics created through it cannot be suppressed. return false; } else { // NotConfigurable disabled diagnostic can be ignored as it is never reported. continue; } } // Is this diagnostic suppressed by default (as written by the rule author) var isSuppressed = !diag.IsEnabledByDefault; // Compilation wide user settings from ruleset/nowarn/warnaserror overrides the analyzer author. // Note that "/warnaserror-:DiagnosticId" adds a diagnostic option with value 'ReportDiagnostic.Default', // which should not alter 'isSuppressed'. if (diagnosticOptions.TryGetValue(diag.Id, out var severity) && severity != ReportDiagnostic.Default) { isSuppressed = severity == ReportDiagnostic.Suppress; } else { severity = isSuppressed ? ReportDiagnostic.Suppress : DiagnosticDescriptor.MapSeverityToReport(diag.DefaultSeverity); } // Is this diagnostic suppressed due to its severity if (severityFilter.Contains(severity)) { isSuppressed = true; } // Editorconfig user settings override compilation wide settings. if (isSuppressed && isEnabledWithAnalyzerConfigOptions(diag, severityFilter, compilation, analyzerOptions, analyzerExecutor.CancellationToken)) { isSuppressed = false; } if (!isSuppressed) { return false; } } if (analyzer is DiagnosticSuppressor suppressor) { foreach (var suppressionDescriptor in GetSupportedSuppressionDescriptors(suppressor, analyzerExecutor)) { if (!suppressionDescriptor.IsDisabled(options)) { return false; } } } return true;
private static void Run(int timeout) { _messagesRcvd = new BitArray(_expected, false); _received = 0; string pid = Process.GetCurrentProcess().Id.ToString(CultureInfo.InvariantCulture); ILogCollector server = CollectorHelper.CreateCollector(); string host = Dns.GetHostName(); PropertyFilter hostFilter = new PropertyFilter { comparison = ComparisonOperator.eq, value = host, propertyName = Property.Host }; FacilityEqualsFilter facFilter = new FacilityEqualsFilter { facility = SyslogFacility.Local4 }; PropertyFilter pidFilter = new PropertyFilter { comparison = ComparisonOperator.eq, value = pid, propertyName = Property.ProcessID }; PropertyFilter idFilter = new PropertyFilter { value = "BENCH", comparison = ComparisonOperator.eq, propertyName = Property.MessageID }; SeverityFilter sevFilter = new SeverityFilter { comparison = ComparisonOperator.eq, severity = SyslogSeverity.Notice }; using (ILogClient client = ClientHelper.CreateReliableClient(hostFilter & pidFilter & idFilter & sevFilter & facFilter)) { client.MessageReceived += client_MessageReceived; client.Start(); for (int i = 0; i < _expected; i++) { if (timeout > 0) { Nanosleep(timeout); } SyslogMessage message = new SyslogMessage { Timestamp = DateTime.Now, Facility = SyslogFacility.Local4, Severity = SyslogSeverity.Notice, Host = host, ProcessID = pid, MessageId = "BENCH", Text = i.ToString() }; server.SubmitMessage(message); } silenceTimer = new Timer(state => Stop.Set(), null, 40000, Timeout.Infinite); Console.WriteLine("Waiting up to 30 seconds after last message received..."); Stop.WaitOne(); } if (_expected == _received) { Console.WriteLine("Received all messaged"); } else { Console.WriteLine("Lost {0} messages", _expected - _received); } }