private static void CollectAppenders(ArrayList appenderList, IAppenderAttachable container)
{
foreach (IAppender appender in container.Appenders)
{
CollectAppender(appenderList, appender);
}
}
/// <summary>
/// Parses an appender element.
/// </summary>
/// <param name="appenderElement">The appender element.</param>
/// <returns>The appender instance or <c>null</c> when parsing failed.</returns>
protected IAppender ParseAppender(XmlElement appenderElement)
{
string appenderName = appenderElement.GetAttribute(NAME_ATTR);
string typeName = appenderElement.GetAttribute(TYPE_ATTR);
LogLog.Debug("DOMConfigurator: Loading Appender [" + appenderName + "] type: [" + typeName + "]");
try
{
IAppender appender = (IAppender)SystemInfo.GetTypeFromString(typeName, true, true).GetConstructor(SystemInfo.EmptyTypes).Invoke(BindingFlags.Public | BindingFlags.Instance, null, new object[0], CultureInfo.InvariantCulture);
appender.Name = appenderName;
foreach (XmlNode currentNode in appenderElement.ChildNodes)
{
/* We're only interested in Elements */
if (currentNode.NodeType == XmlNodeType.Element)
{
XmlElement currentElement = (XmlElement)currentNode;
// Look for the appender ref tag
if (currentElement.LocalName == APPENDER_REF_TAG)
{
string refName = currentElement.GetAttribute(REF_ATTR);
if (appender is IAppenderAttachable)
{
IAppenderAttachable aa = (IAppenderAttachable)appender;
LogLog.Debug("DOMConfigurator: Attaching appender named [" + refName + "] to appender named [" + appender.Name + "].");
IAppender a = FindAppenderByReference(currentElement);
if (a != null)
{
aa.AddAppender(a);
}
}
else
{
LogLog.Error("DOMConfigurator: Requesting attachment of appender named [" + refName + "] to appender named [" + appender.Name + "] which does not implement log4net.spi.IAppenderAttachable.");
}
}
else
{
// For all other tags we use standard set param method
SetParameter(currentElement, appender);
}
}
}
if (appender is IOptionHandler)
{
((IOptionHandler)appender).ActivateOptions();
}
LogLog.Debug("DOMConfigurator: Created Appender [" + appenderName + "]");
return(appender);
}
/* Yes, it's ugly. But all of these exceptions point to the same problem: we can't create an Appender */
catch (Exception oops)
{
LogLog.Error("DOMConfigurator: Could not create Appender [" + appenderName + "] of type [" + typeName + "]. Reported error follows.", oops);
return(null);
}
}
public void Dispose()
{
if (_root != null)
{
_root.RemoveAppender(this);
_root = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="logAction"></param>
/// <param name="level"></param>
public LogInterceptor(Action <LoggingEvent> logAction, Level level)
{
Threshold = level;
_logAction = logAction;
_root = ((Hierarchy)LogManager.GetRepository()).Root;
_root.AddAppender(this);
}
private static bool HasCountingAppender(IAppenderAttachable logger)
{
foreach (IAppender appender in logger.Appenders)
{
if (appender is CountToContextItemsAppender)
return true;
}
return false;
}
public void Start()
{
IAppenderAttachable attachable = GetAppenderAttachable();
if (attachable != null)
{
attachable.AddAppender(_appender);
}
}
public void Stop()
{
IAppenderAttachable attachable = GetAppenderAttachable();
if (attachable != null)
{
attachable.RemoveAppender(_appender);
}
}
protected LogOutputTester(ITestOutputHelper output)
{
log4net.Config.XmlConfigurator.Configure();
var root = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
_attachable = root;
_appender = new TestOutputAppender(output);
_attachable.AddAppender(_appender);
}
private static void CheckAppenders(IAppenderAttachable logger, string accountName, string profileName)
{
logger.Appenders.Should(Be.Not.Empty);
logger.Appenders.OfType <PluginRollingFileAppender>().Should(Be.Not.Empty);
var appender = logger.Appenders.OfType <PluginRollingFileAppender>().First();
appender.File.Contains(accountName).Should(Be.True);
appender.File.Contains(profileName).Should(Be.True);
}
private static bool HasCountingAppender(IAppenderAttachable logger)
{
foreach (IAppender appender in logger.Appenders)
{
if (appender is CountToContextItemsAppender)
{
return(true);
}
}
return(false);
}
protected LogOutputTester(ITestOutputHelper output)
{
var repo = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository(this.GetType().Assembly));
BasicConfigurator.Configure(repo);
_attachable = repo.Root;
_appender = new TestOutputAppender(output);
_attachable?.AddAppender(_appender);
this.output = output;
}
private static void CollectAppender(ArrayList appenderList, IAppender appender)
{
if (!appenderList.Contains(appender))
{
appenderList.Add(appender);
IAppenderAttachable container = appender as IAppenderAttachable;
if (container != null)
{
CollectAppenders(appenderList, container);
}
}
}
protected LogOutputTester(ITestOutputHelper output)
{
var repo = LogManager.GetRepository(typeof(ITelegramClient).GetTypeInfo().Assembly);
XmlConfigurator.Configure(repo, new FileInfo("log4net.config"));
var root = ((Hierarchy)repo).Root;
_attachable = root;
_appender = new TestOutputAppender(output);
_attachable?.AddAppender(_appender);
}
/// <summary>
/// Collect the appenders from an <see cref="IAppenderAttachable"/>.
/// The appender may also be a container.
/// </summary>
/// <param name="appenderList"></param>
/// <param name="appender"></param>
private static void CollectAppender(System.Collections.ArrayList appenderList, log4net.Appender.IAppender appender)
{
if (!appenderList.Contains(appender))
{
appenderList.Add(appender);
IAppenderAttachable container = appender as IAppenderAttachable;
if (container != null)
{
CollectAppenders(appenderList, container);
}
}
}
public static void CollectAppender(ArrayList appenderList, IAppender appender)
{
if (appenderList.Contains((object)appender))
{
return;
}
appenderList.Add((object)appender);
IAppenderAttachable container = appender as IAppenderAttachable;
if (container != null)
{
CollectAppenders(appenderList, container);
}
}
public Log4NetInMemoryStreamAppenderManager()
{
_loggerRoot = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
_memoryAppender = new MemoryAppender
{
Threshold = Level.All,
Name = this.GetType().Name,
Layout = new PatternLayout("{message}")
};
if (_loggerRoot != null)
_loggerRoot.AddAppender(_memoryAppender);
}
/// <summary>
/// Parses an appender element.
/// </summary>
/// <param name="appenderElement">The appender element.</param>
/// <returns>The appender instance or <c>null</c> when parsing failed.</returns>
/// <remarks>
/// <para>
/// Parse an XML element that represents an appender and return
/// the appender instance.
/// </para>
/// </remarks>
protected IAppender ParseAppender(XmlElement appenderElement)
{
string attribute = appenderElement.GetAttribute("name");
string attribute2 = appenderElement.GetAttribute("type");
LogLog.Debug(declaringType, "Loading Appender [" + attribute + "] type: [" + attribute2 + "]");
try
{
IAppender appender = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, attribute2, throwOnError: true, ignoreCase: true));
appender.Name = attribute;
foreach (XmlNode childNode in appenderElement.ChildNodes)
{
if (childNode.NodeType == XmlNodeType.Element)
{
XmlElement xmlElement = (XmlElement)childNode;
if (xmlElement.LocalName == "appender-ref")
{
string attribute3 = xmlElement.GetAttribute("ref");
IAppenderAttachable appenderAttachable = appender as IAppenderAttachable;
if (appenderAttachable != null)
{
LogLog.Debug(declaringType, "Attaching appender named [" + attribute3 + "] to appender named [" + appender.Name + "].");
IAppender appender2 = FindAppenderByReference(xmlElement);
if (appender2 != null)
{
appenderAttachable.AddAppender(appender2);
}
}
else
{
LogLog.Error(declaringType, "Requesting attachment of appender named [" + attribute3 + "] to appender named [" + appender.Name + "] which does not implement log4net.Core.IAppenderAttachable.");
}
}
else
{
SetParameter(xmlElement, appender);
}
}
}
(appender as IOptionHandler)?.ActivateOptions();
LogLog.Debug(declaringType, "Created Appender [" + attribute + "]");
return(appender);
}
catch (Exception exception)
{
LogLog.Error(declaringType, "Could not create Appender [" + attribute + "] of type [" + attribute2 + "]. Reported error follows.", exception);
return(null);
}
}
public LogOutputTester(ITestOutputHelper output)
{
var repo = LogManager.GetRepository(typeof(INettyBootstrapper).GetTypeInfo().Assembly);
XmlConfigurator.Configure(repo, new FileInfo("log4net.config"));
InternalLoggerFactory.DefaultFactory.AddProvider(new Log4NetProvider(repo));
var root = ((Hierarchy)repo).Root;
_attachable = root;
_appender = new TestOutputAppender(output);
_attachable?.AddAppender(_appender);
}
public Log4NetInMemoryStreamAppenderManager()
{
_loggerRoot = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
_memoryAppender = new MemoryAppender
{
Threshold = Level.All,
Name = this.GetType().Name,
Layout = new PatternLayout("{message}")
};
if (_loggerRoot != null)
{
_loggerRoot.AddAppender(_memoryAppender);
}
}
/// <summary>
/// Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable" /> container
/// </summary>
/// <param name="appenderList"></param>
/// <param name="container"></param>
private static void CollectAppenders(ArrayList appenderList, IAppenderAttachable container)
{
AppenderCollection.IAppenderCollectionEnumerator enumerator = container.Appenders.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
IAppender current = enumerator.Current;
CollectAppender(appenderList, current);
}
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
}
protected virtual void AddAppender(IAppender profilerAppender, IAppenderAttachable logger)
{
IAppender appender;
do {
appender = logger.GetAppender(profilerAppender.Name);
if (appender != null) {
try {
logger.RemoveAppender(appender);
}
catch (Exception) { }
}
}
while (appender != null);
logger.AddAppender(profilerAppender);
}
/// <summary>
/// Opens session logger
/// </summary>
public void OpenSessionLogger()
{
connectionAppender = (IAppenderAttachable)log.Logger;
fileAppender = new FileAppender();
fileAppender.File = sessionFileName;
fileAppender.AppendToFile = true;
fileAppender.ImmediateFlush = false;
PatternLayout patternLayout =
new PatternLayout("%date{yyyy-MM-dd HH:mm:ss,fff} [%thread] %-5level %message%newline");
fileAppender.Layout = patternLayout;
fileAppender.ActivateOptions();
connectionAppender.AddAppender(fileAppender);
}
// ------------------------------------------------------------------------------------
private void _BeginStoreLogMessages()
{
logMessages = new StringBuilder(8192);
appenderLogMessages = new TextWriterAppender();
appenderLogMessages.ImmediateFlush = true;
appenderLogMessages.Layout = new log4net.Layout.PatternLayout("%date %-5level %message%newline");
appenderLogMessages.Writer = new StringWriter(logMessages);
appenderLogMessages.Threshold = Level.Info;
IAppenderAttachable appender_attachable = log.Logger as IAppenderAttachable;
if (appender_attachable != null)
{
appender_attachable.AddAppender(appenderLogMessages);
}
appenderLogMessages.ActivateOptions();
}
private void CreateAppenderForLogger(string csvHeader, string fileName, IAppenderAttachable myLogger)
{
var appender = new RollingFileAppender
{
File = fileName,
AppendToFile = true,
Layout = new PatternLayout("%message%newline")
{
Header = csvHeader + Environment.NewLine
},
MaxFileSize = maxFileSize,
MaxSizeRollBackups = rollBackups,
RollingStyle = RollingFileAppender.RollingMode.Size
};
appender.ActivateOptions();
myLogger.AddAppender(appender);
BasicConfigurator.Configure(appender);
}
private void CreateAppenderForLogger(string csvHeader, string fileName, IAppenderAttachable myLogger)
{
var appender = new RollingFileAppender
{
File = fileName,
AppendToFile = true,
Layout = new PatternLayout("%message%newline")
{
Header = csvHeader + Environment.NewLine
},
MaxFileSize = maxFileSize,
MaxSizeRollBackups = rollBackups,
RollingStyle = RollingFileAppender.RollingMode.Size
};
appender.ActivateOptions();
myLogger.AddAppender(appender);
BasicConfigurator.Configure(appender);
}
protected virtual IEnumerable <string> GetLoggerFiles(IAppenderAttachable logger)
{
return(logger.Appenders.OfType <PluginRollingFileAppender>().Select(x => x.File));
}
/// <summary>
/// Parses an appender element.
/// </summary>
/// <param name="appenderElement">The appender element.</param>
/// <returns>The appender instance or <c>null</c> when parsing failed.</returns>
/// <remarks>
/// <para>
/// Parse an XML element that represents an appender and return
/// the appender instance.
/// </para>
/// </remarks>
protected IAppender ParseAppender(XmlElement appenderElement)
{
string appenderName = appenderElement.GetAttribute(NAME_ATTR);
string typeName = appenderElement.GetAttribute(TYPE_ATTR);
LogLog.Debug(declaringType, "Loading Appender [" + appenderName + "] type: [" + typeName + "]");
try
{
IAppender appender = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true));
appender.Name = appenderName;
foreach (XmlNode currentNode in appenderElement.ChildNodes)
{
/* We're only interested in Elements */
if (currentNode.NodeType == XmlNodeType.Element)
{
XmlElement currentElement = (XmlElement)currentNode;
// Look for the appender ref tag
if (currentElement.LocalName == APPENDER_REF_TAG)
{
string refName = currentElement.GetAttribute(REF_ATTR);
IAppenderAttachable appenderContainer = appender as IAppenderAttachable;
if (appenderContainer != null)
{
LogLog.Debug(declaringType, "Attaching appender named [" + refName + "] to appender named [" + appender.Name + "].");
IAppender referencedAppender = FindAppenderByReference(currentElement);
if (referencedAppender != null)
{
appenderContainer.AddAppender(referencedAppender);
}
}
else
{
LogLog.Error(declaringType, "Requesting attachment of appender named [" + refName + "] to appender named [" + appender.Name + "] which does not implement log4net.Core.IAppenderAttachable.");
}
}
else
{
// For all other tags we use standard set param method
SetParameter(currentElement, appender);
}
}
}
IOptionHandler optionHandler = appender as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
LogLog.Debug(declaringType, "Created Appender [" + appenderName + "]");
return(appender);
}
catch (Exception ex)
{
// Yes, it's ugly. But all exceptions point to the same problem: we can't create an Appender
LogLog.Error(declaringType, "Could not create Appender [" + appenderName + "] of type [" + typeName + "]. Reported error follows.", ex);
return(null);
}
}
/// <summary>
/// Collect the appenders from an <see cref="IAppenderAttachable"/> container
/// </summary>
/// <param name="appenderList"></param>
/// <param name="container"></param>
static void CollectAppenders(ArrayList appenderList, IAppenderAttachable container) {
foreach (IAppender appender in container.Appenders)
CollectAppender(appenderList, appender);
}
/// <summary>
/// Collect the appenders from an <see cref="IAppenderAttachable"/> container
/// </summary>
/// <param name="appenderList"></param>
/// <param name="container"></param>
private static void CollectAppenders(System.Collections.ArrayList appenderList, IAppenderAttachable container)
{
foreach (Appender.IAppender appender in container.Appenders)
{
CollectAppender(appenderList, appender);
}
}
private static bool HasQueryAppender(IAppenderAttachable logger)
{
foreach (IAppender appender in logger.Appenders)
{
if (appender is QueryAppender)
return true;
}
return false;
}
protected IAppender ParseAppender(XmlElement appenderElement)
{
string attribute = appenderElement.GetAttribute("name");
string typeName = appenderElement.GetAttribute("type");
string[] textArray1 = new string[] { "Loading Appender [", attribute, "] type: [", typeName, "]" };
LogLog.Debug(declaringType, string.Concat(textArray1));
try
{
IAppender target = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true));
target.Name = attribute;
IEnumerator enumerator = appenderElement.ChildNodes.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
XmlNode current = (XmlNode)enumerator.Current;
if (current.NodeType == XmlNodeType.Element)
{
XmlElement element = (XmlElement)current;
if (element.LocalName != "appender-ref")
{
this.SetParameter(element, target);
continue;
}
string str3 = element.GetAttribute("ref");
IAppenderAttachable attachable = target as IAppenderAttachable;
if (attachable == null)
{
string[] textArray3 = new string[] { "Requesting attachment of appender named [", str3, "] to appender named [", target.Name, "] which does not implement log4net.Core.IAppenderAttachable." };
LogLog.Error(declaringType, string.Concat(textArray3));
continue;
}
string[] textArray2 = new string[] { "Attaching appender named [", str3, "] to appender named [", target.Name, "]." };
LogLog.Debug(declaringType, string.Concat(textArray2));
IAppender appender2 = this.FindAppenderByReference(element);
if (appender2 != null)
{
attachable.AddAppender(appender2);
}
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
IOptionHandler handler = target as IOptionHandler;
if (handler != null)
{
handler.ActivateOptions();
}
LogLog.Debug(declaringType, "Created Appender [" + attribute + "]");
return(target);
}
catch (Exception exception)
{
string[] textArray4 = new string[] { "Could not create Appender [", attribute, "] of type [", typeName, "]. Reported error follows." };
LogLog.Error(declaringType, string.Concat(textArray4), exception);
return(null);
}
}
/// <summary>
/// Collect the appenders from an <see cref="IAppenderAttachable"/> container
/// </summary>
/// <param name="appenderList"></param>
/// <param name="container"></param>
private static void CollectAppenders(System.Collections.ArrayList appenderList, IAppenderAttachable container)
{
foreach(log4net.Appender.IAppender appender in container.Appenders)
{
CollectAppender(appenderList, appender);
}
}
private static void CheckAppenders(IAppenderAttachable logger, string accountName, string profileName)
{
logger.Appenders.Should(Be.Not.Empty);
logger.Appenders.OfType<PluginRollingFileAppender>().Should(Be.Not.Empty);
var appender = logger.Appenders.OfType<PluginRollingFileAppender>().First();
appender.File.Contains(accountName).Should(Be.True);
appender.File.Contains(profileName).Should(Be.True);
}
