public static LoggingConfiguration BuildProgrammaticConfig(bool isAsync = false) { var formatter = new TextFormatter(); var flatFileTraceListener = new FlatFileTraceListener(@"FlatFile.log", "----------------------------------------", "----------------------------------------", formatter); // var eventLog = new EventLog("Application", ".", "LoggingApplication"); // var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog, formatter); // Build Configuration var config = new LoggingConfiguration(); if (isAsync == false) { config.AddLogSource("General", SourceLevels.All, true) // .AddTraceListener(eventLogTraceListener); .AddTraceListener(flatFileTraceListener); } else { config.AddLogSource("General", SourceLevels.All, true) // .AddTraceListener(eventLogTraceListener); .AddAsynchronousTraceListener(flatFileTraceListener); } config.IsTracingEnabled = true; return(config); }
public void FlatFileListenerReplacedEnviromentVariablesWillFallBackIfNotPrivilegesToRead() { string environmentVariable = "%USERPROFILE%"; string fileName = Path.Combine(environmentVariable, "foo.log"); EnvironmentPermission denyPermission = new EnvironmentPermission(PermissionState.Unrestricted); denyPermission.Deny(); try { FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); } catch (InvalidOperationException) { throw; } finally { EnvironmentPermission.RevertAll(); } Assert.Fail("Permission was not denied."); }
public void FlatFileListenerWillFallbackIfNotPriviledgesToWrite() { string fileName = @"trace.log"; string fullPath = String.Format(@"{0}\{1}", Directory.GetCurrentDirectory(), fileName); File.Delete(fileName); FileIOPermission fileIOPerm1 = new FileIOPermission(PermissionState.None); fileIOPerm1.SetPathList(FileIOPermissionAccess.Read, fullPath); fileIOPerm1.PermitOnly(); try { FlatFileTraceListener listener = new FlatFileTraceListener(fileName, "---header---", "***footer***", new TextFormatter("DUMMY{newline}DUMMY")); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All); source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null)); listener.Dispose(); } catch (SecurityException) { FileIOPermission.RevertAll(); throw; } }
public void EntryIsWrittenWhenFlatFileUnprocessedCategory() { LoggingConfiguration loggingConfiguration = BuildProgrammaticConfigForTrace(); this.UpdateFlatFileForConfig(loggingConfiguration); var unprocessedFlatFileTraceListener = new FlatFileTraceListener( Path.Combine(strPath, "Unprocessed.log"), "----------------------------------------", "----------------------------------------", null); loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(unprocessedFlatFileTraceListener); this.writer = new LogWriter(loggingConfiguration); this.writer.Write("Test Logging"); this.writer.Dispose(); Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "FlatFile.log"))); Assert.IsTrue(File.Exists(Path.Combine(this.strPath, "Unprocessed.log"))); string strFileData1 = LogFileReader.ReadFileWithoutLock(Path.Combine(this.strPath, "FlatFile.log")); Assert.IsTrue(strFileData1.Contains("Message: Test Logging")); Assert.IsTrue(strFileData1.Contains("Category: General")); string strFileData = LogFileReader.ReadFileWithoutLock((Path.Combine(this.strPath, "Unprocessed.log"))); Assert.IsTrue(strFileData.Contains("Message: Test Logging")); Assert.IsTrue(strFileData.Contains("Unprocessed Category Information: 1")); }
private static LogSource BuildErrorsLogSource() { var formatter = new TextFormatter( @"Timestamp: {timestamp} Category: {category} Message: {message} Priority: {priority} EventId: {eventid} Severity: {severity} Title:{title} Machine: {machine} Application Domain: {appDomain} Process Id: {processId} Process Name: {processName} Win32 Thread Id: {win32ThreadId} Thread Name: {threadName} Extended Properties: {dictionary({key} - {value})}" ); var fileListener = new FlatFileTraceListener("ErrorLog.txt"); fileListener.Formatter = formatter; var listeners = new TraceListener[] { fileListener }; var source = new LogSource("FlatFileTraceListener", listeners, SourceLevels.All); return(source); }
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 FlatFileListenerWillFallbackIfNotPriviledgesToWrite() { string fileName = @"trace.log"; string fullPath = String.Format(@"{0}\{1}", Directory.GetCurrentDirectory(), fileName); File.Delete(fileName); FileIOPermission fileIOPerm1 = new FileIOPermission(PermissionState.None); fileIOPerm1.SetPathList(FileIOPermissionAccess.Read, fullPath); fileIOPerm1.PermitOnly(); try { FlatFileTraceListener listener = new FlatFileTraceListener(fileName, "---header---", "***footer***", new TextFormatter("DUMMY{newline}DUMMY")); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", SourceLevels.All); source.Listeners.Add(listener); source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null)); source.Dispose(); } catch (SecurityException) { FileIOPermission.RevertAll(); throw; } }
/// <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 FlatFileListenerReplacedEnviromentVariables() { string fileName = @"%USERPROFILE%\foo.log"; string fileNameFromListener = string.Empty; FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(fileName); bool result = File.Exists(expandedFileName); Assert.IsTrue(result); using (FileStream stream = File.Open(expandedFileName, FileMode.Open)) { fileNameFromListener = stream.Name; } File.Delete(expandedFileName); Assert.AreEqual(expandedFileName, fileNameFromListener); }
public static void CheckListener() { string environmentVariable = "%USERPROFILE%"; string fileName = Path.Combine(environmentVariable, "test.log"); FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); }
private void UpdateFlatFileForConfigNullParams(LoggingConfiguration loggingConfiguration) { // Trace Listeners var flatFileTraceListener = new FlatFileTraceListener(Path.Combine(strPath, "FlatFile.log"), null, null, null); flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All); // Special Sources Configuration loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener); }
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 UpdateConfiguration() { numUpdates++; Logger.Writer.Configure(config => { 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}"); var newDest = new FlatFileTraceListener(@"C:\Temp\trace-" + numUpdates + @".log", "----------------------------------------", "----------------------------------------", formatter); config.SpecialSources.AllEvents.Listeners.Clear(); config.SpecialSources.AllEvents.AddTraceListener(newDest); }); }
private void UpdateFlatFileForConfigStreamWriter(LoggingConfiguration loggingConfiguration) { // Trace Listeners StreamWriter writer = new StreamWriter(Path.Combine(strPath, "FlatFileStreamWriter.log")); FlatFileTraceListener flatFileTraceListener = new FlatFileTraceListener(writer); flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All); // Special Sources Configuration loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener); }
private void UpdateFlatFileForConfigFileStream(LoggingConfiguration loggingConfiguration) { // Trace Listeners FileStream stream = new FileStream(Path.Combine(strPath, "FlatFileFileStream.log"), FileMode.OpenOrCreate); FlatFileTraceListener flatFileTraceListener = new FlatFileTraceListener(stream); //var flatFileTraceListener = new FlatFileTraceListener(Path.Combine(strPath, "FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter); flatFileTraceListener.Filter = new EventTypeFilter(SourceLevels.All); // Special Sources Configuration loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(flatFileTraceListener); }
public LoggingViewModel() { var logFormatter = new TextFormatter(); var flatFileTraceListener = new FlatFileTraceListener("log.hblog", "-------------------------", "-------------------------", logFormatter); var config = new LoggingConfiguration(); config.AddLogSource("Hummingbird", SourceLevels.All, true).AddTraceListener(flatFileTraceListener); Logger = new LogWriter(config); }
/// <summary> /// Static constructor /// </summary> static Logger() { string LogFile = ConfigurationManager.AppSettings["LogFile"].ToString(); // a static constructor works because changing the web.config restarts the appliaction. // this defaults to the namespace WebForms even when used in another application so it's not used //string LogFile=Properties.Settings.Default.LogFile; if (ConfigurationManager.AppSettings["LogErr"].ToString().ToLower() == "yes") { LogErr = true; } if (ConfigurationManager.AppSettings["LogInfo"].ToString().ToLower() == "yes") { LogInfo = true; } // formatter TextFormatter formatter = new TextFormatter("[{timestamp(local)}] [{machine}] {category} \t: {message}"); // listeners FlatFileTraceListener logFileListener = new FlatFileTraceListener(LogFile, "", "", formatter); RollingFlatFileTraceListener rollingFlatFileListener = new RollingFlatFileTraceListener(LogFile, "", "", formatter, 1000, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.Day); //uncomment if an event log is needed //FormattedEventLogTraceListener logEventListener = new FormattedEventLogTraceListener("Enterprise Library Logging",formatter); // Sources LogSource mainLogSource = new LogSource("MainLogSource", SourceLevels.All); //mainLogSource.Listeners.Add(logFileListener);//regular flat file mainLogSource.Listeners.Add(rollingFlatFileListener); //uncomment if an event log is needed //LogSource errorLogSource = new LogSource("ErrorLogSource",SourceLevels.Error); //errorLogSource.Listeners.Add(logEventListener); // empty source LogSource nonExistantLogSource = new LogSource("Empty"); //non matching category. // trace sources IDictionary <string, LogSource> traceSources = new Dictionary <string, LogSource>(); //traceSources.Add("Error",errorLogSource);//uncomment if an event log is needed traceSources.Add("Warning", mainLogSource); traceSources.Add("Information", mainLogSource); // log writer writer = new LogWriter(new ILogFilter[0], traceSources, mainLogSource, nonExistantLogSource, mainLogSource, "Error", false, true); //writer = new LogWriter(new ILogFilter[0],traceSources,mainLogSource,nonExistantLogSource, //errorLogSource,"Error",false,true);//uncomment if 'internal' error are to be logged to an event log is needed }
static void Main(string[] args) { TextFormatter briefFormatter = new TextFormatter(); var flatFileTraceListerner = new FlatFileTraceListener(@"C:\temp\xxx.log", "-------------------------------", "-------------------------------", briefFormatter); var config = new LoggingConfiguration(); config.AddLogSource("my_log", System.Diagnostics.SourceLevels.All, true).AddTraceListener(flatFileTraceListerner); LogWriter logger = new LogWriter(config); }
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache) { FlatFileTraceListenerData castedObjectConfiguration = (FlatFileTraceListenerData)objectConfiguration; ILogFormatter formatter = GetFormatter(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache); TraceListener createdObject = new FlatFileTraceListener( castedObjectConfiguration.FileName, castedObjectConfiguration.Header, castedObjectConfiguration.Footer, formatter); return(createdObject); }
public void MessageIsWrittenWhenUsingJsonFormatterWithFlatFileTraceListener() { this.fileNameWithoutExtension = Guid.NewGuid().ToString(); this.fileName = this.fileNameWithoutExtension + JsonLogFormatterFixture.Extension; using (FlatFileTraceListener tracelistener = new FlatFileTraceListener(this.fileName, null, null, new JsonLogFormatter(JsonFormatting.Indented))) { tracelistener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); tracelistener.Dispose(); Assert.IsTrue(File.Exists(this.fileName)); string strLog = LogFileReader.ReadFileWithoutLock(this.fileName); StringAssert.Contains(strLog, "source Error: 1 : This is a test\r\n"); } }
private static LoggingConfiguration BuildProgrammaticConfig() { var formatter = new TextFormatter(); var flatFileTraceListener = new FlatFileTraceListener( "log.txt", "----------------------------------------", "----------------------------------------", formatter); var config = new LoggingConfiguration(); config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(flatFileTraceListener); config.IsTracingEnabled = true; return(config); }
public void ListenerWithHeaderAndFooterWillUseFormatterIfExists() { File.Delete("tracewithheaderandfooter.log"); FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfooter.log", "--------header------", "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY")); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All); source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null)); listener.Dispose(); string strFileContents = GetFileContents("tracewithheaderandfooter.log"); Assert.AreEqual("--------header------" + Environment.NewLine + "DUMMY" + Environment.NewLine + "DUMMY" + Environment.NewLine + "=======footer===========" + Environment.NewLine, strFileContents); }
public void TraceListenerIsSingletonInContainer() { FormatterData data = new TextFormatterData("formattername", "template"); loggingSettings.Formatters.Add(data); TraceListenerData traceListenerData = new FlatFileTraceListenerData("name", "filename.log", "formattername"); loggingSettings.TraceListeners.Add(traceListenerData); container.AddExtension(new LoggingBlockExtension()); FlatFileTraceListener createdObject1 = (FlatFileTraceListener)container.Resolve <TraceListener>("name"); FlatFileTraceListener createdObject2 = (FlatFileTraceListener)container.Resolve <TraceListener>("name"); Assert.AreSame(createdObject1, createdObject2); }
private static void ConfigureSimpleLogging(LoggingConfiguration config) { // Create a briefformatter object to write the log out 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}"); // Create a txt file listener and point to the formatter var flatFileTraceListener = new FlatFileTraceListener( @"C:\Temp\FlatFile.log", "----------------------------------------", "----------------------------------------", briefFormatter); // Tell the config to use this (Category = Simple) config.AddLogSource("Simple", SourceLevels.All, true) .AddTraceListener(flatFileTraceListener); }
private void ConfigureLogging() { // Formatter TextFormatter fm = new TextFormatter(); var flatFileTraceListener = new FlatFileTraceListener(@"trace.log", "----------------------------------------", "----------------------------------------", fm); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource("General", SourceLevels.All, true).AddTraceListener(flatFileTraceListener); config.IsTracingEnabled = true; config.SpecialSources.AllEvents.AddTraceListener(flatFileTraceListener); Logger.SetLogWriter(new LogWriter(config)); }
public void ListenerWillFallbackToTraceEntryToStringIfFormatterDoesNotExists() { LogEntry testLogEntry = new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null); StreamWriter writer = new StreamWriter("trace.log"); FlatFileTraceListener listener = new FlatFileTraceListener(writer); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All); source.TraceData(TraceEventType.Error, 0, testLogEntry); listener.Dispose(); string strFileContents = GetFileContents("trace.log"); string testLogEntryAsString = testLogEntry.ToString(); Assert.IsTrue(-1 != strFileContents.IndexOf(testLogEntryAsString)); }
private static LoggingConfiguration BuildProgrammaticConfig() { // Formatter 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}"); // Trace Listeners var flatFileTraceListener = new FlatFileTraceListener(@"C:\Temp\trace.log", "----------------------------------------", "----------------------------------------", formatter); var asyncTraceListener = new AsynchronousTraceListenerWrapper(flatFileTraceListener); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource(Category.Trace, SourceLevels.ActivityTracing, true).AddAsynchronousTraceListener(asyncTraceListener); config.IsTracingEnabled = true; return(config); }
private static LoggingConfiguration BuildLoggingConfig() { // Formatters TextFormatter formatter = new TextFormatter( @"Timestamp: {timestamp}{newline} Message: {message}{newline}Category: {category}{newline} Priority: {priority}{newline}EventId: {eventid}{newline} Severity: {severity}{newline}Title:{title}{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})}"); // Listeners var flatFileTraceListener = new FlatFileTraceListener( @"C:\Temp\Puzzler.log", "----------------------------------------", "----------------------------------------", formatter); var eventLog = new EventLog("Application", ".", "Enterprise Library Logging"); var eventLogTraceListener = new FormattedEventLogTraceListener(eventLog); // Build Configuration var config = new LoggingConfiguration(); config.AddLogSource("General", SourceLevels.All, true) .AddTraceListener(eventLogTraceListener); config.LogSources["General"] .AddTraceListener(flatFileTraceListener); // Special Sources Configuration config.SpecialSources.LoggingErrorsAndWarnings .AddTraceListener(eventLogTraceListener); return(config); }
public void FlatFileListenerReplacedInexistingEnviromentVariables() { string fileName = @"a\%FOO%\%MY_VARIABLE%\foo.log"; FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); string fileNameFromListener = string.Empty; string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(fileName); string expectedFileName = Path.GetFileName(expandedFileName); bool result = File.Exists(expandedFileName); Assert.IsTrue(result); File.Delete(expandedFileName); }
public void FlatFileTraceListenerMultipleWrites() { File.Delete("tracewithheaderandfooter.log"); string header = "--------header------"; int numberOfWrites = 4; FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfooter.log", header, "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY")); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", SourceLevels.All); source.Listeners.Add(listener); for (int writeLoop = 0; writeLoop < numberOfWrites; writeLoop++) source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null)); source.Dispose(); StreamReader reader = new StreamReader("tracewithheaderandfooter.log"); int headersFound = NumberOfItems("tracewithheaderandfooter.log", header); Assert.AreEqual(numberOfWrites,headersFound); }
public void FlatFileListenerReplacedEnviromentVariablesWillFallBackIfNotPrivilegesToRead() { string environmentVariable = "%USERPROFILE%"; string fileName = Path.Combine(environmentVariable, "foo.log"); EnvironmentPermission denyPermission = new EnvironmentPermission(PermissionState.Unrestricted); denyPermission.Deny(); try { FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); } finally { EnvironmentPermission.RevertAll(); } Assert.Fail("Permission was not denied."); }
public void CanCreateTraceListenerWithReferenceToFormatter() { FormatterData data = new TextFormatterData("formattername", "template"); loggingSettings.Formatters.Add(data); TraceListenerData traceListenerData = new FlatFileTraceListenerData("name", "filename.log", "formattername"); traceListenerData.Filter = SourceLevels.Critical; traceListenerData.TraceOutputOptions = TraceOptions.ProcessId; loggingSettings.TraceListeners.Add(traceListenerData); container.AddExtension(new LoggingBlockExtension()); FlatFileTraceListener createdObject = (FlatFileTraceListener)container.Resolve <TraceListener>("name"); Assert.IsNotNull(createdObject); Assert.AreEqual("name", createdObject.Name); Assert.AreEqual(SourceLevels.Critical, ((EventTypeFilter)createdObject.Filter).EventType); Assert.AreEqual(TraceOptions.ProcessId, createdObject.TraceOutputOptions); Assert.IsNotNull(createdObject.Formatter); Assert.AreEqual("template", ((TextFormatter)createdObject.Formatter).Template); }
public void FlatFileTraceListenerMultipleWrites() { File.Delete("tracewithheaderandfootermultiplewrites.log"); string header = "--------header------"; int numberOfWrites = 4; FlatFileTraceListener listener = new FlatFileTraceListener("tracewithheaderandfootermultiplewrites.log", header, "=======footer===========", new TextFormatter("DUMMY{newline}DUMMY")); // need to go through the source to get a TraceEventCache LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All); for (int writeLoop = 0; writeLoop < numberOfWrites; writeLoop++) { source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null)); } listener.Dispose(); StreamReader reader = new StreamReader("tracewithheaderandfootermultiplewrites.log"); int headersFound = NumberOfItems("tracewithheaderandfootermultiplewrites.log", header); Assert.AreEqual(numberOfWrites, headersFound); }
public void FlatFileListenerReplacedInexistingEnviromentVariables() { string fileName = @"%FOO%\%MY_VARIABLE%\foo.log"; FlatFileTraceListener listener = new FlatFileTraceListener(fileName); listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, "This is a test"); listener.Dispose(); string fileNameFromListener = string.Empty; string expandedFileName = EnvironmentHelper.ReplaceEnvironmentVariables(fileName); string expectedFileName = Path.GetFileName(expandedFileName); bool result = File.Exists(expandedFileName); Assert.IsTrue(result); File.Delete(expandedFileName); Assert.AreEqual(expectedFileName, expandedFileName); }