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