public void LogWithMultipleCategories()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
LogEntry logEntry = new LogEntry();
logEntry.Message = "message";
logEntry.Categories.Add("FormattedCategory");
logEntry.Categories.Add("DictionaryCategory");
logEntry.EventId = 123;
logEntry.Priority = 11;
logEntry.Severity = TraceEventType.Error;
logEntry.Title = "title";
source.TraceData(TraceEventType.Error, 0, logEntry);
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetSqlStringCommand("SELECT Count(*) FROM Category");
int categoryCount = Convert.ToInt32(db.ExecuteScalar(command));
Assert.AreEqual(2, categoryCount);
}
public void AllEntriesAreWrittenWhenUsingAsynchForFormattedDatabase()
{
this.ClearLogs();
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(this.ConfigurationSource.GetSection), false);
DatabaseProviderFactory factory = new DatabaseProviderFactory(this.ConfigurationSource.GetSection);
Data.Database dbProvider = factory.CreateDefault();
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(dbProvider, "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
string unique = Guid.NewGuid().ToString();
LogWriterFactory factory1 = new LogWriterFactory((e) => this.ConfigurationSource.GetSection("loggingConfiguration"));
int messageContents = 0;
using (var writer = factory1.Create())
{
Logger.SetLogWriter(writer);
Parallel.Invoke(Enumerable.Range(0, 10000).Select(i =>
new Action(() =>
{
Logger.Write(unique + " Test Asynch Message: " + i);
})).ToArray());
}
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand command = new SqlCommand("select COUNT(1) from Log where Message like '" + unique + " Test Asynch Message:%'", connection);
messageContents = (Int32)command.ExecuteScalar();
connection.Close();
}
Assert.AreEqual(10000, messageContents);
}
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 EntryIsWrittenToDatabaseWhenSpecialCategoriesErrorMax()
{
Data.Database dbProvider = new DatabaseProviderFactory(this.ConfigurationSource).Create("Connection String");
Assert.IsNotNull(dbProvider);
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(dbProvider,
"WriteLog",
"AddCategory",
new TextFormatter("DBTL TEST{newline}DBTL TEST"));
LogEntry entry = new LogEntry();
entry.Message = "Message 1";
entry.Categories.Add("General");
entry.EventId = 123;
entry.Priority = 11;
entry.Severity = TraceEventType.Error;
entry.Title = "Db Trace listener title";
entry.Win32ThreadId = "Win32ThreadId";
entry.TimeStamp = DateTime.Now;
entry.ProcessId = "100";
entry.ProcessName = "Process Name";
entry.MachineName = "CHNSHL123456";
entry.ActivityId = Guid.NewGuid();
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, entry);
string result = GetLastLogMessage("Connection String");
Assert.AreNotEqual(0, result.Length);
Assert.AreEqual("DBTL TEST" + Environment.NewLine + "DBTL TEST", result);
}
public void FormatterListenerWithWrongStoredProcs()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WrongWriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
private void UpdateConfigForDatabaseTL(LoggingConfiguration loggingConfiguration)
{
SqlDatabase dbConnection = new SqlDatabase(connectionString);
var databaseTraceListener = new FormattedDatabaseTraceListener(dbConnection, "WriteLog", "AddCategory", briefFormatter);
loggingConfiguration.AddLogSource("Database", SourceLevels.All, true, databaseTraceListener);
loggingConfiguration.SpecialSources.Unprocessed.Listeners.Add(databaseTraceListener);
}
public void FormatterListenerWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", messageContents);
}
public void FormatterListenerWriteWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.Write("Test Message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("Test Message", messageContents);
}
public void FormatterListenerAsString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, "test message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("test message", messageContents);
}
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 LogToDatabaseUsingDirectObjectOnlyResultsInOneMessage()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
int numMessages = GetNumberOfLogMessage("LoggingDb");
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, new TestCustomObject());
int newNumMessages = GetNumberOfLogMessage("LoggingDb");
Assert.AreEqual(numMessages, newNumMessages - 1);
}
public void FormatterListenerDoesNotFireInstrumentationWhenTracingString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
MockLoggingInstrumentationListener instrumentationListener = new MockLoggingInstrumentationListener();
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(listener.GetInstrumentationEventProvider(), instrumentationListener);
TraceEventCache eventCache = new TraceEventCache();
listener.TraceData(eventCache, "", TraceEventType.Error, 0, "message");
Assert.AreEqual(0, instrumentationListener.calls);
}
public void ShouldFilterLogToDatabase()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// Disable filtering
listener.Filter = new EventTypeFilter(SourceLevels.Off);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string result = GetLastLogMessage("LoggingDb");
Assert.AreEqual(0, result.Length);
}
public void FormatterListenerWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", messageContents);
}
public void ShouldFilterLogToDatabase()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// Disable filtering
listener.Filter = new EventTypeFilter(SourceLevels.Off);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string result = GetLastLogMessage("LoggingDb");
Assert.AreEqual(0, result.Length);
}
public void LogToDatabaseApplyingFilter()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// Apply filter
listener.Filter = new EventTypeFilter(SourceLevels.Information);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Verbose, "title", null));
string result = GetLastLogMessage("LoggingDb");
Assert.AreNotEqual(0, result.Length);
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", result);
}
public void FormatterListenerAsString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, "test message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("test message", messageContents);
}
public void FormatterListenerFiresInstrumentation()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
MockLoggingInstrumentationListener instrumentationListener = new MockLoggingInstrumentationListener();
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(listener.GetInstrumentationEventProvider(), instrumentationListener);
TraceEventCache eventCache = new TraceEventCache();
listener.TraceData(eventCache, "", TraceEventType.Error, 0, new LogEntry("message", "category", 0, 0, TraceEventType.Error, "title", null));
Assert.AreEqual(1, instrumentationListener.calls);
}
public void LogToDatabaseApplyingFilter()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// Apply filter
listener.Filter = new EventTypeFilter(SourceLevels.Information);
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Verbose, "title", null));
string result = GetLastLogMessage("LoggingDb");
Assert.AreNotEqual(0, result.Length);
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", result);
}
public void FormatterListenerWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", messageContents);
}
public void FormatterListenerAsString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, "test message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("test message", messageContents);
}
public void LogToDatabaseUsingDirectObjectOnlyResultsInOneMessage()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
int numMessages = GetNumberOfLogMessage("LoggingDb");
source.TraceData(TraceEventType.Error, 1, new TestCustomObject());
source.Close();
int newNumMessages = GetNumberOfLogMessage("LoggingDb");
Assert.AreEqual(numMessages, newNumMessages - 1);
}
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}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})}");
// Listeners
var databaseTraceListener = new FormattedDatabaseTraceListener(DatabaseFactory.CreateDatabase("Conn"), "WriteLog", "AddCategory", formatter);
// Build Configuration
var config = new LoggingConfiguration();
config.AddLogSource("Database", SourceLevels.All, true).AddTraceListener(databaseTraceListener);
// Special Sources Configuration
return(config);
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds a <see cref="FormattedDatabaseTraceListener"/> based on an instance of <see cref="FormattedDatabaseTraceListenerData"/>.
/// </summary>
/// <seealso cref="TraceListenerCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="FormattedDatabaseTraceListenerData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="FormattedDatabaseTraceListener"/>.</returns>
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
FormattedDatabaseTraceListenerData castedObjectConfiguration
= (FormattedDatabaseTraceListenerData)objectConfiguration;
Data.Database database =
(Data.Database)context.HeadOfChain.BuildUp(context, typeof(Data.Database), null, castedObjectConfiguration.DatabaseInstanceName);
ILogFormatter formatter
= LogFormatterCustomFactory.Instance.Create(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new FormattedDatabaseTraceListener(
database,
castedObjectConfiguration.WriteLogStoredProcName,
castedObjectConfiguration.AddCategoryStoredProcName,
formatter);
return(createdObject);
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds a <see cref="FormattedDatabaseTraceListener"/> based on an instance of <see cref="FormattedDatabaseTraceListenerData"/>.
/// </summary>
/// <seealso cref="TraceListenerCustomFactory"/>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="objectConfiguration">The configuration object that describes the object to build. Must be an instance of <see cref="FormattedDatabaseTraceListenerData"/>.</param>
/// <param name="configurationSource">The source for configuration objects.</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>A fully initialized instance of <see cref="FormattedDatabaseTraceListener"/>.</returns>
public override TraceListener Assemble(IBuilderContext context, TraceListenerData objectConfiguration, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
FormattedDatabaseTraceListenerData castedObjectConfiguration
= (FormattedDatabaseTraceListenerData)objectConfiguration;
Data.Database database =
(Data.Database)context.HeadOfChain.BuildUp(context, typeof(Data.Database), null, castedObjectConfiguration.DatabaseInstanceName);
ILogFormatter formatter
= LogFormatterCustomFactory.Instance.Create(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new FormattedDatabaseTraceListener(
database,
castedObjectConfiguration.WriteLogStoredProcName,
castedObjectConfiguration.AddCategoryStoredProcName,
formatter);
return createdObject;
}
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);
}
public void EntryIsWrittenToDatabaseWhenSeverityIsWarning()
{
Data.Database dbProvider = new DatabaseProviderFactory(this.ConfigurationSource).Create("Connection String");
Assert.IsNotNull(dbProvider);
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(dbProvider,
"WriteLog",
"AddCategory",
new TextFormatter("DBTL TEST{newline}DBTL TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("Message-Warning",
"cat1",
0,
0,
TraceEventType.Warning,
"title",
null));
string result = GetLastLogMessage("Connection String");
Assert.AreNotEqual(0, result.Length);
Assert.AreEqual("DBTL TEST" + Environment.NewLine + "DBTL TEST", result);
}
public void EntryIsWrittenToDatabase()
{
var config = new LoggingConfiguration();
config.IsTracingEnabled = true;
config.DefaultSource = "General";
config.LogWarningsWhenNoCategoriesMatch = true;
SqlDatabase dbConnection = new SqlDatabase(connectionString);
var databaseTraceListener = new FormattedDatabaseTraceListener(dbConnection, "WriteLog", "AddCategory", briefFormatter);
config.SpecialSources.Unprocessed.Listeners.Add(databaseTraceListener);
this.writer = new LogWriter(config);
this.writer.Write("Test Log Entry in Database", "Database",
2, 1001, TraceEventType.Warning, "Logging Block ProgConfig Sample", null);
string dateTimeLogged = DateTime.Now.ToLocalTime().ToString();
string strMessage = this.CheckEntryInDatabase();
Assert.IsTrue(strMessage.Contains("Test Log Entry in Database"));
}
public override TraceListener Assemble(IBuilderContext context,
TraceListenerData objectConfiguration,
IConfigurationSource configurationSource,
ConfigurationReflectionCache reflectionCache)
{
FormattedDatabaseTraceListenerData castedObjectConfiguration
= (FormattedDatabaseTraceListenerData)objectConfiguration;
IBuilderContext databaseContext
= context.CloneForNewBuild(
NamedTypeBuildKey.Make <Data.Database>(castedObjectConfiguration.DatabaseInstanceName), null);
Data.Database database
= (Data.Database)databaseContext.Strategies.ExecuteBuildUp(databaseContext);
ILogFormatter formatter
= GetFormatter(context, castedObjectConfiguration.Formatter, configurationSource, reflectionCache);
TraceListener createdObject
= new FormattedDatabaseTraceListener(
database,
castedObjectConfiguration.WriteLogStoredProcName,
castedObjectConfiguration.AddCategoryStoredProcName,
formatter);
return(createdObject);
}
public void FormatterListenerWithWrongStoredProcs()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WrongWriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
public void FormatterListenerWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("TEST" + Environment.NewLine + "TEST", messageContents);
}
public void LogWithMultipleCategories()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
// need to go through the source to get a TraceEventCache
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
LogEntry logEntry = new LogEntry();
logEntry.Message = "message";
logEntry.Categories.Add("FormattedCategory");
logEntry.Categories.Add("DictionaryCategory");
logEntry.EventId = 123;
logEntry.Priority = 11;
logEntry.Severity = TraceEventType.Error;
logEntry.Title = "title";
source.TraceData(TraceEventType.Error, 0, logEntry);
DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
Data.Database db = factory.CreateDefault();
DbCommand command = db.GetSqlStringCommand("SELECT Count(*) FROM Category");
int categoryCount = Convert.ToInt32(db.ExecuteScalar(command));
Assert.AreEqual(2, categoryCount);
}
public void LogToDatabaseUsingDirectObjectOnlyResultsInOneMessage()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
int numMessages = GetNumberOfLogMessage("LoggingDb");
source.TraceData(TraceEventType.Error, 1, new TestCustomObject());
source.Close();
int newNumMessages = GetNumberOfLogMessage("LoggingDb");
Assert.AreEqual(numMessages, newNumMessages - 1);
}
public void FormatterListenerWriteWithStoredProcsAndDbInstance()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.Write("Test Message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("Test Message", messageContents);
}
public void FormatterListenerWithWrongStoredProcs()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WrongWriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
TraceSource source = new TraceSource("notfromconfig", SourceLevels.All);
source.Listeners.Add(listener);
source.TraceData(TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
public void FormatterListenerAsString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, "test message");
string messageContents = GetLastLogMessage("LoggingDb");
Assert.AreEqual("test message", messageContents);
}
public void FormatterListenerWithWrongStoredProcs()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WrongWriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
private FormattedDatabaseTraceListener RollingFlatFileTraceListenerGet()
{
if (this._dormattedDatabaseTraceListener == null)
{
this.AttributesSetDefaultValues();
this._dormattedDatabaseTraceListener = new FormattedDatabaseTraceListener(
DatabaseFactory.CreateDatabase(this.Attributes[_databaseInstanceNameAttribute]),
this.Attributes[_writeLogStoredProcNameAttribute],
this.Attributes[_addCategoryStoredProcNameAttribute],
new RollingXmlTraceListenerFormatter(this.AttributesConvertToNameValueCollection()));
}
return this._dormattedDatabaseTraceListener;
}
public void ExceptionIsThrownWhenWrongConnectionString()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(WrongConnectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 0, new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
}
public void LogToDatabaseUsingDirectObjectOnlyResultsInOneMessage()
{
FormattedDatabaseTraceListener listener = new FormattedDatabaseTraceListener(new SqlDatabase(connectionString), "WriteLog", "AddCategory", new TextFormatter("TEST{newline}TEST"));
int numMessages = GetNumberOfLogMessage("LoggingDb");
listener.TraceData(new TraceEventCache(), "source", TraceEventType.Error, 1, new TestCustomObject());
int newNumMessages = GetNumberOfLogMessage("LoggingDb");
Assert.AreEqual(numMessages, newNumMessages - 1);
}
