/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseLibraryLoggerAdapter"/> class.
/// </summary>
static EnterpriseLibraryLoggerAdapter()
{
TextFormatter _extendedFormatter = new TextFormatter("Timestamp: {timestamp}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}Severity: {severity}{newline}Title: {title}{newline}Activity ID: {property(ActivityId)}{newline}Machine: {localMachine}{newline}App Domain: {localAppDomain}{newline}ProcessId: {localProcessId}{newline}Process Name: {localProcessName}{newline}Thread Name: {threadName}{newline}Win32 ThreadId:{win32ThreadId}{newline}Extended Properties: {dictionary({key} - {value}{newline})}");
TextFormatter _briefFormatter = new TextFormatter("{timestamp(local)};{message};{category};{priority};{eventid};{severity};{title}");
// Category Filters
ICollection <string> _categories = new List <string>();
_categories.Add("BlockedByFilter");
// Log Filters
PriorityFilter _priorityFilter = new PriorityFilter("Priority Filter", -1, 99);
LogEnabledFilter _logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
CategoryFilter _categoryFilter = new CategoryFilter("Category Filter", _categories, CategoryFilterMode.AllowAllExceptDenied);
FlatFileTraceListener _flatFileTraceListener = new FlatFileTraceListener($"{nameof(ConfigurationEditorBase)}.log", string.Empty, string.Empty, _briefFormatter);
LoggingConfiguration _configuration = new LoggingConfiguration();
_configuration.Filters.Add(_priorityFilter);
_configuration.Filters.Add(_logEnabledFilter);
_configuration.Filters.Add(_categoryFilter);
_configuration.AddLogSource("Debug", System.Diagnostics.SourceLevels.All, true, _flatFileTraceListener);
FlatFileTraceListener unprocessedFlatFileTraceListener = new FlatFileTraceListener(@"Unprocessed.log", "----------------------------------------", "----------------------------------------", _extendedFormatter);
_configuration.SpecialSources.Unprocessed.AddTraceListener(unprocessedFlatFileTraceListener);
FlatFileTraceListener _LoggingErrorsAndWarningsTraceListener = new FlatFileTraceListener(@"LoggingErrorsAndWarnings.log", "----------------------------------------", "----------------------------------------", _extendedFormatter);
_configuration.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(_LoggingErrorsAndWarningsTraceListener);
Logger.SetLogWriter(new LogWriter(_configuration));
}
public void OnlyEntriesInPriorityRangeAreWrittenWhenXmlListenerPriorityFilter()
{
File.Delete(Path.Combine(this.strPath, "XmlLogFile.xml"));
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForXMLTL(loggingConfiguration);
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
loggingConfiguration.Filters.Add(priorityFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging XML 1", "General", 1);
this.writer.Write("Test Logging XML 2", "General", 2);
this.writer.Write("Test Logging XML 101", "General", 101);
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "XmlLogFile.xml")));
string strFileData = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "XmlLogFile.xml"));
Assert.IsFalse(strFileData.Contains("<Message>Test Logging XML 1</Message>"));
Assert.IsFalse(strFileData.Contains("<Message>Test Logging XML 101</Message>"));
Assert.IsTrue(strFileData.Contains("<Message>Test Logging XML 2</Message>"));
}
public void CanRetrieveLogFiltersByType()
{
ICollection <ILogFilter> filters = new List <ILogFilter>();
ICollection <string> categories = new List <string>();
categories.Add("cat1");
categories.Add("cat2");
categories.Add("cat3");
categories.Add("cat4");
filters.Add(new CategoryFilter("category", categories, CategoryFilterMode.AllowAllExceptDenied));
filters.Add(new PriorityFilter("priority", 100));
filters.Add(new LogEnabledFilter("enable", true));
LogFilterHelper helper = new LogFilterHelper(filters, new MockLogFilterErrorHandler(true));
CategoryFilter categoryFilter = helper.GetFilter <CategoryFilter>();
PriorityFilter priorityFilter = helper.GetFilter <PriorityFilter>();
LogEnabledFilter enabledFilter = helper.GetFilter <LogEnabledFilter>();
Assert.IsNotNull(categoryFilter);
Assert.AreEqual(4, categoryFilter.CategoryFilters.Count);
Assert.IsNotNull(priorityFilter);
Assert.AreEqual(100, priorityFilter.MinimumPriority);
Assert.IsNotNull(enabledFilter);
Assert.IsTrue(enabledFilter.Enabled);
}
static LoggingConfiguration BuildProgrammaticConfig()
{
// Formatters
TextFormatter formatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}");
// Category Filters
ICollection <string> categories = new List <string>();
categories.Add("BlockedByFilter");
// Log Filters
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.AllowAllExceptDenied);
// Trace Listeners
var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\ConfigSampleFlatFile.log", "----------------------------------------", "----------------------------------------", formatter);
// Build Configuration
var config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource("General", SourceLevels.All, true, flatFileTraceListener);
return(config);
}
public void CanGetLogFiltersByType()
{
ICollection <ILogFilter> filters = new List <ILogFilter>();
ICollection <string> categories = new List <string>();
categories.Add("cat1");
categories.Add("cat2");
categories.Add("cat3");
categories.Add("cat4");
filters.Add(new CategoryFilter("category", categories, CategoryFilterMode.AllowAllExceptDenied));
filters.Add(new PriorityFilter("priority", 100));
filters.Add(new LogEnabledFilter("enable", true));
LogWriter writer = new LogWriter(filters, new Dictionary <string, LogSource>(), new LogSource("errors"), "default");
CategoryFilter categoryFilter = writer.GetFilter <CategoryFilter>();
PriorityFilter priorityFilter = writer.GetFilter <PriorityFilter>();
LogEnabledFilter enabledFilter = writer.GetFilter <LogEnabledFilter>();
Assert.IsNotNull(categoryFilter);
Assert.AreEqual(4, categoryFilter.CategoryFilters.Count);
Assert.IsNotNull(priorityFilter);
Assert.AreEqual(100, priorityFilter.MinimumPriority);
Assert.IsNotNull(enabledFilter);
Assert.IsTrue(enabledFilter.Enabled);
}
public void EntriesAreOnlyWrittenToDatabaseWhenPassPriorityFilter()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForDatabaseTL(loggingConfiguration);
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
loggingConfiguration.Filters.Add(priorityFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging PriorityFilter 1", "General", 1);
this.writer.Write("Test Logging PriorityFilter 2", "General", 2);
this.writer.Write("Test Logging PriorityFilter 101", "General", 101);
string dateTimeLogged = DateTime.Now.ToLocalTime().ToString();
int checkPriority1 = this.CheckEntryInDatabase("Test Logging PriorityFilter 1");
int checkPriority101 = this.CheckEntryInDatabase("Test Logging PriorityFilter 101");
Assert.AreEqual(0, checkPriority1);
Assert.AreEqual(0, checkPriority101);
string strMessage = this.CheckEntryInDatabase();
Assert.IsTrue(strMessage.Contains("Timestamp: " + dateTimeLogged + "\r\nMessage: Test Logging PriorityFilter 2\r\nCategory: General\r\nPriority: 2\r\nEventId: 1"));
}
private void ApplyFilters()
{
BacklogTasksFiltered.Clear();
Priority?priority;
if (PriorityFilter == null || PriorityFilter.Equals(" "))
{
priority = null;
}
else
{
priority = (Priority)System.Enum.Parse(typeof(Priority), PriorityFilter);
}
var temp = BacklogTasks
.Where(
t => (t?.Title ?? "").Contains(SearchTerm ?? "") &&
(BoardFilter == null || BoardFilter.ID == -1 || t.BoardID == BoardFilter.ID) &&
(priority == null || t.Priority == priority) &&
(DueDateFilter == null || DueDateFilter.Equals(" ") ||
(DueDateFilter.Equals("Overdue") && t.DueDate != null && t.DueDate < DateTime.Now) ||
(DueDateFilter.Equals("Todays") && t.DueDate != null && t.DueDate == DateTime.Today) ||
(DueDateFilter.Equals("3 Days") && t.DueDate != null && DateTime.Now.AddDays(3) - t.DueDate <= TimeSpan.FromDays(3))
)).OrderBy(t => t.Position);
foreach (Task task in temp)
{
BacklogTasksFiltered.Add(task);
}
}
static LoggingConfiguration BuildProgrammaticConfig()
{
// Formatters
TextFormatter briefFormatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}");
TextFormatter extendedFormatter = new TextFormatter("Timestamp: {timestamp}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}Severity: {severity}{newline}Title: {title}{newline}Activity ID: {property(ActivityId)}{newline}Machine: {localMachine}{newline}App Domain: {localAppDomain}{newline}ProcessId: {localProcessId}{newline}Process Name: {localProcessName}{newline}Thread Name: {threadName}{newline}Win32 ThreadId:{win32ThreadId}{newline}Extended Properties: {dictionary({key} - {value}{newline})}");
// Category Filters
ICollection <string> categories = new List <string>();
categories.Add("BlockedByFilter");
// Log Filters
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.AllowAllExceptDenied);
// Trace Listeners
var causeLoggingErrorTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("DoesNotExist"), "WriteLog", "AddCategory", null);
var databaseTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("ExampleDatabase"), "WriteLog", "AddCategory", extendedFormatter);
var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter);
var eventLog = new EventLog("Application", ".", "Enterprise Library Logging");
var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog);
var rollingFlatFileTraceListener = new RollingFlatFileTraceListener(@"C:\Temp\RollingFlatFile.log", "----------------------------------------", "----------------------------------------", extendedFormatter, 20, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.None, 3);
var unprocessedFlatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\Unprocessed.log", "----------------------------------------", "----------------------------------------", extendedFormatter);
var xmlTraceListener = new XmlTraceListener(@"C:\Temp\XmlLogFile.xml");
xmlTraceListener.Filter = new EventTypeFilter(SourceLevels.Error);
// Build Configuration
var config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource("BlockedByFilter", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
config.AddLogSource("CauseLoggingError", SourceLevels.All, true).AddTraceListener(causeLoggingErrorTraceListener);
config.AddLogSource("Database", SourceLevels.All, true).AddTraceListener(databaseTraceListener);
// The defaults for the asynchronous wrapper are:
// bufferSize: 30000
// disposeTimeout: infinite
config.AddLogSource("AsyncDatabase", SourceLevels.All, true).AddAsynchronousTraceListener(databaseTraceListener);
config.AddLogSource("DiskFiles", SourceLevels.All, true).AddTraceListener(flatFileTraceListener);
config.LogSources["DiskFiles"].AddTraceListener(xmlTraceListener);
config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
config.AddLogSource("Important", SourceLevels.All, true).AddTraceListener(eventLogTraceListener);
config.LogSources["Important"].AddTraceListener(rollingFlatFileTraceListener);
// Special Sources Configuration
config.SpecialSources.Unprocessed.AddTraceListener(unprocessedFlatFileTraceListener);
config.SpecialSources.LoggingErrorsAndWarnings.AddTraceListener(eventLogTraceListener);
return(config);
}
public ILogFilter Assemble(IBuilderContext context, LogFilterData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
PriorityFilterData castedObjectConfiguration = (PriorityFilterData)objectConfiguration;
ILogFilter createdObject
= new PriorityFilter(
castedObjectConfiguration.Name,
castedObjectConfiguration.MinimumPriority,
castedObjectConfiguration.MaximumPriority);
return(createdObject);
}
public SelectionParameters(SelectionSeverity severity, int nRequired = 0, bool getMaxData = false, bool useJourney = true, JourneyFilter journeyFilter = JourneyFilter.CurrentJourney, PackListHistory packListHistory = PackListHistory.NoFilter, List <string> filteringIds = null, bool sortDataByDifficulty = false,
PriorityFilter priorityFilter = PriorityFilter.CurrentThenPast)
{
this.nRequired = nRequired;
this.getMaxData = getMaxData;
this.severity = severity;
this.useJourney = useJourney;
this.journeyFilter = journeyFilter;
this.packListHistory = packListHistory;
this.filteringIds = filteringIds;
this.sortDataByDifficulty = sortDataByDifficulty;
this.priorityFilter = priorityFilter;
}
public void CanCreatePoliciesForPriorityFilter()
{
PriorityFilterData data = new PriorityFilterData("provider name", 10);
data.MaximumPriority = 100;
loggingSettings.LogFilters.Add(data);
container.AddExtension(new LoggingBlockExtension());
PriorityFilter createdObject = (PriorityFilter)container.Resolve <ILogFilter>("provider name");
Assert.IsNotNull(createdObject);
Assert.AreEqual("provider name", createdObject.Name);
Assert.AreEqual(10, createdObject.MinimumPriority);
Assert.AreEqual(100, createdObject.MaximumPriority);
}
public void NonExistentFilterReturnsNullByType()
{
ICollection <ILogFilter> filters = new List <ILogFilter>();
filters.Add(new CategoryFilter("category", new List <string>(), CategoryFilterMode.AllowAllExceptDenied));
LogFilterHelper helper = new LogFilterHelper(filters, new MockLogFilterErrorHandler(true));
CategoryFilter categoryFilter = helper.GetFilter <CategoryFilter>();
PriorityFilter priorityFilter = helper.GetFilter <PriorityFilter>();
LogEnabledFilter enabledFilter = helper.GetFilter <LogEnabledFilter>();
Assert.IsNotNull(categoryFilter);
Assert.IsNull(priorityFilter);
Assert.IsNull(enabledFilter);
}
public void SetUp()
{
ICollection <string> categoryFilters = new string[] { "foo" };
categoryFilter = new CategoryFilter("category", categoryFilters, CategoryFilterMode.DenyAllExceptAllowed);
priorityFilter = new PriorityFilter("priority", 5);
enabledFilter = new LogEnabledFilter("enable", true);
ICollection <ILogFilter> filters = new List <ILogFilter>(3);
filters.Add(enabledFilter);
filters.Add(categoryFilter);
filters.Add(priorityFilter);
handler = new MockLogFilterErrorHandler(true);
filterHelper = new LogFilterHelper(filters, handler);
log = CommonUtil.GetDefaultLogEntry();
}
/// <summary>Builds the configuration used to log entries to the file system.</summary>
/// <returns>A <see cref="LoggingConfiguration"/> with default settings.</returns>
private LoggingConfiguration BuildLoggingConfiguration()
{
TextFormatter formatter = new TextFormatter("Timestamp: {timestamp(local)}{newline}Message: {message}{newline}Category: {category}{newline}Priority: {priority}{newline}EventId: {eventid}{newline}ActivityId: {property(ActivityId)}{newline}Severity: {severity}{newline}Title:{title}{newline}");
ICollection <string> categories = new List <string> {
"BlockedByFilter"
};
PriorityFilter priorityFilter = new PriorityFilter("PriorityFilter", -1);
LogEnabledFilter logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
CategoryFilter categoryFilter = new CategoryFilter("CategoryFilter", categories, CategoryFilterMode.AllowAllExceptDenied);
RollingFlatFileTraceListener rollingFileListener = new RollingFlatFileTraceListener(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"SCH\Logs\Everything.log"),
"----------------------------------------",
"----------------------------------------",
formatter,
200,
"yyyy-MM-dd",
RollFileExistsBehavior.Increment,
RollInterval.None,
5);
RollingFlatFileTraceListener errorFileListener = new RollingFlatFileTraceListener(
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"SCH\Logs\Errors.log"),
"----------------------------------------",
"----------------------------------------",
formatter,
200,
"yyyy-MM-dd",
RollFileExistsBehavior.Increment,
RollInterval.None,
2);
// Build Configuration
LoggingConfiguration config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource(LoggingConstants.CategoryGeneralConst, SourceLevels.All, true, rollingFileListener);
config.AddLogSource(LoggingConstants.CategoryCompilerConst, SourceLevels.All, true, rollingFileListener);
config.AddLogSource(LoggingConstants.CategoryErrorConst, SourceLevels.Warning, true, errorFileListener);
return(config);
}
static void ReplacePriorityFilter(int maximumPriority)
{
defaultWriter.Configure(cfg => {
cfg.Filters.Clear();
// Category Filters
ICollection <string> categories = new List <string>();
categories.Add("BlockedByFilter");
// Log Filters
var priorityFilter = new PriorityFilter("Priority Filter", 2, maximumPriority);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", true);
var categoryFilter = new CategoryFilter("Category Filter", categories, CategoryFilterMode.AllowAllExceptDenied);
cfg.Filters.Add(priorityFilter);
cfg.Filters.Add(logEnabledFilter);
cfg.Filters.Add(categoryFilter);
});
}
public void SetUp()
{
ICollection<string> categoryFilters = new string[] { "foo" };
categoryFilter = new CategoryFilter("category", categoryFilters, CategoryFilterMode.DenyAllExceptAllowed);
priorityFilter = new PriorityFilter("priority", 5);
enabledFilter = new LogEnabledFilter("enable", true);
ICollection<ILogFilter> filters = new List<ILogFilter>(3);
filters.Add(enabledFilter);
filters.Add(categoryFilter);
filters.Add(priorityFilter);
handler = new MockLogFilterErrorHandler(true);
filterHelper = new LogFilterHelper(filters, handler);
log = CommonUtil.GetDefaultLogEntry();
}
public void OnlyEntriesInPriorityRangeAreWrittenWhenEventlogWithPriorityFilter()
{
string guid = Guid.NewGuid().ToString();
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForEventlog(loggingConfiguration);
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
loggingConfiguration.Filters.Add(priorityFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging PriorityFilter 1: " + guid, "General", 1);
this.writer.Write("Test Logging PriorityFilter 2: " + guid, "General", 2);
this.writer.Write("Test Logging PriorityFilter 101: " + guid, "General", 101);
this.writer.Dispose();
Assert.IsFalse(this.CheckForEntryInEventlog("Message: Test Logging PriorityFilter 1: " + guid));
Assert.IsFalse(this.CheckForEntryInEventlog("Message: Test Logging PriorityFilter 101: " + guid));
Assert.IsTrue(this.CheckForEntryInEventlog("Message: Test Logging PriorityFilter 2: " + guid));
}
public void MultipleFiltersOfSameTypeReturnsFirstByType()
{
ICollection <ILogFilter> filters = new List <ILogFilter>();
ICollection <string> categories = new List <string>();
categories.Add("cat1");
categories.Add("cat2");
categories.Add("cat3");
categories.Add("cat4");
filters.Add(new CategoryFilter("category", categories, CategoryFilterMode.AllowAllExceptDenied));
filters.Add(new PriorityFilter("priority1", 100));
filters.Add(new PriorityFilter("priority2", 200));
filters.Add(new LogEnabledFilter("enable", true));
filters.Add(new PriorityFilter("priority2", 300));
LogFilterHelper helper = new LogFilterHelper(filters, new MockLogFilterErrorHandler(true));
PriorityFilter priorityFilter = helper.GetFilter <PriorityFilter>();
Assert.IsNotNull(priorityFilter);
Assert.AreEqual(100, priorityFilter.MinimumPriority);
}
public void OnlyEntriesInPriorityRangeAreWrittenWhenRollingFlatFilePriorityFilter()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForRollingFlatFileRollExistsIncrement(loggingConfiguration);
var priorityFilter = new PriorityFilter("Priority Filter", 2, 99);
loggingConfiguration.Filters.Add(priorityFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging1", "General", 1);
this.writer.Write("Test Logging2", "General", 2);
this.writer.Write("Test Logging101", "General", 101);
this.writer.Dispose();
Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "RollingFlatFile.log")));
string strFileData = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "RollingFlatFile.log"));
Assert.IsFalse(strFileData.Contains("Message: Test Logging1"));
Assert.IsFalse(strFileData.Contains("Message: Test Logging101"));
Assert.IsTrue(strFileData.Contains("Message: Test Logging2"));
}
public void CanGetLogFiltersByNameAndType()
{
ICollection <ILogFilter> filters = new List <ILogFilter>();
ICollection <string> categories = new List <string>();
categories.Add("cat1");
categories.Add("cat2");
categories.Add("cat3");
categories.Add("cat4");
filters.Add(new CategoryFilter("category", categories, CategoryFilterMode.AllowAllExceptDenied));
filters.Add(new PriorityFilter("priority1", 100));
filters.Add(new LogEnabledFilter("enable", true));
filters.Add(new PriorityFilter("priority2", 200));
LogWriter writer = new LogWriterImpl(filters, new Dictionary <string, LogSource>(), new LogSource("errors"), "default");
PriorityFilter priorityFilter1 = writer.GetFilter <PriorityFilter>("priority1");
PriorityFilter priorityFilter2 = writer.GetFilter <PriorityFilter>("priority2");
Assert.IsNotNull(priorityFilter1);
Assert.AreEqual(100, priorityFilter1.MinimumPriority);
Assert.IsNotNull(priorityFilter2);
Assert.AreEqual(200, priorityFilter2.MinimumPriority);
}
static void ShowDetailsAndAddExtraInfo(LogEntry entry)
{
// Display information about the Trace Sources and Listeners for this LogEntry.
IEnumerable <LogSource> sources = defaultWriter.GetMatchingTraceSources(entry);
foreach (LogSource source in sources)
{
Console.WriteLine("Log Source name: '{0}'", source.Name);
foreach (TraceListener listener in source.Listeners)
{
Console.WriteLine(" - Listener name: '{0}'", listener.Name);
}
}
// Check if any filters will block this LogEntry.
// This approach allows you to check for specific types of filter.
// If there are no filters of the specified type configured, the GetFilter
// method returns null, so check this before calling the ShouldLog method.
CategoryFilter catFilter = defaultWriter.GetFilter <CategoryFilter>();
if (null == catFilter || catFilter.ShouldLog(entry.Categories))
{
Console.WriteLine("Category Filter(s) will not block this LogEntry.");
}
else
{
Console.WriteLine("A Category Filter will block this LogEntry.");
}
PriorityFilter priFilter = defaultWriter.GetFilter <PriorityFilter>();
if (null == priFilter || priFilter.ShouldLog(entry.Priority))
{
Console.WriteLine("Priority Filter(s) will not block this LogEntry.");
}
else
{
Console.WriteLine("A Priority Filter will block this LogEntry.");
}
// Alternatively, a simple approach can be used to check for any type of filter
if (defaultWriter.ShouldLog(entry))
{
Console.WriteLine("This LogEntry will not be blocked due to configuration settings.");
// Create the additional context information to add to the LogEntry. Checking that
// the LogEntry will not be blocked first minimizes the performance impact.
Dictionary <string, object> dict = new Dictionary <string, object>();
// Use the information helper classes to get information about the environment and add it to the dictionary.
DebugInformationProvider debugHelper = new DebugInformationProvider();
debugHelper.PopulateDictionary(dict);
Console.WriteLine("Added the current stack trace to the Log Entry.");
ManagedSecurityContextInformationProvider infoHelper = new ManagedSecurityContextInformationProvider();
infoHelper.PopulateDictionary(dict);
Console.WriteLine("Added current identity name, authentication type, and status to the Log Entry.");
UnmanagedSecurityContextInformationProvider secHelper = new UnmanagedSecurityContextInformationProvider();
secHelper.PopulateDictionary(dict);
Console.WriteLine("Added the current user name and process account name to the Log Entry.");
ComPlusInformationProvider comHelper = new ComPlusInformationProvider();
comHelper.PopulateDictionary(dict);
Console.WriteLine("Added COM+ IDs and caller account information to the Log Entry.");
// Get any other information you require and add it to the dictionary.
string configInfo = File.ReadAllText(@"..\..\App.config");
dict.Add("Config information", configInfo);
Console.WriteLine("Added information about the configuration of the application to the Log Entry.");
// Set the dictionary in the LogEntry and write it using the default LogWriter.
entry.ExtendedProperties = dict;
defaultWriter.Write(entry);
Console.WriteLine("LogEntry written to configured trace listeners.");
Console.WriteLine();
}
else
{
Console.WriteLine("This LogEntry will be blocked due to configuration settings.");
}
}
public void AssignJourney(bool insideJourney)
{
journeyFilter = JourneyFilter.CurrentJourney;
priorityFilter = insideJourney ? PriorityFilter.CurrentThenPast : PriorityFilter.NoPriority;
}
