/// <summary>
/// Loads an <see cref="Appender"/> based on the content of an appropriate Log4Net Config <see cref="XElement"/>.
/// </summary>
/// <param name="appenderElement">The <see cref="XElement"/> that represents an appender element.</param>
private static Appender LoadAppenderFromElement(XElement appenderElement)
{
if (!appenderElement.Descendants().Any())
{
return(null);
}
AppenderType newAppenderType = AppenderType.RollingFileAppender;
try
{
newAppenderType = LoadAppenderTypeFromElement(appenderElement);
}
catch
{
return(null);
}
Appender newAppender = new Appender
{
Type = newAppenderType,
FolderPath = LoadAppenderFolderPathFromElement(appenderElement),
RollingFileNameMask = LoadAppenderRollingFileMaskFromElement(appenderElement),
StaticFileNameMask = LoadAppenderStaticFileNameMaskFromElement(appenderElement),
UseStaticLogFileName = LoadAppenderUseStaticLogFileNameFromElement(appenderElement),
Layout = LoadAppenderLayoutFromElement(appenderElement)
};
return(newAppender);
}
public static void LoadAppenders(AppenderType type)
{
switch (type)
{
case AppenderType.Console:
LoadAppenders(new ConsoleAppender());
break;
case AppenderType.GUI:
LoadAppenders(GUIAppender.Instance);
break;
case AppenderType.MobileGUI:
LoadAppenders(MobileGUIAppender.Instance);
break;
case AppenderType.File:
LoadAppenders(FileAppender.Instance);
break;
case AppenderType.Window:
LoadAppenders(new WindowAppender());
break;
}
}
private bool AreEqual(AppenderDescriptor descriptor, string name, AppenderType type, string typeNamespace, string elementName)
{
return(descriptor.Name == name &&
descriptor.Type == type &&
descriptor.TypeNamespace == typeNamespace &&
descriptor.ElementName == elementName);
}
public void UnloadAppenders(AppenderType type)
{
if (!allAppender.ContainsKey(type))
{
return;
}
UnloadAppenders(allAppender.GetValue(type));
}
/// <summary>
/// Add an appender to the logger
/// </summary>
/// <param name="type">The appender type</param>
/// <param name="clazz">The appender class</param>
/// <param name="name">The name of the appender</param>
/// <returns>IAppender</returns>
public IAppender AddAppender(AppenderType type, Type clazz, string name = null)
{
if (!this.AppenderList.IsAnAppenderName(name))
{
// Create a new appender
IAppender appender = this.CreateAppender(type, clazz, name);
this.AddAppender(appender);
return(appender);
}
else
{
return(null);
}
}
/// <summary>
/// Create a new appender from its type.
/// </summary>
/// <param name="type">The appender type</param>
/// <param name="clazz">Class of the appender</param>
/// <param name="name">Name of the appender</param>
/// <returns>IAppender</returns>
public IAppender CreateAppender(AppenderType type, Type clazz, string name)
{
switch (type)
{
case AppenderType.MESSAGE_BOX_CUSTOM:
var d1 = typeof(MessageBoxCustomAppender <>);
var makeme = d1.MakeGenericType(clazz);
return(Activator.CreateInstance(makeme, name) as IAppender);
default:
return(new ConsoleAppender(name));
}
}
/// <summary>
/// Create a new appender from its type.
/// </summary>
/// <param name="type">The appender type</param>
/// <param name="name">Tha appender name</param>
/// <returns>IAppender</returns>
public IAppender CreateAppender(AppenderType type, string name)
{
switch (type)
{
case AppenderType.CONSOLE:
return(new ConsoleAppender(name));
case AppenderType.MESSAGE_BOX:
return(new MessageBoxAppender(name));
case AppenderType.TOAST:
return(new ToastAppender(name));
case AppenderType.DATABASE:
return(new DataBaseAppender(name));
case AppenderType.FILE:
return(new FileAppender(name));
default:
return(new ConsoleAppender(name));
}
}
public void EachAppender_ShouldHaveCorrectAppenderField(string name, AppenderType type, string typeNamespace, string elementName)
{
mAppenders.Single(a => AreEqual((AppenderDescriptor)a.GetValue(null), name, type, typeNamespace, elementName));
}
static void CreateAppenderFromConfig(string appenderName)
{
if (string.IsNullOrEmpty(appenderName))
{
return;
}
string options = ConfigMgr.GetDefaultValue(appenderName, "");
var tokens = new StringArray(options, ',');
string name = appenderName.Substring(9);
if (tokens.Length < 2)
{
Console.WriteLine("Log.CreateAppenderFromConfig: Wrong configuration for appender {0}. Config line: {1}", name, options);
return;
}
AppenderFlags flags = AppenderFlags.None;
AppenderType type = (AppenderType)uint.Parse(tokens[0]);
LogLevel level = (LogLevel)uint.Parse(tokens[1]);
if (level > LogLevel.Fatal)
{
Console.WriteLine("Log.CreateAppenderFromConfig: Wrong Log Level {0} for appender {1}\n", level, name);
return;
}
if (tokens.Length > 2)
{
flags = (AppenderFlags)uint.Parse(tokens[2]);
}
byte id = NextAppenderId();
switch (type)
{
case AppenderType.Console:
{
var appender = new ConsoleAppender(id, name, level, flags);
appenders[id] = appender;
break;
}
case AppenderType.File:
{
string filename;
if (tokens.Length < 4)
{
if (name != "Server")
{
Console.WriteLine("Log.CreateAppenderFromConfig: Missing file name for appender {0}", name);
return;
}
filename = Process.GetCurrentProcess().ProcessName + ".log";
}
else
{
filename = tokens[3];
}
appenders[id] = new FileAppender(id, name, level, filename, m_logsDir, flags);
break;
}
case AppenderType.DB:
{
appenders[id] = new DBAppender(id, name, level);
break;
}
default:
Console.WriteLine("Log.CreateAppenderFromConfig: Unknown type {0} for appender {1}", type, name);
break;
}
}
private AppenderDescriptor(string name, AppenderType type, string typeNamespace)
: base(name, "appender", typeNamespace)
{
Type = type;
}
public void SynchronousAppender_Send_MeasurePerformance(int bufferSize, int messageCount, AppenderType appenderType)
{
// Arrange
var appender = new MyBufferedAppender
{
BufferSize = bufferSize,
SendAsync = appenderType == AppenderType.Asynchronous
};
appender.ActivateOptions();
ConfigureAppender(appender);
var logger = LogManager.GetLogger(this.GetType());
// Act
var stopWatch = new Stopwatch();
stopWatch.Start();
for (int i = 0; i < messageCount; i++)
{
logger.Info(Guid.NewGuid().ToString());
}
stopWatch.Stop();
StopApplication();
// Assert
if (MessageSink.Logs.Count != messageCount)
{
// Give it time to finish sending
Thread.Sleep(2000);
}
Assert.That(MessageSink.Logs.Count, Is.EqualTo(messageCount), "Not all the messages were sent!");
Console.WriteLine("Type:{3}|BufferSize:{0}|MessageCount:{1}|Time(seconds):{2}", bufferSize, messageCount, stopWatch.Elapsed.TotalSeconds, appenderType);
}
public static void UnloadAppenders(AppenderType type)
{
Logging.Instance.UnloadAppenders(type);
}
/// <summary>
/// Add an appender from AppenderType.
/// </summary>
/// <param name="appenderType">Type of the appender</param>
/// <param name="appenderName">Name of the appender</param>
/// <returns>IAppender</returns>
public IAppender AddAppender(AppenderType appenderType, string appenderName = null)
{
return(this.AppenderManager.AddAppender(appenderType, appenderName));
}
/// <summary>
/// Remove all appenders from the given type
/// </summary>
/// <param name="appenderType">Type of appender to remove</param>
public void RemoveAppender(AppenderType appenderType)
{
this.AppenderManager.Detach(appenderType);
}
private void CreateAppenderFromConfig(string?appenderName)
{
if (string.IsNullOrEmpty(appenderName))
{
return;
}
// Format = type, level, flags, optional1, optional2
// if type = File. optional1 = file and option2 = mode
// if type = Console. optional1 = Color
var options = sConfigMgr.GetStringDefault(appenderName, "");
var tokens = options.Split(',', StringSplitOptions.TrimEntries);
var size = tokens.Length;
var name = appenderName.Substring(9);
if (size < 2)
{
Console.Error.WriteLine(string.Format("Log::CreateAppenderFromConfig: Wrong configuration for appender {0}. Config line: {1}", name, options));
return;
}
AppenderFlags flags = APPENDER_FLAGS_NONE;
AppenderType type = APPENDER_INVALID;
Enum.TryParse <AppenderType>(tokens[0], out type);
LogLevel level = LOG_LEVEL_INVALID;
Enum.TryParse <LogLevel>(tokens[1], out level);
if (!_appenderFactory.TryGetValue((byte)type, out var factoryFunction))
{
Console.Error.WriteLine(string.Format("Log::CreateAppenderFromConfig: Unknown type '{0}' for appender {1}", tokens[0], name));
return;
}
if (level > NUM_ENABLED_LOG_LEVELS)
{
Console.Error.WriteLine(string.Format("Log::CreateAppenderFromConfig: Wrong Log Level '{0}' for appender {1}", tokens[1], name));
return;
}
if (size > 2)
{
if (byte.TryParse(tokens[2], out var flagsVal))
{
flags = (AppenderFlags)flagsVal;
}
else
{
Console.Error.WriteLine(string.Format("Log::CreateAppenderFromConfig: Unknown flags '{0}' for appender {1}", tokens[2], name));
return;
}
}
try
{
var appender = factoryFunction(NextAppenderId(), name, level, flags, tokens);
_appenders[appender.Id] = appender;
}
catch (InvalidAppenderArgsException ex)
{
Console.Error.WriteLine(ex);
}
}
public void EachAppender_ShouldBeFoundByTypeNamespace(string name, AppenderType type, string typeNamespace, string elementName)
{
Assert.IsTrue(AppenderDescriptor.TryFindByTypeNamespace(typeNamespace, out AppenderDescriptor appender));
Assert.IsTrue(AreEqual(appender, name, type, typeNamespace, elementName));
}
/// <summary>
/// Detach all appender from a type
/// </summary>
/// <param name="type">The appender type</param>
public void Detach(AppenderType type)
{
List <IAppender> appenders = this.appenderList.ToList <IAppender>();
appenders.RemoveAll(app => app.AppenderType == type);
}
/// <summary>
/// Retrieves an enumerable of <see cref="Appender"/>s based on their <see cref="AppenderType"/>
/// </summary>
/// <param name="appenderType">The <see cref="AppenderType"/> to retrieve <see cref="Appender"/>s for.</param>
public IEnumerable <Appender> AppendersOfType(AppenderType appenderType)
{
return(Appenders.Where(a => a.Type == appenderType));
}
