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);
}
/// <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 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);
}
public ILogFilter Assemble(IBuilderContext context, LogFilterData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
LogEnabledFilterData castedObjectConfiguration = (LogEnabledFilterData)objectConfiguration;
ILogFilter createdObject
= new LogEnabledFilter(
castedObjectConfiguration.Name,
castedObjectConfiguration.Enabled);
return(createdObject);
}
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 void CanCreatePoliciesForEnabledFilter()
{
LogEnabledFilterData data = new LogEnabledFilterData("provider name", true);
loggingSettings.LogFilters.Add(data);
container.AddExtension(new LoggingBlockExtension());
LogEnabledFilter createdObject = (LogEnabledFilter)container.Resolve <ILogFilter>("provider name");
Assert.IsNotNull(createdObject);
Assert.AreEqual("provider name", createdObject.Name);
Assert.AreEqual(true, createdObject.Enabled);
}
public void EntryIsNotWrittenToEventlogWhenLogEnabledFilterIsFalse()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForEventlog(loggingConfiguration);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", false);
loggingConfiguration.Filters.Add(logEnabledFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging Not Present");
this.writer.Dispose();
Assert.IsFalse(this.CheckForEntryInEventlog("Message: Test Logging Not Present"));
}
public void EntryIsNotWrittenWhenRollingFlatFileLogEnabledFilterIsFalse()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForRollingFlatFileRollExistsIncrement(loggingConfiguration);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", false);
loggingConfiguration.Filters.Add(logEnabledFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging Not Present");
this.writer.Dispose();
Assert.IsFalse(File.Exists(Path.Combine(this.strPath, "RollingFlatFile.log")));
}
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);
}
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();
}
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 EntryIsNotWrittenWhenXMLLogEnabledFilterIsFalse()
{
File.Delete(Path.Combine(this.strPath, "XmlLogFile.xml"));
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForXMLTL(loggingConfiguration);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", false);
loggingConfiguration.Filters.Add(logEnabledFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging XML Not Present");
this.writer.Dispose();
Assert.IsFalse(File.Exists(Path.Combine(this.strPath, "XmlLogFile.xml")));
}
public void EmailIsNotSentWhenLogEnabledFilterIsFalse()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForEmailNoPortEmailAuth(loggingConfiguration);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", false);
loggingConfiguration.Filters.Add(logEnabledFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Test Logging Not Present");
this.writer.Dispose();
string emailContent = LogFileReader.GetEmail();
Assert.IsNull(emailContent);
}
public void EntryIsNotWrittenToDatabaseWhenLogEnabledFilterIsFalse()
{
LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace();
this.UpdateConfigForDatabaseTL(loggingConfiguration);
var logEnabledFilter = new LogEnabledFilter("LogEnabled Filter", false);
loggingConfiguration.Filters.Add(logEnabledFilter);
this.writer = new LogWriter(loggingConfiguration);
this.writer.Write("Invalid Log Entry. LogEnabledFilter is False", "Database",
2, 1001, TraceEventType.Warning, "Logging Block ProgConfig Sample", null);
string dateTimeLogged = DateTime.Now.ToLocalTime().ToString();
string strMessage = this.CheckEntryInDatabase();
Assert.IsFalse(strMessage.Contains("Timestamp: " + dateTimeLogged + "\r\nMessage: Invalid Log Entry. LogEnabledFilter is False"));
}
/// <summary>
/// Queries whether logging is enabled.
/// </summary>
/// <returns><b>true</b> if logging is enabled.</returns>
public override bool IsLoggingEnabled()
{
LogEnabledFilter enabledFilter = filter.GetFilter <LogEnabledFilter>();
return(enabledFilter == null || enabledFilter.Enabled);
}
/// <summary>
/// Queries whether logging is enabled.
/// </summary>
/// <returns><b>true</b> if logging is enabled.</returns>
public bool IsLoggingEnabled()
{
LogEnabledFilter enabledFilter = this.filter.GetFilter <LogEnabledFilter>();
return(enabledFilter == null || enabledFilter.Enabled);
}
