public void CanCreatePoliciesForProviderWithFormatter()
{
FormattedDatabaseTraceListenerData listenerData
= new FormattedDatabaseTraceListenerData("listener", "write", "add", "database", "formatter");
listenerData.TraceOutputOptions = TraceOptions.Callstack | TraceOptions.ProcessId;
listenerData.Filter = SourceLevels.Error;
loggingSettings.TraceListeners.Add(listenerData);
FormatterData formatterData = new TextFormatterData("formatter", "template");
loggingSettings.Formatters.Add(formatterData);
connectionStringsSection.ConnectionStrings.Add(
new ConnectionStringSettings("database", "foo=bar;", "System.Data.SqlClient"));
using (var container = CreateContainer())
{
FormattedDatabaseTraceListener createdObject =
(FormattedDatabaseTraceListener)container.Resolve <TraceListener>("listener\u200cimplementation");
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.IsNotNull(createdObject.Formatter);
Assert.AreSame(typeof(TextFormatter), createdObject.Formatter.GetType());
Assert.AreEqual("template", ((TextFormatter)createdObject.Formatter).Template);
}
}
public void CanCreateInstanceFromGivenName()
{
FormattedDatabaseTraceListenerData listenerData =
new FormattedDatabaseTraceListenerData("listener", "WriteLog", "AddCategory", "LoggingDb", "formatter")
{
TraceOutputOptions = TraceOptions.Callstack | TraceOptions.DateTime,
Filter = SourceLevels.Information
};
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.Formatters.Add(new TextFormatterData("formatter", "some template"));
helper.loggingSettings.TraceListeners.Add(listenerData);
var listener = (FormattedDatabaseTraceListener)GetListener("listener", helper.configurationSource);
Assert.IsNotNull(listener);
Assert.AreEqual("listener", listener.Name);
Assert.AreEqual(TraceOptions.Callstack | TraceOptions.DateTime, listener.TraceOutputOptions);
Assert.IsNotNull(listener.Filter);
Assert.AreEqual(SourceLevels.Information, ((EventTypeFilter)listener.Filter).EventType);
Assert.AreEqual("WriteLog", listener.WriteLogStoredProcName);
Assert.AreEqual("AddCategory", listener.AddCategoryStoredProcName);
Assert.AreEqual(@"server=(localdb)\v11.0;database=Logging;Integrated Security=true", listener.Database.ConnectionString);
Assert.IsNotNull(listener.Formatter);
Assert.AreEqual(listener.Formatter.GetType(), typeof(TextFormatter));
Assert.AreEqual("some template", ((TextFormatter)listener.Formatter).Template);
}
public void CanDeserializeSerializedConfiguration()
{
string name = "name";
string write = "write";
string add = "add";
string database = "database";
string formatter = "formatter";
TraceListenerData data = new FormattedDatabaseTraceListenerData(name, write, add, database, formatter, TraceOptions.Callstack);
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.Callstack, roSettigs.TraceListeners.Get(name).TraceOutputOptions);
Assert.AreSame(typeof(FormattedDatabaseTraceListenerData), roSettigs.TraceListeners.Get(name).GetType());
Assert.AreSame(typeof(FormattedDatabaseTraceListenerData), roSettigs.TraceListeners.Get(name).ListenerDataType);
Assert.AreSame(typeof(FormattedDatabaseTraceListener), roSettigs.TraceListeners.Get(name).Type);
Assert.AreEqual(add, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).AddCategoryStoredProcName);
Assert.AreEqual(database, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).DatabaseInstanceName);
Assert.AreEqual(formatter, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).Formatter);
Assert.AreEqual(write, ((FormattedDatabaseTraceListenerData)roSettigs.TraceListeners.Get(name)).WriteLogStoredProcName);
}
public void SavesChangesToConfigurationObject()
{
FormattedDatabaseTraceListenerData sourceElement = new FormattedDatabaseTraceListenerData();
sourceElement.Filter = SourceLevels.Information;
sourceElement.Formatter = "formatter";
sourceElement.AddCategoryStoredProcName = "add sproc";
sourceElement.DatabaseInstanceName = "instance";
sourceElement.WriteLogStoredProcName = "write sproc";
sourceElement.TraceOutputOptions = TraceOptions.ThreadId;
List <ConfigurationSetting> settings = new List <ConfigurationSetting>(1);
FormattedDatabaseTraceListenerDataWmiMapper.GenerateWmiObjects(sourceElement, settings);
Assert.AreEqual(1, settings.Count);
FormattedDatabaseTraceListenerSetting setting = settings[0] as FormattedDatabaseTraceListenerSetting;
Assert.IsNotNull(setting);
setting.Filter = SourceLevels.All.ToString();
setting.Formatter = "updated formatter";
setting.AddCategoryStoredProcName = "new add sproc";
setting.DatabaseInstanceName = "updated instance";
setting.WriteLogStoredProcName = "new write sproc";
setting.TraceOutputOptions = TraceOptions.ProcessId.ToString();
setting.Commit();
Assert.AreEqual("updated formatter", sourceElement.Formatter);
Assert.AreEqual("new add sproc", sourceElement.AddCategoryStoredProcName);
Assert.AreEqual("updated instance", sourceElement.DatabaseInstanceName);
Assert.AreEqual("new write sproc", sourceElement.WriteLogStoredProcName);
Assert.AreEqual(SourceLevels.All, sourceElement.Filter);
Assert.AreEqual(TraceOptions.ProcessId, sourceElement.TraceOutputOptions);
}
public void SetUp()
{
provider = new ConfigurationElementManageabilityProviderWrapper(new FormattedDatabaseTraceListenerDataManageabilityProvider());
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
wmiSettings = new List <ConfigurationSetting>();
configurationObject = new FormattedDatabaseTraceListenerData();
}
public void Setup()
{
listenerData =
new FormattedDatabaseTraceListenerData("listener", "write", "add", "database", "formatter")
{
Filter = SourceLevels.Warning,
TraceOutputOptions = TraceOptions.Callstack | TraceOptions.DateTime
};
}
public void SetUp()
{
provider = new FormattedDatabaseTraceListenerDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
machineOptionsKey = new MockRegistryKey(false);
userKey = new MockRegistryKey(true);
userOptionsKey = new MockRegistryKey(false);
configurationObject = new FormattedDatabaseTraceListenerData();
}
public SendToDatabaseTraceListenerBuilder(ILoggingConfigurationSendTo context, string listenerName)
: base(context)
{
databaseTraceListener = new FormattedDatabaseTraceListenerData
{
Name = listenerName
};
base.AddTraceListenerToSettingsAndCategory(databaseTraceListener);
}
public void ListenerDataIsCreatedCorrectly()
{
FormattedDatabaseTraceListenerData listenerData = new FormattedDatabaseTraceListenerData("listener", "WriteLog", "AddCategory", "LoggingDb", "formatter");
Assert.AreSame(typeof(FormattedDatabaseTraceListener), listenerData.Type);
Assert.AreSame(typeof(FormattedDatabaseTraceListenerData), listenerData.ListenerDataType);
Assert.AreEqual("listener", listenerData.Name);
Assert.AreEqual("WriteLog", listenerData.WriteLogStoredProcName);
Assert.AreEqual("AddCategory", listenerData.AddCategoryStoredProcName);
Assert.AreEqual("LoggingDb", listenerData.DatabaseInstanceName);
Assert.AreEqual("formatter", listenerData.Formatter);
}
/// <summary>
/// Configures the database trace listener with custom database instance information.
/// </summary>
/// <param name="databaseInstanceName">The database instance name.</param>
public void ConfigureDatabaseTraceListener(string databaseInstanceName)
{
if (this.loggingSettings.TraceListeners.Contains(Resources.FormattedDatabaseTraceListenerName))
{
FormattedDatabaseTraceListenerData listenerData = this.loggingSettings.TraceListeners.Get(Resources.FormattedDatabaseTraceListenerName) as FormattedDatabaseTraceListenerData;
if (listenerData != null)
{
listenerData.DatabaseInstanceName = databaseInstanceName;
}
}
}
public static void GenerateWmiObjects(FormattedDatabaseTraceListenerData configurationObject,
ICollection <ConfigurationSetting> wmiSettings)
{
wmiSettings.Add(
new FormattedDatabaseTraceListenerSetting(configurationObject,
configurationObject.Name,
configurationObject.DatabaseInstanceName,
configurationObject.WriteLogStoredProcName,
configurationObject.AddCategoryStoredProcName,
configurationObject.Formatter,
configurationObject.TraceOutputOptions.ToString(),
configurationObject.Filter.ToString()));
}
/// <summary>
/// Initialize a new instance of the <see cref="LoggingDatabaseNode"/> class with a <see cref="FormattedDatabaseTraceListenerData"/> instance.
/// </summary>
/// <param name="traceListenerData">A <see cref="FormattedDatabaseTraceListenerData"/> instance</param>
public LoggingDatabaseNode(FormattedDatabaseTraceListenerData traceListenerData)
{
if (null == traceListenerData) throw new ArgumentNullException("traceListenerData");
Rename(traceListenerData.Name);
TraceOutputOptions = traceListenerData.TraceOutputOptions;
this.databaseName = traceListenerData.DatabaseInstanceName;
this.addCategoryStoredProcedure = traceListenerData.AddCategoryStoredProcName;
this.writeLogStoredProcedureName = traceListenerData.WriteLogStoredProcName;
this.formatterName = traceListenerData.Formatter;
this.onConnectionStringNodeRemoved = new EventHandler<ConfigurationNodeChangedEventArgs>(OnConnectionStringNodeRemoved);
this.onConnectionStringNodeRenamed = new EventHandler<ConfigurationNodeChangedEventArgs>(OnConnectionStringNodeRenamed);
}
public FormattedDatabaseTraceListenerSetting(FormattedDatabaseTraceListenerData sourceElement,
string name,
string databaseInstanceName,
string writeLogStoredProcName,
string addCategoryStoredProcName,
string formatter,
string traceOutputOptions,
string filter)
: base(sourceElement, name, traceOutputOptions, filter)
{
this.addCategoryStoredProcName = addCategoryStoredProcName;
this.databaseInstanceName = databaseInstanceName;
this.formatter = formatter;
this.writeLogStoredProcName = writeLogStoredProcName;
}
public LoggingDatabaseNode(FormattedDatabaseTraceListenerData traceListenerData)
{
if (null == traceListenerData)
{
throw new ArgumentNullException("traceListenerData");
}
Rename(traceListenerData.Name);
TraceOutputOptions = traceListenerData.TraceOutputOptions;
databaseName = traceListenerData.DatabaseInstanceName;
addCategoryStoredProcedure = traceListenerData.AddCategoryStoredProcName;
writeLogStoredProcedureName = traceListenerData.WriteLogStoredProcName;
formatterName = traceListenerData.Formatter;
onConnectionStringNodeRemoved = new EventHandler <ConfigurationNodeChangedEventArgs>(OnConnectionStringNodeRemoved);
onConnectionStringNodeRenamed = new EventHandler <ConfigurationNodeChangedEventArgs>(OnConnectionStringNodeRenamed);
}
public void CanCreateInstanceFromGivenName()
{
FormattedDatabaseTraceListenerData listenerData = new FormattedDatabaseTraceListenerData("listener", "WriteLog", "AddCategory", "LoggingDb", "formatter");
MockLogObjectsHelper helper = new MockLogObjectsHelper();
helper.loggingSettings.Formatters.Add(new TextFormatterData("formatter", "foobar template"));
helper.loggingSettings.TraceListeners.Add(listenerData);
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", helper.configurationSource, reflectionCache);
Assert.IsNotNull(listener);
Assert.AreEqual(listener.GetType(), typeof(FormattedDatabaseTraceListener));
Assert.IsNotNull(((FormattedDatabaseTraceListener)listener).Formatter);
Assert.AreEqual(((FormattedDatabaseTraceListener)listener).Formatter.GetType(), typeof(TextFormatter));
Assert.AreEqual("foobar template", ((TextFormatter)((FormattedDatabaseTraceListener)listener).Formatter).Template);
}
public void CanCreatePoliciesForProvider()
{
FormattedDatabaseTraceListenerData listenerData
= new FormattedDatabaseTraceListenerData("listener", "write", "add", "database", "");
listenerData.TraceOutputOptions = TraceOptions.Callstack | TraceOptions.ProcessId;
listenerData.Filter = SourceLevels.Error;
loggingSettings.TraceListeners.Add(listenerData);
connectionStringsSection.ConnectionStrings.Add(
new ConnectionStringSettings("database", "foo=bar;", "System.Data.SqlClient"));
container.AddExtension(new LoggingBlockExtension());
container.AddExtension(new DataAccessBlockExtension());
FormattedDatabaseTraceListener createdObject = (FormattedDatabaseTraceListener)container.Resolve <TraceListener>("listener");
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);
}
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);
}
}
}
}
