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