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