private static TraceListener GetListener(string name, IConfigurationSource configurationSource)
{
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(configurationSource.GetSection), false);
var settings = LoggingSettings.GetLoggingSettings(configurationSource);
return(settings.TraceListeners.Get(name).BuildTraceListener(settings));
}
protected override TraceListenerData GetConfiguration(string name, IConfigurationSource configurationSource)
{
LoggingSettings settings = LoggingSettings.GetLoggingSettings(configurationSource);
ValidateSettings(settings);
TraceListenerData objectConfiguration = settings.TraceListeners.Get(name);
ValidateConfiguration(objectConfiguration, name);
return(objectConfiguration);
}
public void ConfigExistsTest()
{
LoggingSettings msConfig = null;
try
{
msConfig = LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource());
}
catch
{
Assert.Fail("Error");
}
Assert.IsNotNull(msConfig);
}
private static LogglyTraceListenerData GetLogglyTraceListenerSettings()
{
LogglyTraceListenerData traceListenerSettings = null;
using (var configurationSource = ConfigurationSourceFactory.Create())
{
var loggingSettings = LoggingSettings.GetLoggingSettings(configurationSource);
traceListenerSettings = loggingSettings.TraceListeners
.Where(l => l is LogglyTraceListenerData)
.Single() as LogglyTraceListenerData;
}
return(traceListenerSettings);
}
public DynamicELLogger(string logRoot, IEnumerable <string> applications)
{
string[] categories = new string[] { "Info", "Error", "Debug", "Perf" };
LoggingSettings loggingSetting = LoggingSettings.GetLoggingSettings(ConfigurationSourceFactory.Create());
Dictionary <string, TextFormatter> formatters = new Dictionary <string, TextFormatter>(categories.Count(), StringComparer.OrdinalIgnoreCase);
foreach (string cate in categories)
{
var formatData = loggingSetting.Formatters.Where(f => f.Name.Equals(cate, StringComparison.OrdinalIgnoreCase)).SingleOrDefault() as TextFormatterData;
if (formatData == null)
{
throw new Exception(string.Format("Missing logging formatter \"{0}\"", cate));
}
TextFormatter formatter = new TextFormatter(formatData.Template);
formatters[cate] = formatter;
}
string baseLogPath = Path.Combine(logRoot, "{0}.log");
string logPath = Path.Combine(logRoot, "{0}\\{1}.log");
List <LogSource> logSources = new List <LogSource>();
foreach (var cate in categories)
{
logSources.Add(new LogSource(cate, new List <TraceListener>
{
new RollingFlatFileTraceListener(string.Format(baseLogPath, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day)
}, SourceLevels.All));
}
foreach (var app in applications)
{
foreach (var cate in categories)
{
logSources.Add(new LogSource(app + "." + cate, new List <TraceListener>
{
new RollingFlatFileTraceListener(string.Format(logPath, app, cate), "", "", formatters[cate], 0, "yyyyMMdd", RollFileExistsBehavior.Overwrite, RollInterval.Day)
}, SourceLevels.All));
}
}
var nonExistantLog = new LogSource("Empty");
m_Writer = new LogWriter(new ILogFilter[0], logSources, nonExistantLog, categories[0]);
}
static void Main(string[] args)
{
var configSource = ConfigurationSourceFactory.Create();
var logglyLoggingSettings = (LogglyTraceListenerData)LoggingSettings.GetLoggingSettings(configSource).TraceListeners.Get("Loggly Listener");
string logglyInputKey = logglyLoggingSettings.LogglyInputKey;
Console.WriteLine("Testing logging for Loggly input key: {0}", logglyInputKey);
if (Logger.IsLoggingEnabled())
{
for (int i = 1; i < GetRandom.PositiveInt(9) + 1; i++)
{
var message = string.Format("Test {0}", i);
Console.WriteLine(message);
Logger.Write(message);
}
}
}
public void EmptyCategoriesRevertToDefaultCategory()
{
MockTraceListener.Reset();
LoggingSettings settings = LoggingSettings.GetLoggingSettings(new SystemConfigurationSource());
LogEntry log = new LogEntry();
log.EventId = 1;
log.Message = "test";
log.Categories = new string[0];
log.Severity = TraceEventType.Error;
Logger.Write(log);
Assert.IsNotNull(MockTraceListener.LastEntry);
Assert.AreEqual("test", MockTraceListener.LastEntry.Message);
Assert.AreEqual(1, MockTraceListener.LastEntry.Categories.Count);
Assert.IsTrue(MockTraceListener.LastEntry.Categories.Contains(settings.DefaultCategory));
}
/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Builds a <see cref="LogWriterStructureHolder"/> described by the <see cref="LoggingSettings"/> configuration section.
/// </summary>
/// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
/// <param name="name">The name of the instance to build. It is part of the <see cref="ICustomFactory.CreateObject(IBuilderContext, string, IConfigurationSource, ConfigurationReflectionCache)"/> method, but it is not used in this implementation.</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="LogWriterStructureHolder"/>.</returns>
public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
{
LoggingSettings loggingSettings = LoggingSettings.GetLoggingSettings(configurationSource);
ValidateLoggingSettings(loggingSettings);
TraceListenerCustomFactory.TraceListenerCache traceListenerCache
= TraceListenerCustomFactory.CreateTraceListenerCache(loggingSettings.TraceListeners.Count);
ICollection <ILogFilter> logFilters = new List <ILogFilter>();
foreach (LogFilterData logFilterData in loggingSettings.LogFilters)
{
logFilters.Add(LogFilterCustomFactory.Instance.Create(context, logFilterData, configurationSource, reflectionCache));
}
IDictionary <string, LogSource> traceSources = new Dictionary <string, LogSource>();
foreach (TraceSourceData traceSourceData in loggingSettings.TraceSources)
{
traceSources.Add(traceSourceData.Name, LogSourceCustomFactory.Instance.Create(context, traceSourceData, configurationSource, reflectionCache, traceListenerCache));
}
LogSource allEventsTraceSource
= LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.AllEventsTraceSource, configurationSource, reflectionCache, traceListenerCache);
LogSource notProcessedTraceSource
= LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.NotProcessedTraceSource, configurationSource, reflectionCache, traceListenerCache);
LogSource errorsTraceSource
= LogSourceCustomFactory.Instance.Create(context, loggingSettings.SpecialTraceSources.ErrorsTraceSource, configurationSource, reflectionCache, traceListenerCache);
LogWriterStructureHolder createdObject
= new LogWriterStructureHolder(
logFilters,
traceSources,
allEventsTraceSource,
notProcessedTraceSource,
errorsTraceSource,
loggingSettings.DefaultCategory,
loggingSettings.TracingEnabled,
loggingSettings.LogWarningWhenNoCategoriesMatch);
return(createdObject);
}
/// <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));
}
private void UpdateLoggingTemplate()
{
var originalSettings = LoggingSettings.GetLoggingSettings(secondSource);
var newSettings = new LoggingSettings(originalSettings.Name, originalSettings.TracingEnabled,
originalSettings.DefaultCategory)
{
SpecialTraceSources = originalSettings.SpecialTraceSources,
LogWarningWhenNoCategoriesMatch = originalSettings.LogWarningWhenNoCategoriesMatch,
RevertImpersonation = originalSettings.RevertImpersonation
};
CopyData(originalSettings.TraceListeners, tl => newSettings.TraceListeners.Add(tl));
CopyData(originalSettings.Formatters, f => newSettings.Formatters.Add(f));
CopyData(originalSettings.LogFilters, lf => newSettings.LogFilters.Add(lf));
CopyData(originalSettings.TraceSources, ts => newSettings.TraceSources.Add(ts));
var formatter = (TextFormatterData)newSettings.Formatters.Get("Text Formatter");
formatter.Template = "*** " + formatter.Template;
secondSource.Save(LoggingSettings.SectionName, newSettings);
}
private static TraceListener GetListener(string name, IConfigurationSource configurationSource)
{
var settings = LoggingSettings.GetLoggingSettings(configurationSource);
return(settings.TraceListeners.Get(name).BuildTraceListener(settings));
}
public void ConfigListenerExistsTest()
{
Assert.IsTrue(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Count > 0);
}
private static ILogFilter GetFilter(string name, IConfigurationSource configurationSource)
{
var settings = LoggingSettings.GetLoggingSettings(configurationSource);
return(settings.LogFilters.Get(name).BuildFilter());
}
private void DisplayConfiguration()
{
try
{
// Get configuration settings for Logging and Instrmentation Application Block.
// This assumes the configuration source is the SystemConfigurationSource, which
// is the default setting when the QuickStart ships.
LoggingSettings settings = LoggingSettings.GetLoggingSettings(new SystemConfigurationSource());
string defaultCategory = settings.DefaultCategory;
StringBuilder results = new StringBuilder();
results.Append("Current Configuration");
results.Append(Environment.NewLine);
results.Append("---------------------------------");
results.Append(Environment.NewLine);
results.Append(Environment.NewLine);
results.Append("Default Category: " + settings.DefaultCategory + Environment.NewLine + Environment.NewLine);
results.Append("Categories and category listeners");
results.Append(Environment.NewLine);
results.Append(Environment.NewLine);
// Grab the list of categories and loop through for display.
NamedElementCollection <TraceSourceData> sources = settings.TraceSources;
foreach (TraceSourceData source in sources)
{
results.Append(" " + source.Name);
// Flag any of the categories that would be denied based upon
// the current category filter configuration.
if (!Logger.GetFilter <CategoryFilter>().ShouldLog(source.Name))
{
results.Append("*");
}
// Loop through the list of trace listeners for the category.
NamedElementCollection <TraceListenerReferenceData> TraceListeners = source.TraceListeners;
StringBuilder listener = new StringBuilder();
listener.Append(" - ");
foreach (TraceListenerReferenceData listenerData in TraceListeners)
{
listener.Append(listenerData.Name + ", ");
}
// Remove trailing comma and space
listener.Remove(listener.Length - 2, 2);
results.Append(listener.ToString());
results.Append(Environment.NewLine);
}
results.Append(Environment.NewLine);
results.Append(" * Events in category will not be logged");
this.resultsTextBox.Text += results.ToString();
}
catch (Exception ex)
{
ProcessUnhandledException(ex);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void ConfigFileListenerExistsTest()
{
Assert.IsNotNull(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("Rolling Flat File Trace Listener"));
}
public void ConfigConsoleAppenderExistsTest()
{
Assert.IsTrue(LoggingSettings.GetLoggingSettings(new Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource()).TraceListeners.Get("System Diagnostics Trace Listener").Type == typeof(ConsoleTraceListener));
}
