/// <summary>
/// Configures logging to a specified level, optionally directing log output to a particular
/// IAppender instance.
/// </summary>
/// <param name="verbose">If true, informational messages should be logged.</param>
/// <param name="debug">If true, diagnostic and trace-level messages should be logged.</param>
/// <param name="appender">An IAppender to which log traffic should be directed. If absent, a default
/// is used.</param>
public static void Configure(bool verbose, bool debug, IAppender appender = null)
{
if (appender != null)
{
BasicConfigurator.Configure(appender);
}
else
{
// Just take the default
BasicConfigurator.Configure();
}
var hierarchy = log4net.LogManager.GetRepository() as log4net.Repository.Hierarchy.Hierarchy;
if (debug)
{
hierarchy.Root.Level = log4net.Core.Level.Debug;
}
else if (verbose)
{
hierarchy.Root.Level = log4net.Core.Level.Info;
}
else
{
hierarchy.Root.Level = log4net.Core.Level.Error;
}
}
private void AddAppenders(IAppender[] appenders)
{
foreach (IAppender appender in appenders)
{
this.Appenders.Add(appender);
}
}
public void AddAppender(IAppender appender)
{
Hierarchy hierarchy =
(Hierarchy)LogManager.GetRepository();
hierarchy.Root.AddAppender(appender);
}
public Logger(IAppender appender, IAppender appenderTwo, IAppender appenderThree)
{
this.appenders = new List<IAppender>();
this.Appenders = appender;
this.Appenders = appenderTwo;
this.Appenders = appenderThree;
}
/// <summary>
/// Add an appender to a logger.
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <param name="appender">The appender.</param>
public static void AddAppender( string loggerName, IAppender appender )
{
ILog log = LogManager.GetLogger( loggerName );
var l = (Logger)log.Logger;
l.AddAppender( appender );
}
private void InitAppenders(IAppender[] appenders)
{
for (int i = 0; i < appenders.Length; i++)
{
this.appenders[i] = appenders[i];
}
}
/*
public static ILog MyLogger {
get {
return LogManager.GetLogger(MyLoggerName);
}
}
*/
private static void AddAppender(string loggerName, IAppender appender) {
var log = LogManager.GetLogger(loggerName);
var logger = (Logger)log.Logger;
logger.AddAppender(appender);
logger.Repository.Configured = true;
}
public static void AddAppender(IAppender initAppender)
{
appender.Add(initAppender);
foreach (ILog aLog in log)
{
((Log)aLog).AddAppender(initAppender);
}
}
private void SetAppenderFixFlags(IAppender appender)
{
var bufferingAppender = appender as BufferingAppenderSkeleton;
if (bufferingAppender != null)
{
bufferingAppender.Fix = Fix;
}
}
public Logger(IAppender baseapender, params IAppender[] moreappenders)
{
this.Appenders = new List<IAppender>();
this.Appenders.Add(baseapender);
foreach (var appender in moreappenders)
{
this.Appenders.Add(appender);
}
}
public FallbackAppenderProxyBase(IAppender appenderToWrap)
{
var convertedAppender = appenderToWrap as AppenderSkeleton;
if (convertedAppender == null)
throw new InvalidOperationException("cannot use IndefiniteAppenderProxy with an appender that does not inherit from AppenderSkeleton as it needs to hook into the IErrorHandler, to gather errors.");
innerAppender = convertedAppender;
errorHandler = new RecordingErrorHandler(GetType().Name);
convertedAppender.ErrorHandler = errorHandler;
}
public void AddAppender(IAppender appender)
{
int size = this.Appenders.Length;
int newSize = size + 1;
IAppender[] tmp = new IAppender[newSize];
Array.Copy(this.Appenders, 0, tmp, 0, size);
this.Appenders = tmp;
this.Appenders[newSize - 1] = appender;
}
public void Dispose()
{
try
{
if (_appender != null)
{
((log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository()).Root.RemoveAppender(_appender);
}
}
catch
{ }
_appender = null;
}
public static void addLogAppender(IAppender appender)
{
if (appender == null)
{
string msg = UException.getExceptionMessage("AppGlobal", "addLogAppender", "An IAppender object is required");
logAndThrowException(new ArgumentNullException(msg), msg);
}
loadLoggers();
log4net.Repository.Hierarchy.Logger log = (log4net.Repository.Hierarchy.Logger)logger.Logger;
log.AddAppender(appender);
}
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>
/// Attaches an appender.
/// </summary>
/// <param name="newAppender">The appender to add.</param>
/// <remarks>
/// If the appender is already in the list it won't be added again.
/// </remarks>
public void AddAppender(IAppender newAppender)
{
// Null values for newAppender parameter are strictly forbidden.
if (newAppender == null)
{
throw new ArgumentNullException("newAppender");
}
if (m_appenderList == null)
{
m_appenderList = new AppenderCollection(1);
}
if (!m_appenderList.Contains(newAppender))
{
m_appenderList.Add(newAppender);
}
}
public OneHydraLogger(string loggerName, IConfigManagerHelper config)
{
var hier = LogManager.GetRepository() as Hierarchy;
// If we have the setting in the configuration set the log level. Otherwise, default to only errors and fatal
// debug messages.
if (hier != null)
{
var logLevel = hier.LevelMap["ERROR"];
var configLogLevel = config.GetAppSetting("OneHydraLogLevel");
if (configLogLevel != null)
{
logLevel = hier.LevelMap[configLogLevel.ToUpper()];
}
// Only do this once when the first instance is created. After that, the adoAppender should be available
// to all subsequent instantiations. We're also only setting the log level for the entire configuration once.
// If subsequently, someone uses log4net and usurps the hierarchy in the architecture, it could change the log level.
lock (ConfigureLock)
{
if (_adoAppender == null)
{
_adoAppender = GetAdoAppender(config);
log4net.Config.BasicConfigurator.Configure(_adoAppender);
ILogger[] loggers = hier.GetCurrentLoggers();
foreach (var logger in loggers)
{
((Logger)logger).Level = logLevel;
}
//Configure the root logger.
Logger rootLogger = hier.Root;
rootLogger.Level = logLevel;
}
}
// Set the appender and log level for this instance. We know they should already be configured.
var loggerToConfigure = hier.GetLogger(loggerName, hier.LoggerFactory);
if (loggerToConfigure != null)
{
loggerToConfigure.Level = logLevel;
_logger = LogManager.GetLogger(loggerName);
}
}
}
/// <summary>
/// Add <paramref name="newAppender"/> to the list of appenders of this
/// Logger instance.
/// </summary>
/// <param name="newAppender">An appender to add to this logger</param>
/// <remarks>
/// <para>
/// Add <paramref name="newAppender"/> to the list of appenders of this
/// Logger instance.
/// </para>
/// <para>
/// If <paramref name="newAppender"/> is already in the list of
/// appenders, then it won't be added again.
/// </para>
/// </remarks>
virtual public void AddAppender(IAppender newAppender)
{
if (newAppender == null)
{
throw new ArgumentNullException("newAppender");
}
m_appenderLock.AcquireWriterLock();
try {
if (m_appenderAttachedImpl == null)
{
m_appenderAttachedImpl = new GodLesZ.Library.Logging.Util.AppenderAttachedImpl();
}
m_appenderAttachedImpl.AddAppender(newAppender);
} finally {
m_appenderLock.ReleaseWriterLock();
}
}
/// <summary>
/// Inserts an element into the <c>AppenderCollection</c> at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The <see cref="IAppender"/> to insert.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="index"/> is less than zero.</para>
/// <para>-or-</para>
/// <para><paramref name="index"/> is equal to or greater than <see cref="AppenderCollection.Count"/>.</para>
/// </exception>
public virtual void Insert(int index, IAppender item)
{
this.ValidateIndex(index, true); // throws
if (this.m_count == this.m_array.Length)
{
this.EnsureCapacity(this.m_count + 1);
}
if (index < this.m_count)
{
Array.Copy(this.m_array, index, this.m_array, index + 1, this.m_count - index);
}
this.m_array[index] = item;
this.m_count++;
this.m_version++;
}
private BuilderContext(IBuilder builder, Builtin builtin, BuilderSettings settings, int depth, object owner, PluginTreeNode ownerNode)
{
_builder = builder ?? throw new ArgumentNullException(nameof(builder));
_builtin = builtin ?? throw new ArgumentNullException(nameof(builtin));
_appender = builder as IAppender;
_settings = settings;
_depth = depth;
_owner = owner;
_ownerNode = ownerNode;
if (builtin.HasBehaviors)
{
_cancel = builtin.Behaviors.GetBehaviorValue <bool>(builtin.Scheme + ".break");
}
_syncRoot = new object();
}
/// <summary>
/// Attaches an appender.
/// </summary>
/// <param name="newAppender">The appender to add.</param>
/// <remarks>
/// <para>
/// If the appender is already in the list it won't be added again.
/// </para>
/// </remarks>
public void AddAppender(IAppender newAppender)
{
// Null values for newAppender parameter are strictly forbidden.
if (newAppender == null)
{
throw new ArgumentNullException("newAppender");
}
m_appenderArray = null;
if (m_appenderList == null)
{
m_appenderList = new AppenderCollection(1);
}
if (!m_appenderList.Contains(newAppender))
{
m_appenderList.Add(newAppender);
}
}
private IAppender[] ReadAppenders(int n)
{
IAppender[] appenders = new IAppender[n];
for (int i = 0; i < n; i++)
{
string[] appenderParts = reader.ReadLine().Split();
string appenderType = appenderParts[0];
string layoutType = appenderParts[1];
ReportLevel reportLevel = appenderParts.Length == 3 ? Enum.Parse <ReportLevel>(appenderParts[2], true) : ReportLevel.Info;
ILayout layout = layoutFactory.CreateFactory(layoutType);
IAppender appender = appenderFactory.CreateAppender(appenderType, layout, reportLevel);
appenders[i] = appender;
}
return(appenders);
}
/// <summary>
/// 附加一个附加器.
/// </summary>
/// <param name="newAppender">要附加的附加器.</param>
/// <remarks>
/// <para>
/// 如果存在则不再添加.
/// </para>
/// </remarks>
public void AddAppender(IAppender newAppender)
{
if (newAppender == null)
{
throw new ArgumentNullException("没有附加器");
}
m_appenderArray = null;
if (m_appenderList == null)
{
m_appenderList = new AppenderCollection(1);
}
if (!m_appenderList.Contains(newAppender))
{
m_appenderList.Add(newAppender);
}
}
/// <summary>
/// Inserts an element into the <c>AppenderCollection</c> at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The <see cref="IAppender"/> to insert.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="index"/> is less than zero</para>
/// <para>-or-</para>
/// <para><paramref name="index"/> is equal to or greater than <see cref="AppenderCollection.Count"/>.</para>
/// </exception>
public virtual void Insert(int index, IAppender item)
{
ValidateIndex(index, true); // throws
if (m_count == m_array.Length)
{
EnsureCapacity(m_count + 1);
}
if (index < m_count)
{
Array.Copy(m_array, index, m_array, index + 1, m_count - index);
}
m_array[index] = item;
m_count++;
m_version++;
}
/// <summary>
/// Removes the element at the specified index of the <c>AppenderCollection</c>.
/// </summary>
/// <param name="index">The zero-based index of the element to remove.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="index"/> is less than zero</para>
/// <para>-or-</para>
/// <para><paramref name="index"/> is equal to or greater than <see cref="AppenderCollection.Count"/>.</para>
/// </exception>
public virtual void RemoveAt(int index)
{
ValidateIndex(index); // throws
m_count--;
if (index < m_count)
{
Array.Copy(m_array, index + 1, m_array, index, m_count - index);
}
// We can't set the deleted entry equal to null, because it might be a value type.
// Instead, we'll create an empty single-element array of the right type and copy it
// over the entry we want to erase.
IAppender[] temp = new IAppender[1];
Array.Copy(temp, 0, m_array, m_count, 1);
m_version++;
}
public CedrusGame(IocBuilder builder)
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
builder.LogRegistrations();
builder.RegisterModules(Assembly.GetExecutingAssembly(), type => type.FullName.EndsWith("Module"));
builder.RegisterSingleton(c => graphics.GraphicsDevice);
builder.RegisterSingleton(c => new GameSettings(Window));
builder.RegisterSingleton(c => Content);
EnumerateAssemblies(assembly => builder.RegisterSingletonSubclassesOf(assembly, typeof(CommonAssetBuilder)));
container = builder.Build();
gameTimeline = container.Resolve <GameTimeline>();
Appender = container.Resolve <IAppender>()[GetType()];
}
public void AddAppender(string[] args)
{
string appenderType = args[0];
string layoutType = args[1];
ReportLevel reportLevel = ReportLevel.INFO;
if (args.Length == 3)
{
reportLevel = Enum.Parse <ReportLevel>(args[2]);
}
ILayout layout = this.layoutFactory.CretaeLayout(layoutType);
IAppender appender = this.appenderFactory.CreateAppender(appenderType, layout);
appender.ReportLevel = reportLevel;
this.appenders.Add(appender);
}
public OneHydraLogger(string loggerName, IConfigManagerHelper config)
{
var hier = LogManager.GetRepository() as Hierarchy;
// If we have the setting in the configuration set the log level. Otherwise, default to only errors and fatal
// debug messages.
if (hier != null)
{
var logLevel = hier.LevelMap["ERROR"];
var configLogLevel = config.GetAppSetting("OneHydraLogLevel");
if (configLogLevel != null)
{
logLevel = hier.LevelMap[configLogLevel.ToUpper()];
}
// Only do this once when the first instance is created. After that, the adoAppender should be available
// to all subsequent instantiations. We're also only setting the log level for the entire configuration once.
// If subsequently, someone uses log4net and usurps the hierarchy in the architecture, it could change the log level.
lock (ConfigureLock)
{
if (_adoAppender == null)
{
_adoAppender = GetAdoAppender(config);
log4net.Config.BasicConfigurator.Configure(_adoAppender);
ILogger[] loggers = hier.GetCurrentLoggers();
foreach (var logger in loggers)
{
((Logger)logger).Level = logLevel;
}
//Configure the root logger.
Logger rootLogger = hier.Root;
rootLogger.Level = logLevel;
}
}
// Set the appender and log level for this instance. We know they should already be configured.
var loggerToConfigure = hier.GetLogger(loggerName, hier.LoggerFactory);
if (loggerToConfigure != null)
{
loggerToConfigure.Level = logLevel;
_logger = LogManager.GetLogger(loggerName);
}
}
}
/// <summary>
/// Parses the children of a logger element.
/// </summary>
/// <param name="catElement">The category element.</param>
/// <param name="log">The logger instance.</param>
/// <param name="isRoot">Flag to indicate if the logger is the root logger.</param>
/// <remarks>
/// <para>
/// Parse the child elements of a <logger> element.
/// </para>
/// </remarks>
protected void ParseChildrenOfLoggerElement(XmlElement catElement, Logger log, bool isRoot)
{
// Remove all existing appenders from log. They will be
// reconstructed if need be.
log.RemoveAllAppenders();
foreach (XmlNode currentNode in catElement.ChildNodes)
{
if (currentNode.NodeType == XmlNodeType.Element)
{
XmlElement currentElement = (XmlElement)currentNode;
if (currentElement.LocalName == APPENDER_REF_TAG)
{
IAppender appender = FindAppenderByReference(currentElement);
string refName = currentElement.GetAttribute(REF_ATTR);
if (appender != null)
{
LogLog.Debug(declaringType, "Adding appender named [" + refName + "] to logger [" + log.Name + "].");
log.AddAppender(appender);
}
else
{
LogLog.Error(declaringType, "Appender named [" + refName + "] not found.");
}
}
else if (currentElement.LocalName == LEVEL_TAG || currentElement.LocalName == PRIORITY_TAG)
{
ParseLevel(currentElement, log, isRoot);
}
else
{
SetParameter(currentElement, log);
}
}
}
IOptionHandler optionHandler = log as IOptionHandler;
if (optionHandler != null)
{
optionHandler.ActivateOptions();
}
}
public IAppender CreateAppender(string[] args)
{
string appenderType = args[0];
string layoutType = args[1];
LayoutFactory layoutFactory = new LayoutFactory();
ILayout layout = layoutFactory.CreateLayout(layoutType);
IAppender appender = null;
if (args.Length == 2)
{
switch (appenderType)
{
case "ConsoleAppender": appender = new ConsoleAppender(layout); break;
case "FileAppender": appender = new FileAppender(layout); break;
default:
throw new ArgumentException("Invalid Appender Type!");
}
}
else
{
string reportType = args[2];
if (!Enum.TryParse(typeof(ReportLevel), reportType, true, out object reportLevelObj))
{
throw new ArgumentException("Invalid Report Level!");
}
ReportLevel reportLevelThreshold = (ReportLevel)reportLevelObj;
switch (appenderType)
{
case "ConsoleAppender": appender = new ConsoleAppender(layout, reportLevelThreshold); break;
case "FileAppender": appender = new FileAppender(layout, reportLevelThreshold); break;
default:
throw new ArgumentException("Invalid Appender Type!");
}
}
return(appender);
}
/// <summary>
/// Parse appenders by IDREF.
/// </summary>
/// <param name="appenderRef">The appender ref element.</param>
/// <returns>The instance of the appender that the ref refers to.</returns>
/// <remarks>
/// <para>
/// Parse an XML element that represents an appender and return
/// the appender.
/// </para>
/// </remarks>
protected IAppender FindAppenderByReference(XmlElement appenderRef)
{
string appenderName = appenderRef.GetAttribute(REF_ATTR);
IAppender appender = (IAppender)this.m_appenderBag[appenderName];
if (appender != null)
{
return(appender);
}
else
{
// Find the element with that id
XmlElement element = null;
if (appenderName != null && appenderName.Length > 0)
{
foreach (XmlElement curAppenderElement in appenderRef.OwnerDocument.GetElementsByTagName(APPENDER_TAG))
{
if (curAppenderElement.GetAttribute("name") == appenderName)
{
element = curAppenderElement;
break;
}
}
}
if (element == null)
{
LogLog.Error(declaringType, "XmlHierarchyConfigurator: No appender named [" + appenderName + "] could be found.");
return(null);
}
else
{
appender = this.ParseAppender(element);
if (appender != null)
{
this.m_appenderBag[appenderName] = appender;
}
return(appender);
}
}
}
private void SetupLogger()
{
int numberOfAppenders = int.Parse(Console.ReadLine());
ICollection <IAppender> appenders = new List <IAppender>();
for (int i = 0; i < numberOfAppenders; i++)
{
string[] layoutArgs = Console.ReadLine().Split();
string appenderType = layoutArgs[0];
string layoutType = layoutArgs[1];
string reportLevelAsString = layoutArgs.Length == 3 ? layoutArgs[2] : "info";
ReportLevel reportLevel = this.reportLevelFactory.Create(reportLevelAsString);
ILayout layout = this.layoutFactory.Create(layoutType);
IAppender appender = this.appenderFactory.Create(appenderType, reportLevel, layout);
this.logger.AddAppender(appender);
}
}
public IAppender CreateAppender(string appenderName, string layoutName)
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
ILayout layout = this.layoutFactory.CreateLayout(layoutName);
Type appenderType = types.FirstOrDefault(t => t.Name.Equals(appenderName));
if (appenderType == null)
{
throw new ArgumentException("Invalid Appender Type!");
}
IAppender appender = (IAppender)Activator.CreateInstance(appenderType, new object[] { layout });
this.InjectDependencies(appenderType, appender);
return(appender);
}
public static void RemoveUdpAppender()
{
var repositroy = (Hierarchy)log4net.LogManager.GetRepository();
if (!repositroy.Configured)
{
return;
}
var root = repositroy.Root;
IAppender udpAppender = root.GetAppender("UdpAppender");
if (null != udpAppender)
{
root.RemoveAppender(udpAppender);
repositroy.Configured = true;
repositroy.RaiseConfigurationChanged(EventArgs.Empty);
}
}
public void AddAppender(string[] input)
{
var typeAppender = input[0];
var typeLayout = input[1];
ReportLevel reportLevel = ReportLevel.INFO;
if (input.Length == 3)
{
reportLevel = Enum.Parse <ReportLevel>(input[2]);
}
ILayout layout = this.layoutFactory.CreateLayout(typeLayout);
IAppender appender = this.appenderFactory.CreateAppender(typeAppender, layout);
appender.ReportLevel = reportLevel;
appenders.Add(appender);
}
private void ParseInput()
{
int number = int.Parse(Console.ReadLine());
for (int i = 0; i < number; i++)
{
string[] inputParts = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
ILayout layout = this.layoutFactory.CreateLayout(inputParts[1]);
IAppender appender = this.appenderFactory.CreateAppender(inputParts[0], layout);
if (inputParts.Length > 2)
{
string reportLevel = this.GetTitleCase(inputParts[2]);
appender.ReportLevel = Enum.Parse <ReportLevel>(reportLevel);
}
this.appenders.Add(appender);
}
}
/// <summary>
/// Parse appenders by IDREF.
/// </summary>
/// <param name="appenderRef">The appender ref element.</param>
/// <returns>The instance of the appender that the ref refers to.</returns>
protected IAppender FindAppenderByReference(XmlElement appenderRef)
{
string appenderName = appenderRef.GetAttribute(REF_ATTR);
IAppender appender = (IAppender)m_appenderBag[appenderName];
if (appender != null)
{
return(appender);
}
else
{
// Find the element with that id
XmlElement element = null;
if (appenderName != null && appenderName.Length > 0)
{
foreach (XmlNode node in appenderRef.OwnerDocument.GetElementsByTagName(APPENDER_TAG))
{
if (((XmlElement)node).GetAttribute("name") == appenderName)
{
element = (XmlElement)node;
break;
}
}
}
if (element == null)
{
LogLog.Error("DOMConfigurator: No appender named [" + appenderName + "] could be found.");
return(null);
}
else
{
appender = ParseAppender(element);
if (appender != null)
{
m_appenderBag[appenderName] = appender;
}
return(appender);
}
}
}
private static void SetLogAppender(IAppender appender, Level level, bool additive)
{
Hierarchy hierarchy = LogManager.GetRepository() as Hierarchy;
if (hierarchy != null)
{
if (!additive)
{
hierarchy.Root.RemoveAllAppenders();
}
hierarchy.Root.AddAppender(appender);
hierarchy.Threshold = level;
hierarchy.Configured = true;
}
else
{
throw new AdkException("Unable to initialize log4net framework", null);
}
}
public void Run()
{
int numOfAppenders = int.Parse(reader.ReadLine());
for (int i = 0; i < numOfAppenders; i++)
{
var infoArgs = reader.ReadLine().Split();
IAppender currentAppender = GetAppender(infoArgs);
var logger = new Logger(currentAppender);
loggersList.Add(logger);
}
var logInfo = reader.ReadLine().Split('|');
while (logInfo[0] != "END")
{
var reportLevel = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(logInfo[0].ToLower());
var date = logInfo[1];
var msg = logInfo[2];
var parameters = new string[] { date, msg };
foreach (var logger in this.loggersList)
{
foreach (var method in loggerMethods.Where(n => n.Name == reportLevel))
{
method.Invoke(logger, parameters);
}
}
logInfo = reader.ReadLine().Split('|');
}
//Layout write
foreach (var log in loggersList)
{
log.LayoutOutput();
}
writer.WriteLine("Logger info");
foreach (var logger in loggersList)
{
logger.InfoSummary();
}
}
public void AddAppender(params string[] args)
{
string typeAppender = args[0];
string typeLayout = args[1];
ILayout currentLayout = layoutFactory.GenerateLayout(typeLayout);
ReportLevel level = ReportLevel.INFO;
if (args.Length == 3)
{
Enum.TryParse(args[2], true, out ReportLevel lvl);
level = lvl;
}
IAppender appender = appenderFactory.GenerateFactory(typeAppender, currentLayout, level);
appenders.Add(appender);
}
private void InjectDependencies(Type appenderType, IAppender appender)
{
FieldInfo[] appenderFields = appenderType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
FieldInfo[] factoryFields = this.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo appenderField in appenderFields)
{
if (appenderField.GetCustomAttributes(typeof(InjectAttribute)) == null)
{
continue;
}
if (factoryFields.Any(ifield => ifield.FieldType.Equals(appenderField.FieldType)))
{
string filePath = Path.Combine(Environment.CurrentDirectory, this.defaultFileName);
appenderField.SetValue(appender, filePath);
break;
}
}
}
public void AddAppender(params string[] arguments)
{
string typeAppender = arguments[0];
string typeLayout = arguments[1];
ReportLevel reportLevel = ReportLevel.INFO;
if (arguments.Length == 3)
{
reportLevel = Enum.Parse <ReportLevel>(arguments[2]);
}
ILayout layout = this.layoutFactory.CreateLayout(typeLayout);
IAppender appender = this.appenderFactory.CreateAppender(typeAppender, layout);
appender.ReportLevel = reportLevel;
appenders.Add(appender);
}
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
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
public static ICollection Configure(ILoggerRepository repository)
{
ArrayList items = new ArrayList();
using (new LogLog.LogReceivedAdapter(items))
{
PatternLayout layout = new PatternLayout {
ConversionPattern = "%timestamp [%thread] %level %logger %ndc - %message%newline"
};
layout.ActivateOptions();
ConsoleAppender appender = new ConsoleAppender {
Layout = layout
};
appender.ActivateOptions();
IAppender[] appenders = new IAppender[] { appender };
InternalConfigure(repository, appenders);
}
repository.ConfigurationMessages = items;
return(items);
}
/// <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);
try
{
IAppender appender = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true));
appender.Name = appenderName;
foreach (XmlNode currnode in appenderelement.ChildNodes)
{
if (currnode.NodeType != XmlNodeType.Element)
{
continue;
}
if (currnode.LocalName == APPENDER_REF_TAG)
{
}
else
{
SetParameter((XmlElement)currnode, 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);
}
}
private static void AddAppenders(List <IAppender> appenders, int numAppenders)
{
for (int i = 0; i < numAppenders; i++)
{
var appenderTokens = CreateStringArray(' ');
var appenderType = appenderTokens[0];
var layoutType = appenderTokens[1];
var inputReportLevel = appenderTokens.Length > 2 ? appenderTokens[2] : string.Empty;
ILayout layout = GetLayoutType(layoutType);
IAppender appender = GetAppenderType(appenderType, layout);
if (inputReportLevel != string.Empty)
{
AssignAppenderMinLevel(inputReportLevel, appender);
}
appenders.Add(appender);
}
}
public IAppender[] ReadAppenders()
{
int appendersCount = int.Parse(this.inputReader.ReadLine());
IAppender[] appenders = new IAppender[appendersCount];
for (int i = 0; i < appendersCount; i++)
{
string[] appenderParams = this.inputReader
.ReadLine()
.Split(AppenderParamsSeparator);
IAppender appender = this.appenderFactory.CreateAppender(
appenderParams,
this.layoutFactory);
appenders[i] = appender;
}
return(appenders);
}
public CommandManager(IPerformanceDatabase database, IAppender appender)
{
this.database = database;
this.appender = appender;
}
/// <summary>
/// Remove the appender passed as parameter form the list of appenders.
/// </summary>
/// <param name="appender">The appender to remove</param>
/// <returns>The appender removed from the list</returns>
/// <remarks>
/// <para>
/// Remove the appender passed as parameter form the list of appenders.
/// The appender removed is not closed.
/// If you are discarding the appender you must call
/// <see cref="IAppender.Close"/> on the appender removed.
/// </para>
/// </remarks>
virtual public IAppender RemoveAppender(IAppender appender)
{
m_appenderLock.AcquireWriterLock();
try
{
if (appender != null && m_appenderAttachedImpl != null)
{
return m_appenderAttachedImpl.RemoveAppender(appender);
}
}
finally
{
m_appenderLock.ReleaseWriterLock();
}
return null;
}
/// <summary>
/// Add <paramref name="newAppender"/> to the list of appenders of this
/// Logger instance.
/// </summary>
/// <param name="newAppender">An appender to add to this logger</param>
/// <remarks>
/// <para>
/// Add <paramref name="newAppender"/> to the list of appenders of this
/// Logger instance.
/// </para>
/// <para>
/// If <paramref name="newAppender"/> is already in the list of
/// appenders, then it won't be added again.
/// </para>
/// </remarks>
virtual public void AddAppender(IAppender newAppender)
{
if (newAppender == null)
{
throw new ArgumentNullException("newAppender");
}
m_appenderLock.AcquireWriterLock();
try
{
if (m_appenderAttachedImpl == null)
{
m_appenderAttachedImpl = new log4net.Util.AppenderAttachedImpl();
}
m_appenderAttachedImpl.AddAppender(newAppender);
}
finally
{
m_appenderLock.ReleaseWriterLock();
}
}
/// <summary>
/// Removes the specified appender from the list of appenders.
/// </summary>
/// <param name="appender">The appender to remove.</param>
/// <returns>The appender removed from the list</returns>
/// <remarks>
/// The appender removed is not closed.
/// If you are discarding the appender you must call
/// <see cref="IAppender.Close"/> on the appender removed.
/// </remarks>
virtual public IAppender RemoveAppender(IAppender appender)
{
lock(this)
{
if (appender != null && m_appenderAttachedImpl != null)
{
return m_appenderAttachedImpl.RemoveAppender(appender);
}
}
return null;
}
/// <summary>
/// Adds an <see cref="IAppender" /> to the list of appenders of this
/// instance.
/// </summary>
/// <param name="newAppender">The <see cref="IAppender" /> to add to this appender.</param>
/// <remarks>
/// <para>
/// If the specified <see cref="IAppender" /> is already in the list of
/// appenders, then it won't be added again.
/// </para>
/// </remarks>
virtual public void AddAppender(IAppender newAppender)
{
if (newAppender == null)
{
throw new ArgumentNullException("newAppender");
}
lock(this)
{
if (m_appenderAttachedImpl == null)
{
m_appenderAttachedImpl = new log4net.Util.AppenderAttachedImpl();
}
m_appenderAttachedImpl.AddAppender(newAppender);
}
}
public override int AddRange(IAppender[] x)
{
throw new NotSupportedException("This is a Read Only Collection and can not be modified");
}
public override void Remove(IAppender x)
{
throw new NotSupportedException("This is a Read Only Collection and can not be modified");
}
public override int IndexOf(IAppender x)
{
return m_collection.IndexOf(x);
}
public override bool Contains(IAppender x)
{
return m_collection.Contains(x);
}
public override void CopyTo(IAppender[] array, int start)
{
m_collection.CopyTo(array,start);
}
public override void CopyTo(IAppender[] array)
{
m_collection.CopyTo(array);
}
/// <summary>
/// Return the collection elements as an array
/// </summary>
/// <returns>the array</returns>
public virtual IAppender[] ToArray()
{
IAppender[] resultArray = new IAppender[m_count];
if (m_count > 0)
{
Array.Copy(m_array, 0, resultArray, 0, m_count);
}
return resultArray;
}
/// <summary>
/// Adds the elements of a <see cref="IAppender"/> array to the current <c>AppenderCollection</c>.
/// </summary>
/// <param name="x">The <see cref="IAppender"/> array whose elements should be added to the end of the <c>AppenderCollection</c>.</param>
/// <returns>The new <see cref="AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>
public virtual int AddRange(IAppender[] x)
{
if (m_count + x.Length >= m_array.Length)
{
EnsureCapacity(m_count + x.Length);
}
Array.Copy(x, 0, m_array, m_count, x.Length);
m_count += x.Length;
m_version++;
return m_count;
}
