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