internal static bool SaveChanges(RollingFlatFileTraceListenerSetting setting, ConfigurationElement sourceElement) { RollingFlatFileTraceListenerData element = (RollingFlatFileTraceListenerData)sourceElement; element.FileName = setting.FileName; element.Footer = setting.Footer; element.Formatter = setting.Formatter; element.Header = setting.Header; element.RollFileExistsBehavior = ParseHelper.ParseEnum <RollFileExistsBehavior>(setting.RollFileExistsBehavior, false); element.RollInterval = ParseHelper.ParseEnum <RollInterval>(setting.RollInterval, false); element.RollSizeKB = setting.RollSizeKB; element.TimeStampPattern = setting.TimeStampPattern; element.TraceOutputOptions = ParseHelper.ParseEnum <TraceOptions>(setting.TraceOutputOptions, false); SourceLevels filter; if (ParseHelper.TryParseEnum(setting.Filter, out filter)) { element.Filter = filter; } return(true); }
public void ListenerDataIsCreatedCorrectly() { RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData( "listener", "log.txt", "header", "footer", 10, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.Minute, TraceOptions.DateTime, "SimpleTextFormat"); Assert.AreSame(typeof(RollingFlatFileTraceListener), listenerData.Type); Assert.AreSame(typeof(RollingFlatFileTraceListenerData), listenerData.ListenerDataType); Assert.AreEqual("listener", listenerData.Name); Assert.AreEqual("log.txt", listenerData.FileName); Assert.AreEqual(10, listenerData.RollSizeKB); Assert.AreEqual("yyyy-MM-dd", listenerData.TimeStampPattern); Assert.AreEqual(RollFileExistsBehavior.Increment, listenerData.RollFileExistsBehavior); Assert.AreEqual(RollInterval.Minute, listenerData.RollInterval); Assert.AreEqual(TraceOptions.DateTime, listenerData.TraceOutputOptions); Assert.AreEqual("SimpleTextFormat", listenerData.Formatter); Assert.AreEqual("header", listenerData.Header); Assert.AreEqual("footer", listenerData.Footer); }
/// <summary> /// Configures the Rolling Flat File trace listener with the specified file name and parameters. /// </summary> /// <param name="fileName">The log file name.</param> /// <param name="maxArchivedFiles">The maximum number of archived files to keep.</param> /// <param name="rollSizeKB">The maximum file size (KB) before rolling.</param> public void ConfigureRollingFlatFileTraceListener(string fileName, int maxArchivedFiles, int rollSizeKB) { if (this.loggingSettings.TraceListeners.Contains(Resources.RollingFlatFileTraceListenerName)) { RollingFlatFileTraceListenerData listenerData = this.loggingSettings.TraceListeners.Get(Resources.RollingFlatFileTraceListenerName) as RollingFlatFileTraceListenerData; if (listenerData != null) { if (!String.IsNullOrEmpty(fileName)) { string filePath = Path.GetDirectoryName(fileName); if (String.IsNullOrEmpty(filePath)) { filePath = Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); } listenerData.FileName = Path.Combine(filePath, Path.GetFileName(fileName)); } if (maxArchivedFiles > 0) { listenerData.MaxArchivedFiles = maxArchivedFiles; } if (rollSizeKB > 0) { listenerData.RollSizeKB = rollSizeKB; } } } }
public void CanCreatePoliciesForRollingFlatFileTraceListener() { RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData( "listener", Path.Combine(Environment.CurrentDirectory, "test.log"), "header", "footer", 100, "pattern", RollFileExistsBehavior.Overwrite, RollInterval.Midnight, TraceOptions.Callstack | TraceOptions.ProcessId, ""); listenerData.Filter = SourceLevels.Error; loggingSettings.TraceListeners.Add(listenerData); using (var container = CreateContainer()) { RollingFlatFileTraceListener createdObject = (RollingFlatFileTraceListener)((ReconfigurableTraceListenerWrapper)container.Resolve <TraceListener>("listener")).InnerTraceListener; Assert.IsNotNull(createdObject); Assert.AreEqual(listenerData.TraceOutputOptions, createdObject.TraceOutputOptions); Assert.IsNotNull(createdObject.Filter); Assert.IsInstanceOfType(createdObject.Filter, typeof(EventTypeFilter)); Assert.AreEqual(listenerData.Filter, ((EventTypeFilter)createdObject.Filter).EventType); Assert.IsNull(createdObject.Formatter); Assert.AreEqual(listenerData.FileName, ((FileStream)((StreamWriter)createdObject.Writer).BaseStream).Name); } }
public void CanDeserializeSerializedConfiguration() { string name = "some name"; string fileName = "some filename"; string timesTampPattern = "yyyy-MM-dd"; int rollSizeKB = 10; RollFileExistsBehavior rollFileExistsBehavior = RollFileExistsBehavior.Increment; RollInterval rollInterval = RollInterval.Hour; TraceOptions traceOptions = TraceOptions.LogicalOperationStack; string SimpleTextFormat = "SimpleTextFormat"; string header = "header"; string footer = "footer"; int maxArchivedFiles = 10; RollingFlatFileTraceListenerData data = new RollingFlatFileTraceListenerData( name, fileName, header, footer, rollSizeKB, timesTampPattern, rollFileExistsBehavior, rollInterval, traceOptions, SimpleTextFormat, SourceLevels.Critical); data.TraceOutputOptions = traceOptions; data.MaxArchivedFiles = maxArchivedFiles; LoggingSettings settings = new LoggingSettings(); settings.TraceListeners.Add(data); IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>(); sections[LoggingSettings.SectionName] = settings; IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections); LoggingSettings roSettigs = (LoggingSettings)configurationSource.GetSection(LoggingSettings.SectionName); Assert.AreEqual(1, roSettigs.TraceListeners.Count); Assert.IsNotNull(roSettigs.TraceListeners.Get(name)); Assert.AreEqual(TraceOptions.LogicalOperationStack, roSettigs.TraceListeners.Get(name).TraceOutputOptions); Assert.AreEqual(SourceLevels.Critical, roSettigs.TraceListeners.Get(name).Filter); Assert.AreSame(typeof(RollingFlatFileTraceListenerData), roSettigs.TraceListeners.Get(name).GetType()); Assert.AreSame(typeof(RollingFlatFileTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType); Assert.AreSame(typeof(RollingFlatFileTraceListener), roSettigs.TraceListeners.Get(name).Type); Assert.AreEqual(fileName, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).FileName); Assert.AreEqual(timesTampPattern, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).TimeStampPattern); Assert.AreEqual(rollSizeKB, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).RollSizeKB); Assert.AreEqual(rollFileExistsBehavior, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).RollFileExistsBehavior); Assert.AreEqual(rollInterval, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).RollInterval); Assert.AreEqual("SimpleTextFormat", ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter); Assert.AreEqual(header, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Header); Assert.AreEqual(footer, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).Footer); Assert.AreEqual(maxArchivedFiles, ((RollingFlatFileTraceListenerData)roSettigs.TraceListeners.Get(name)).MaxArchivedFiles); }
public void SetUp() { provider = new RollingFlatFileTraceListenerDataManageabilityProvider(); machineKey = new MockRegistryKey(true); userKey = new MockRegistryKey(true); wmiSettings = new List <ConfigurationSetting>(); configurationObject = new RollingFlatFileTraceListenerData(); }
public void SetUp() { provider = new RollingFlatFileTraceListenerDataManageabilityProvider(); machineKey = new MockRegistryKey(true); machineOptionsKey = new MockRegistryKey(false); userKey = new MockRegistryKey(true); userOptionsKey = new MockRegistryKey(false); configurationObject = new RollingFlatFileTraceListenerData(); }
public SendToRollingFileTraceListenerBuilder(ILoggingConfigurationSendTo context, string listenerName) : base(context) { rollingTraceListenerData = new RollingFlatFileTraceListenerData() { Name = listenerName }; base.AddTraceListenerToSettingsAndCategory(rollingTraceListenerData); }
public void CanCreateInstanceFromGivenConfiguration() { RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData("listener", "log.txt", "header", "footer", 10, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.Minute, TraceOptions.DateTime, "SimpleTextFormat"); MockLogObjectsHelper helper = new MockLogObjectsHelper(); helper.loggingSettings.Formatters.Add(new TextFormatterData("SimpleTextFormat", "foobar template")); TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, listenerData, helper.configurationSource, reflectionCache); Assert.IsNotNull(listener); Assert.AreEqual("listener", listener.Name); Assert.AreEqual(listener.GetType(), typeof(RollingFlatFileTraceListener)); }
public static void GenerateWmiObjects(RollingFlatFileTraceListenerData configurationObject, ICollection <ConfigurationSetting> wmiSettings) { wmiSettings.Add( new RollingFlatFileTraceListenerSetting(configurationObject, configurationObject.Name, configurationObject.FileName, configurationObject.Header, configurationObject.Footer, configurationObject.Formatter, configurationObject.RollFileExistsBehavior.ToString(), configurationObject.RollInterval.ToString(), configurationObject.RollSizeKB, configurationObject.TimeStampPattern, configurationObject.TraceOutputOptions.ToString(), configurationObject.Filter.ToString())); }
private RollingFlatFileTraceListenerData GetErrorListener() { var errorListener = new RollingFlatFileTraceListenerData(); errorListener.Name = ERROR; errorListener.FileName = ErrorFileName; errorListener.RollSizeKB = 1024; errorListener.RollInterval = RollInterval.Day; errorListener.RollFileExistsBehavior = RollFileExistsBehavior.Increment; errorListener.Type = typeof(RollingFlatFileTraceListener); errorListener.ListenerDataType = typeof(RollingFlatFileTraceListenerData); errorListener.Filter = SourceLevels.Error; errorListener.TraceOutputOptions = TraceOptions.None; errorListener.Formatter = "MsgFormatter"; errorListener.Header = "---------------Header---------------"; errorListener.Footer = "-----------------Footer----------------"; return(errorListener); }
private RollingFlatFileTraceListenerData GetVerboseListener() { var verboseListener = new RollingFlatFileTraceListenerData(); verboseListener.Name = VERBOSE; verboseListener.FileName = VerboseFileName; verboseListener.RollSizeKB = 1024; verboseListener.RollInterval = RollInterval.Day; verboseListener.RollFileExistsBehavior = RollFileExistsBehavior.Increment; verboseListener.Type = typeof(RollingFlatFileTraceListener); verboseListener.ListenerDataType = typeof(RollingFlatFileTraceListenerData); verboseListener.Filter = SourceLevels.Verbose; verboseListener.TraceOutputOptions = TraceOptions.None; verboseListener.Formatter = "MsgFormatter"; verboseListener.Header = "---------------Header---------------"; verboseListener.Footer = "-----------------Footer----------------"; return(verboseListener); }
private RollingFlatFileTraceListenerData GetWarningListener() { var warningListener = new RollingFlatFileTraceListenerData(); warningListener.Name = WARNING; warningListener.FileName = WarningFileName; warningListener.RollSizeKB = 1024; warningListener.RollInterval = RollInterval.Day; warningListener.RollFileExistsBehavior = RollFileExistsBehavior.Increment; warningListener.Type = typeof(RollingFlatFileTraceListener); warningListener.ListenerDataType = typeof(RollingFlatFileTraceListenerData); warningListener.Filter = SourceLevels.Warning; warningListener.TraceOutputOptions = TraceOptions.None; warningListener.Formatter = "MsgFormatter"; warningListener.Header = "---------------Header---------------"; warningListener.Footer = "-----------------Footer----------------"; return(warningListener); }
private RollingFlatFileTraceListenerData GetPerformanceListener() { var performanceListener = new RollingFlatFileTraceListenerData(); performanceListener.Name = PERFORMANCE; performanceListener.FileName = PerformanceFileName; performanceListener.RollSizeKB = 1024; performanceListener.RollInterval = RollInterval.Day; performanceListener.RollFileExistsBehavior = RollFileExistsBehavior.Increment; performanceListener.Type = typeof(RollingFlatFileTraceListener); performanceListener.ListenerDataType = typeof(RollingFlatFileTraceListenerData); performanceListener.Filter = SourceLevels.ActivityTracing; performanceListener.TraceOutputOptions = TraceOptions.None; performanceListener.Formatter = "PerformanceFormatter"; performanceListener.Header = "---------------Header---------------"; performanceListener.Footer = "-----------------Footer----------------"; return(performanceListener); }
private RollingFlatFileTraceListenerData GetInfoListener() { var infoListener = new RollingFlatFileTraceListenerData(); infoListener.Name = INFO; infoListener.FileName = InfoFileName; infoListener.RollSizeKB = 1024; infoListener.RollInterval = RollInterval.Day; infoListener.RollFileExistsBehavior = RollFileExistsBehavior.Increment; infoListener.Type = typeof(RollingFlatFileTraceListener); infoListener.ListenerDataType = typeof(RollingFlatFileTraceListenerData); infoListener.Filter = SourceLevels.Information; infoListener.TraceOutputOptions = TraceOptions.None; infoListener.Formatter = "MsgFormatter"; infoListener.Header = "---------------Header---------------"; infoListener.Footer = "-----------------Footer----------------"; return(infoListener); }
public void SavesChangesToConfigurationObject() { RollingFlatFileTraceListenerData sourceElement = new RollingFlatFileTraceListenerData(); sourceElement.FileName = "file name"; sourceElement.Footer = "footer"; sourceElement.Formatter = "formatter"; sourceElement.Header = "header"; sourceElement.RollFileExistsBehavior = RollFileExistsBehavior.Increment; sourceElement.RollInterval = RollInterval.Day; sourceElement.RollSizeKB = 100; sourceElement.TimeStampPattern = "XXXXX"; sourceElement.TraceOutputOptions = TraceOptions.ProcessId; sourceElement.Filter = SourceLevels.Information; List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1); RollingFlatFileTraceListenerDataWmiMapper.GenerateWmiObjects(sourceElement, settings); Assert.AreEqual(1, settings.Count); RollingFlatFileTraceListenerSetting setting = settings[0] as RollingFlatFileTraceListenerSetting; Assert.IsNotNull(setting); setting.FileName = "updated file name"; setting.Footer = "updated footer"; setting.Formatter = "updated formatter"; setting.Header = "updated header"; setting.RollFileExistsBehavior = RollFileExistsBehavior.Overwrite.ToString(); setting.RollInterval = RollInterval.Hour.ToString(); setting.RollSizeKB = 200; setting.TimeStampPattern = "ZZZZZZ"; setting.Filter = SourceLevels.All.ToString(); setting.TraceOutputOptions = TraceOptions.ThreadId.ToString(); setting.Commit(); Assert.AreEqual("updated file name", sourceElement.FileName); Assert.AreEqual("updated footer", sourceElement.Footer); Assert.AreEqual("updated formatter", sourceElement.Formatter); Assert.AreEqual("updated header", sourceElement.Header); Assert.AreEqual(RollFileExistsBehavior.Overwrite, sourceElement.RollFileExistsBehavior); Assert.AreEqual(RollInterval.Hour, sourceElement.RollInterval); Assert.AreEqual(200, sourceElement.RollSizeKB); Assert.AreEqual("ZZZZZZ", sourceElement.TimeStampPattern); Assert.AreEqual(SourceLevels.All, sourceElement.Filter); Assert.AreEqual(TraceOptions.ThreadId, sourceElement.TraceOutputOptions); }
/// <summary> /// Gets the logging output from the app.config (loggingConfiguration section) /// </summary> private static void GetLoggingSettings() { IConfigurationSource configSource = Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ConfigurationSourceFactory.Create(); LoggingSettings logSettings = LoggingSettings.GetLoggingSettings(configSource); TraceListenerDataCollection dataCollection = logSettings.TraceListeners; if (dataCollection.Count == 0) { return; } TraceListenerData traceListenerData = dataCollection.Get(0); if (traceListenerData is RollingFlatFileTraceListenerData) { RollingFlatFileTraceListenerData tld = (RollingFlatFileTraceListenerData)traceListenerData; loggingOutputFileName = tld.FileName; } }
public void ConfigValidFileTest() { RollingFlatFileTraceListenerData fileTraceListener = LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("Rolling Flat File Trace Listener") as RollingFlatFileTraceListenerData; string filePath = fileTraceListener == null ? string.Empty : fileTraceListener.FileName; if (File.Exists(filePath)) { File.Delete(filePath); } string message = "This is Test Message"; LogEntry logEntry = new LogEntry() { Message = message, Severity = TraceEventType.Critical }; Logger.SetLogWriter(new LogWriterFactory().Create()); Logger.Write(logEntry); Logger.Reset(); Assert.IsTrue(File.ReadAllText(filePath).Contains(message)); }
public void RollingFlatFileTraceListenerNodeDataTest() { string name = "some name"; string fileName = "some filename"; string timesTampPattern = "yyyy-MM-dd"; int rollSizeKB = 10; RollFileExistsBehavior rollFileExistsBehavior = RollFileExistsBehavior.Increment; RollInterval rollInterval = RollInterval.Hour; TraceOptions traceOutputOptions = TraceOptions.Callstack; SourceLevels filter = SourceLevels.Critical; string header = "header"; string footer = "footer"; RollingFlatFileTraceListenerData rollingFlatFileTraceListenerData = new RollingFlatFileTraceListenerData(); rollingFlatFileTraceListenerData.Name = name; rollingFlatFileTraceListenerData.FileName = fileName; rollingFlatFileTraceListenerData.TimeStampPattern = timesTampPattern; rollingFlatFileTraceListenerData.RollSizeKB = rollSizeKB; rollingFlatFileTraceListenerData.RollFileExistsBehavior = rollFileExistsBehavior; rollingFlatFileTraceListenerData.RollInterval = rollInterval; rollingFlatFileTraceListenerData.TraceOutputOptions = traceOutputOptions; rollingFlatFileTraceListenerData.Filter = filter; rollingFlatFileTraceListenerData.Header = header; rollingFlatFileTraceListenerData.Footer = footer; RollingTraceListenerNode rollingFlatFileTraceListenerNode = new RollingTraceListenerNode(rollingFlatFileTraceListenerData); ApplicationNode.AddNode(rollingFlatFileTraceListenerNode); Assert.AreEqual(name, rollingFlatFileTraceListenerNode.Name); Assert.AreEqual(fileName, rollingFlatFileTraceListenerNode.FileName); Assert.AreEqual(timesTampPattern, rollingFlatFileTraceListenerNode.TimeStampPattern); Assert.AreEqual(rollSizeKB, rollingFlatFileTraceListenerNode.RollSizeKB); Assert.AreEqual(rollFileExistsBehavior, rollingFlatFileTraceListenerNode.RollFileExistsBehavior); Assert.AreEqual(rollInterval, rollingFlatFileTraceListenerNode.RollInterval); Assert.AreEqual(traceOutputOptions, rollingFlatFileTraceListenerNode.TraceOutputOptions); Assert.AreEqual(filter, rollingFlatFileTraceListenerNode.Filter); Assert.AreEqual(header, rollingFlatFileTraceListenerNode.Header); Assert.AreEqual(footer, rollingFlatFileTraceListenerNode.Footer); }
public RollingFlatFileTraceListenerSetting(RollingFlatFileTraceListenerData sourceElement, string name, string fileName, string header, string footer, string formatter, string rollFileExistsBehavior, string rollInterval, int rollSizeKB, string timeStampPattern, string traceOutputOptions, string filter) : base(sourceElement, name, traceOutputOptions, filter) { this.fileName = fileName; this.header = header; this.footer = footer; this.formatter = formatter; this.rollFileExistsBehavior = rollFileExistsBehavior; this.rollInterval = rollInterval; this.rollSizeKB = rollSizeKB; this.timeStampPattern = timeStampPattern; }
public void CanCreatePoliciesForRollingFlatFileTraceListenerWithFormatter() { RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData( "listener", Path.Combine(Environment.CurrentDirectory, "test.log"), "header", "footer", 100, "pattern", RollFileExistsBehavior.Overwrite, RollInterval.Midnight, TraceOptions.Callstack | TraceOptions.ProcessId, "formatter"); listenerData.Filter = SourceLevels.Error; loggingSettings.TraceListeners.Add(listenerData); FormatterData formatterData = new TextFormatterData("formatter", "template"); loggingSettings.Formatters.Add(formatterData); container.AddExtension(new LoggingBlockExtension()); RollingFlatFileTraceListener createdObject = (RollingFlatFileTraceListener)container.Resolve <TraceListener>("listener"); Assert.IsNotNull(createdObject); Assert.AreEqual("listener", createdObject.Name); Assert.AreEqual(listenerData.TraceOutputOptions, createdObject.TraceOutputOptions); Assert.IsNotNull(createdObject.Filter); Assert.IsInstanceOfType(createdObject.Filter, typeof(EventTypeFilter)); Assert.AreEqual(listenerData.Filter, ((EventTypeFilter)createdObject.Filter).EventType); Assert.IsNotNull(createdObject.Formatter); Assert.AreSame(typeof(TextFormatter), createdObject.Formatter.GetType()); Assert.AreEqual("template", ((TextFormatter)createdObject.Formatter).Template); Assert.AreEqual(listenerData.FileName, ((FileStream)((StreamWriter)createdObject.Writer).BaseStream).Name); }
private void ApplyDefaultTraceListener() { if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDebugTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDebugTraceListenerName)) { CustomTraceListenerData listenerData = new CustomTraceListenerData(); listenerData.Formatter = Resources.TraceLogTextFormatterName; listenerData.Type = typeof(FormattedDebugTraceListener); listenerData.Name = Resources.FormattedDebugTraceListenerName; listenerData.TraceOutputOptions = TraceOptions.None; listenerData.Filter = SourceLevels.All; this.loggingSettings.TraceListeners.Add(listenerData); } } } if (!this.loggingSettings.TraceListeners.Contains(Resources.TraceLogTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.TraceLogTraceListenerName)) { CustomTraceListenerData listenerData = new CustomTraceListenerData(); listenerData.Formatter = Resources.TraceLogTextFormatterName; listenerData.Type = typeof(FormattedTextWriterTraceListener); listenerData.Name = Resources.TraceLogTraceListenerName; listenerData.TraceOutputOptions = TraceOptions.None; listenerData.Filter = SourceLevels.All; this.loggingSettings.TraceListeners.Add(listenerData); } } } if (!this.loggingSettings.TraceListeners.Contains(Resources.EventLogTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.EventLogTraceListenerName)) { FormattedEventLogTraceListenerData listenerData = new FormattedEventLogTraceListenerData(); listenerData.Formatter = Resources.EventLogTextFormatterName; listenerData.Type = typeof(FormattedEventLogTraceListener); listenerData.Name = Resources.EventLogTraceListenerName; listenerData.MachineName = "."; listenerData.Source = AppDomain.CurrentDomain.SetupInformation.ApplicationName; listenerData.Log = Resources.DefaultEventLogTraceListenerLogName; this.loggingSettings.TraceListeners.Add(listenerData); } } } if (!this.loggingSettings.TraceListeners.Contains(Resources.RollingFlatFileTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.RollingFlatFileTraceListenerName)) { RollingFlatFileTraceListenerData listenerData = new RollingFlatFileTraceListenerData(); listenerData.Name = Resources.RollingFlatFileTraceListenerName; listenerData.Formatter = Resources.TraceLogTextFormatterName; listenerData.FileName = Path.ChangeExtension(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, ".log"); listenerData.Footer = String.Empty; listenerData.Header = String.Empty; listenerData.TimeStampPattern = Resources.RollingFlatFileTraceListenerTimeStampPattern; listenerData.MaxArchivedFiles = 10; listenerData.RollFileExistsBehavior = RollFileExistsBehavior.Increment; listenerData.RollSizeKB = 10240; this.loggingSettings.TraceListeners.Add(listenerData); } } } if (!this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.EmailTraceListenerName)) { EmailTraceListenerData listenerData = new EmailTraceListenerData(); listenerData.Name = Resources.EmailTraceListenerName; listenerData.AuthenticationMode = EmailAuthenticationMode.UserNameAndPassword; listenerData.Formatter = Resources.EventLogTextFormatterName; listenerData.SmtpPort = 25; this.loggingSettings.TraceListeners.Add(listenerData); } } } if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDatabaseTraceListenerName)) { lock (this.listenerLock) { if (!this.loggingSettings.TraceListeners.Contains(Resources.FormattedDatabaseTraceListenerName)) { FormattedDatabaseTraceListenerData listenerData = new FormattedDatabaseTraceListenerData(); listenerData.Name = Resources.FormattedDatabaseTraceListenerName; listenerData.AddCategoryStoredProcName = SqlCommandResources.AddCategoryStoredProcName; listenerData.WriteLogStoredProcName = SqlCommandResources.WriteLogStoredProcName; this.loggingSettings.TraceListeners.Add(listenerData); } } } }
public void WhenCreatingInstanceUsingDefaultContructor_ThenListenerDataTypeIsSet() { var listener = new RollingFlatFileTraceListenerData(); Assert.AreEqual(typeof(RollingFlatFileTraceListenerData), listener.ListenerDataType); }