public static void Initialize(string logfilePath, string optionalLog4NetConfigPath)
{
// When interactice, also activate logging to the console.
if (Environment.UserInteractive)
{
BasicConfigurator.Configure();
}
// Use a full-featured log4net log4net configuration file it it exist, otherwise
// use a simple hardcoded default.
if (string.IsNullOrWhiteSpace(optionalLog4NetConfigPath) || !File.Exists(optionalLog4NetConfigPath))
{
_appender = new RollingFileAppender
{
Name = "DefaultAppended",
File = logfilePath,
RollingStyle = RollingFileAppender.RollingMode.Size,
MaxSizeRollBackups = 10,
PreserveLogFileNameExtension = true,
Threshold = _debug ? Level.Debug : Level.Info,
Layout = new PatternLayout("%date [%2thread] %-5level %logger %ndc - %message%newline"),
};
_appender.ActivateOptions();
BasicConfigurator.Configure(_appender);
}
else
{
XmlConfigurator.ConfigureAndWatch(new FileInfo(optionalLog4NetConfigPath));
}
Log.Info(new string('-', 30));
}
/// <summary>
/// Sets the <see cref="IAppender"/>'s filter level to the level specified
/// </summary>
/// <param name="appender">the <see cref="IAppender"/> to change</param>
/// <param name="newLevel">the new level at which the <see cref="IAppender"/> should log</param>
private static void SetAppenderFilterLevel(IAppender appender, log4net.Core.Level newLevel)
{
if (appender == null || newLevel == null)
{
return;
}
AppenderSkeleton baseAppender = appender as AppenderSkeleton;
if (baseAppender == null)
{
return;
}
log4net.Filter.LevelRangeFilter rangeFilter = GetLevelRangeFilter(baseAppender);
if (rangeFilter == null)
{
return;
}
// lock the IAppender so that its clients wait until this process completes
lock (baseAppender)
{
appender.DoAppend(new log4net.Core.LoggingEvent(logger.GetType(), log4net.LogManager.GetRepository(),
logger.GetType().Name, log4net.Core.Level.Info, "Changed log level to " + newLevel.ToString(), null));
rangeFilter.LevelMin = newLevel;
}
}
internal void ApplyTo(AppenderSkeleton appender)
{
if (_filter != null)
{
appender.AddFilter(_filter.CreateFilter());
}
}
public AssociativeCache(
int way,
int totalCacheCapacity,
ICachePolicyFactory <K, V> cachePolicyFactory = null,
ICacheSetHashCalculator <K, V> hashSetCacluator = null,
AppenderSkeleton appender = null)
{
this.appender = appender ?? new ConsoleAppender();
// Implement as a one way cache
if (way <= 0)
{
LoggingUtility.LogData(this.appender, "Number of cache sets cannot be 0 or negative", Level.Fatal);
throw new ArgumentOutOfRangeException("Number of cache sets cannot be 0 or negative", "way");
}
if (totalCacheCapacity <= 0)
{
LoggingUtility.LogData(this.appender, "Number of cache sets cannot be 0 or negative", Level.Fatal);
throw new ArgumentOutOfRangeException("Number of cache sets cannot be 0 or negative", "totalCacheCapacity");
}
this.cachePolicyFactory = cachePolicyFactory;
this.cacheSetLookUp = new Dictionary <int, CacheSet <K, V> >();
this.cachePolicyFactory = cachePolicyFactory ?? new LRUPolicyFactory <K, V>();
this.hashSetCalculator = hashSetCalculator ?? new DefaultCacheSetHashCalculator <K, V>(way);
for (int i = 0; i < way; i++)
{
this.cacheSetLookUp.Add(i, new CacheSet <K, V>(this.cachePolicyFactory.CreatePolicy(), totalCacheCapacity / way, this.appender));
}
}
private static void ConfigureAppender(AppenderSkeleton appender)
{
if (appender.Layout == null)
{
appender.Layout = new log4net.Layout.PatternLayout("%d [%t] %-5p %c [%x] <%X{auth}> - %m%n");
}
var cfg = Configure.GetConfigSection <Config.Logging>();
if (cfg != null)
{
foreach (var f in typeof(Level).GetFields(BindingFlags.Public | BindingFlags.Static))
{
if (string.Compare(cfg.Threshold, f.Name, true) == 0)
{
var val = f.GetValue(null);
appender.Threshold = val as Level;
break;
}
}
}
if (appender.Threshold == null)
{
appender.Threshold = Level.Info;
}
appender.ActivateOptions();
log4net.Config.BasicConfigurator.Configure(appender);
}
public static void ApplyDefaultConfiguration(PatternLayout Pattern = default, AppenderSkeleton[] Appenders = default)
{
var hierarchy = (Hierarchy)LogManager.GetRepository();
if (Pattern == default)
{
Pattern = DefaultPattern();
Pattern.ActivateOptions();
}
if (Appenders == default)
{
Appenders = new AppenderSkeleton[] {
DefaultDebugAppender(),
DefaultConsoleAppender(),
DefaultFileAppender(),
};
}
foreach (var Appender in Appenders)
{
Appender.Layout = Pattern;
Appender.ActivateOptions();
hierarchy.Root.AddAppender(Appender);
}
hierarchy.Root.Level = Level.All;
hierarchy.Configured = true;
}
internal void ApplyTo(AppenderSkeleton appender)
{
if (_layout != null)
{
appender.Layout = _layout.CreateLayout();
}
}
internal void ApplyTo(AppenderSkeleton appender)
{
if (_handler != null)
{
appender.ErrorHandler = _handler.CreateErrorHandler();
}
}
public ActiveLoggerFilterScope(string activeLogger)
{
ILoggerRepository repository = LogManager.GetRepository();
repository.Threshold = Level.All;
repository.Properties[scopeKey] = activeLogger;
foreach (IAppender appender in LogManager.GetRepository().GetAppenders())
{
AppenderSkeleton appenderSkeleton = appender as AppenderSkeleton;
if (appenderSkeleton != null)
{
// only inject ActiveLoggerFilter once
if (appenderSkeleton.FilterHead == null ||
appenderSkeleton.FilterHead.GetType() != typeof(ActiveLoggerFilter))
{
// inject ActiveLoggerFilter into the head of the filter list
IFilter filter = new ActiveLoggerFilter(scopeKey);
filter.ActivateOptions();
filter.Next = appenderSkeleton.FilterHead; // ???
appenderSkeleton.ClearFilters(); // ???
appenderSkeleton.AddFilter(filter); // ???
}
}
}
}
private static void LoadLayout(AppenderSkeleton appender, ILoggerRepository repository)
{
PatternLayout patternLayout = new PatternLayout();
patternLayout.ConversionPattern = "记录时间：%date 线程ID:[%thread] 日志级别：%-5level ：%logger %n%message%n%n";
patternLayout.ActivateOptions();
appender.Layout = patternLayout;
appender.ActivateOptions();
BasicConfigurator.Configure(repository, appender);
}
internal static void LogData(AppenderSkeleton appender, string message, Level trace)
{
LoggingEventData eventData = new LoggingEventData()
{
Level = trace,
Message = message
};
appender.DoAppend(new LoggingEvent(eventData));
}
private bool AppenderError()
{
bool result = false;
if (_appenderError != null)
{
result = true;
_appenderError = null;
}
return(result);
}
private void AdaptFilters(AppenderSkeleton appender, Level level)
{
var rangeFilter = appender.FilterHead as LevelRangeFilter;
if (rangeFilter == null)
{
return;
}
rangeFilter.LevelMin = level;
}
private void RemoveAllFiltersFromAllAppenders()
{
foreach (IAppender appender in LogManager.GetRepository().GetAppenders())
{
AppenderSkeleton appenderSkeleton = appender as AppenderSkeleton;
if (appenderSkeleton != null)
{
appenderSkeleton.ClearFilters();
}
}
}
private static ILog LoadConf(TextLog.Default.Config config)
{
PatternLayout layout = new PatternLayout(config.PatternLayout);
AppenderSkeleton appenderSkeleton = config.Appender as TextWriterAppender;
appenderSkeleton.Layout = layout;
appenderSkeleton.ActivateOptions();
ILoggerRepository loggerRepository = LogManager.CreateRepository(Guid.NewGuid().ToString());
BasicConfigurator.Configure(loggerRepository, appenderSkeleton);
return(LogManager.GetLogger(loggerRepository.Name, Guid.NewGuid().ToString()));
}
public void AddAppender(AppenderSkeleton appender)
{
if (_logger == null)
{
LoadLogger();
}
var hierarchy = (Hierarchy)log4net.LogManager.GetRepository();
appender.Layout = new PatternLayout(GetLogPattern(_logLevel));
appender.Threshold = hierarchy.LevelMap[_logLevel.ToString().ToUpper(CultureInfo.CurrentCulture)];
hierarchy.Root.AddAppender(appender);
}
private static void ConfigPattern(AppenderSkeleton appender, ConfigSource config)
{
string logPattern = config.GetString("pattern", null);
if (logPattern == null)
{
logPattern = "%date [%thread] %-5level %logger - %message%newline";
}
PatternLayout layout = new PatternLayout(logPattern);
layout.ActivateOptions();
appender.Layout = layout;
}
private void EnsureConsoleAppender()
{
if (_consoleAppender != null)
{
return;
}
var consoleAppenderName = "ConsoleAppender";
_consoleAppender = (AppenderSkeleton)RootLogger.GetAppender(consoleAppenderName);
if (_consoleAppender == null)
{
_consoleAppender = GetConfiguredAppender(consoleAppenderName) ?? CreateAppender(consoleAppenderName);
RootLogger.AddAppender(_consoleAppender);
}
}
/// <summary>
/// 设备日志等级
/// </summary>
/// <param name="level">日志等级：all,debug,info,warn,error,fatal,off</param>
internal static void SetLogLevel(string level)
{
if (string.IsNullOrWhiteSpace(level))
{
return;
}
var logLevel = Level.Error;
switch (level.ToLower())
{
case "all": logLevel = Level.All; break;
case "debug": logLevel = Level.Debug; break;
case "info": logLevel = Level.Info; break;
case "warn": logLevel = Level.Warn; break;
case "error": logLevel = Level.Error; break;
case "fatal": logLevel = Level.Fatal; break;
case "off": logLevel = Level.Off; break;
}
var hierarchy = LogManager.GetRepository() as Hierarchy;
// Get the list of Appenders
if (hierarchy != null)
{
var appenders = hierarchy.GetAppenders();
if (appenders != null)
{
foreach (var appender in appenders)
{
if (appender is AppenderSkeleton)
{
AppenderSkeleton appenderSkeleton = appender as AppenderSkeleton;
appenderSkeleton.Threshold = logLevel;
}
}
}
}
}
private static log4net.Filter.LevelRangeFilter GetLevelRangeFilter(AppenderSkeleton appender)
{
log4net.Filter.LevelRangeFilter rangeFilter = null;
lock (appender)
{
log4net.Filter.IFilter filterHead = appender.FilterHead;
//process through the filters until a level range filter is found
while (filterHead != null)
{
if (typeof(log4net.Filter.LevelRangeFilter).Equals(filterHead.GetType()))
{
rangeFilter = filterHead as log4net.Filter.LevelRangeFilter;
break;
}
filterHead = filterHead.Next;
}
}
return(rangeFilter);
}
private IEnumerable <AppenderSkeleton> GetAppenders(IConfigurationRoot configurationRoot, IConfigurationSection log4netSection)
{
IEnumerable <IConfigurationSection> children = log4netSection.GetChildren();
foreach (var child in children)
{
if (child.Key == "appender")
{
IConfigurationSection name = child.GetSection("name");
IConfigurationSection type = child.GetSection("type");
Type appenderType = Type.GetType(type.Value);
ConstructorInfo[] constructorInfos = appenderType.GetConstructors();
ConstructorInfo constructorInfo = constructorInfos[0];
List <object> arguments = new List <object>();
foreach (ParameterInfo param in constructorInfo.GetParameters())
{
object argument = null;
if (param.Name == "connectionString")
{
//get connection string from connection strings section
IConfigurationSection connectionStringName = child.GetSection("connectionStringName");
string connectionString = configurationRoot.GetConnectionString(connectionStringName.Value);
argument = connectionString;
}
else
{
IConfigurationSection paramConfigurationSection = child.GetSection(param.Name);
argument = Convert.ChangeType(paramConfigurationSection.Value, param.ParameterType);
}
arguments.Add(argument);
}
AppenderSkeleton appender = Activator.CreateInstance(appenderType, arguments.ToArray()) as AppenderSkeleton;
yield return(appender);
}
}
}
internal LogSyntax(AppenderSkeleton skeleton)
{
_skeleton = skeleton;
}
/// <summary>
/// Initializes the logging system with extra options used by unit tests.
/// </summary>
/// <param name="enableMemoryLogger">If true, stores a copy of all log events in memory. Used for testing.</param>
/// <param name="enableFileLogger">If true, outputs log events to a file.</param>
/// <param name="colorConsole">If True, colored logs will be used.</param>
/// <param name="defaultLevel">The default level to set for the root logger.</param>
/// <param name="quietConsole">If True limits the level on the appenders to <see cref="Level.Error"/></param>
internal static void Initialize(
bool enableMemoryLogger,
bool enableFileLogger,
bool colorConsole,
Level defaultLevel,
bool quietConsole)
{
Contract.Requires <InvalidOperationException>(!configured, "The logger system can only be initialised once");
configured = true;
repository = (Hierarchy)LogManager.GetRepository();
repository.LevelMap.Add(LogExtensions.PromptLevel);
repository.LevelMap.Add(LogExtensions.SuccessLevel);
rootLogger = repository.Root;
cleanLogger = (Logger)repository.GetLogger(Cleanlogger);
noConsoleLogger = (Logger)repository.GetLogger(Logfileonly);
// cleanLogger.Hierarchy = repository;
// noConsoleLogger.Hierarchy = repository;
// our two special loggers do not forward log events to the root logger
cleanLogger.Additivity = false;
noConsoleLogger.Additivity = false;
// this is the base level for the logging system
repository.Threshold = defaultLevel;
rootLogger.Level = defaultLevel;
// log to a file
PatternLayout standardPattern = new PatternLayout
{
ConversionPattern = "%date{o} [%thread] %-5level %logger - %message%newline%exception",
};
standardPattern.ActivateOptions();
string logFilePath = null;
if (enableFileLogger)
{
var fileAppender = new RollingFileAppender()
{
AppendToFile = false,
Encoding = Encoding.UTF8,
StaticLogFileName = true,
// We clean our logs ourselves, so it might be assumed that MaxSizeRollBackups is not needed,
// however this constraint is needed to trigger log4net's dedupe function for duplicate file names
MaxSizeRollBackups = 100,
Layout = standardPattern,
Name = nameof(RollingFileAppender),
File = new PatternString("Logs/log_%utcdate{yyyyMMddTHHmmssZ}.txt").Format(),
PreserveLogFileNameExtension = true,
RollingStyle = RollingFileAppender.RollingMode.Once,
};
rootLogger.AddAppender(fileAppender);
cleanLogger.AddAppender(fileAppender);
noConsoleLogger.AddAppender(fileAppender);
fileAppender.ActivateOptions();
logFilePath = fileAppender.File;
}
if (enableMemoryLogger)
{
MemoryAppender = new MemoryAppender()
{
Layout = standardPattern,
};
rootLogger.AddAppender(MemoryAppender);
cleanLogger.AddAppender(MemoryAppender);
noConsoleLogger.AddAppender(MemoryAppender);
MemoryAppender.ActivateOptions();
}
// log to a console
PatternLayout consolePattern = new PatternLayout
{
ConversionPattern = "[%date{o}] %-5level - %message%newline%exception",
};
consolePattern.ActivateOptions();
standardConsoleAppender =
colorConsole ? (AppenderSkeleton) new ManagedColoredConsoleAppender() : new ConsoleAppender();
standardConsoleAppender.Layout = consolePattern;
PatternLayout cleanPattern = new PatternLayout
{
ConversionPattern = "%message%newline",
};
cleanPattern.ActivateOptions();
cleanConsoleAppender =
colorConsole ? (AppenderSkeleton) new ManagedColoredConsoleAppender() : new ConsoleAppender();
cleanConsoleAppender.Layout = cleanPattern;
if (colorConsole)
{
var mapping = new[]
{
new LevelColors {
ForeColor = ConsoleColor.Magenta, Level = LogExtensions.PromptLevel
},
new LevelColors {
ForeColor = ConsoleColor.Red, Level = Level.Fatal
},
new LevelColors {
ForeColor = ConsoleColor.DarkRed, Level = Level.Error
},
new LevelColors {
ForeColor = ConsoleColor.Yellow, Level = Level.Warn
},
new LevelColors {
ForeColor = ConsoleColor.Green, Level = LogExtensions.SuccessLevel
},
new LevelColors {
ForeColor = ConsoleColor.Green, Level = Level.Notice
},
new LevelColors {
ForeColor = ConsoleColor.Gray, Level = Level.Info
},
new LevelColors {
ForeColor = ConsoleColor.Cyan, Level = Level.Debug
},
new LevelColors {
ForeColor = ConsoleColor.DarkCyan, Level = Level.Trace
},
new LevelColors {
ForeColor = ConsoleColor.DarkBlue, Level = Level.Verbose
},
};
foreach (var map in mapping)
{
((ManagedColoredConsoleAppender)standardConsoleAppender).AddMapping(map);
((ManagedColoredConsoleAppender)cleanConsoleAppender).AddMapping(map);
}
}
standardConsoleAppender.ActivateOptions();
cleanConsoleAppender.ActivateOptions();
rootLogger.AddAppender(standardConsoleAppender);
cleanLogger.AddAppender(cleanConsoleAppender);
repository.Configured = true;
ModifyVerbosity(defaultLevel, quietConsole);
if (enableFileLogger)
{
// Fire and forget the async cleaning task.
// We'll never know if this fails or not, the exception is captured in the task
// that we do NOT await. We do however log any exceptions.
_ = CleanLogs(logFilePath);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Logging"/> class.
/// </summary>
/// <param name="enableMemoryLogger">If true, stores a copy of all log events in memory. Used for testing.</param>
/// <param name="enableFileLogger">If true, outputs log events to a file.</param>
/// <param name="colorConsole">If True, colored logs will be used.</param>
/// <param name="defaultLevel">The default level to set for the root logger.</param>
/// <param name="quietConsole">If True limits the level on the appenders to <see cref="Level.Error"/>.</param>
internal Logging(
bool enableMemoryLogger,
bool enableFileLogger,
bool colorConsole,
Level defaultLevel,
bool quietConsole)
{
LogManager.ResetConfiguration(RootNamespace);
this.repository = (Hierarchy)LogManager.GetRepository(RootNamespace);
this.repository.LevelMap.Add(LogExtensions.PromptLevel);
this.repository.LevelMap.Add(LogExtensions.SuccessLevel);
this.rootLogger = this.repository.Root;
this.cleanLogger = (Logger)this.repository.GetLogger(CleanLogger);
this.noConsoleLogger = (Logger)this.repository.GetLogger(LogFileOnly);
// cleanLogger.Hierarchy = repository;
// noConsoleLogger.Hierarchy = repository;
// our two special loggers do not forward log events to the root logger
this.cleanLogger.Additivity = false;
this.noConsoleLogger.Additivity = false;
// this is the base level for the logging system
this.repository.Threshold = defaultLevel;
this.rootLogger.Level = defaultLevel;
this.Verbosity = defaultLevel;
this.QuietConsole = quietConsole;
// log to a file
PatternLayout standardPattern = new PatternLayout
{
ConversionPattern = "%date{o} [%thread] %-5level %logger - %message%newline%exception",
};
standardPattern.ActivateOptions();
this.LogFilePath = null;
if (enableFileLogger)
{
this.LogFileName = new PatternString(LogPrefix + "%utcdate{yyyyMMddTHHmmssZ}.txt").Format();
var fileAppender = new RollingFileAppender()
{
AppendToFile = false,
Encoding = Encoding.UTF8,
StaticLogFileName = true,
// We clean our logs ourselves, so it might be assumed that MaxSizeRollBackups is not needed,
// however this constraint is needed to trigger log4net's dedupe function for duplicate file names
MaxSizeRollBackups = 100,
Layout = standardPattern,
Name = nameof(RollingFileAppender),
// ReSharper disable StringLiteralTypo
File = Path.Combine(LogFolder, this.LogFileName),
// ReSharper restore StringLiteralTypo
PreserveLogFileNameExtension = true,
RollingStyle = RollingFileAppender.RollingMode.Once,
};
this.rootLogger.AddAppender(fileAppender);
this.cleanLogger.AddAppender(fileAppender);
this.noConsoleLogger.AddAppender(fileAppender);
fileAppender.ActivateOptions();
this.LogFilePath = fileAppender.File;
}
if (enableMemoryLogger)
{
this.MemoryAppender = new MemoryAppender()
{
Layout = standardPattern,
};
this.rootLogger.AddAppender(this.MemoryAppender);
this.cleanLogger.AddAppender(this.MemoryAppender);
this.noConsoleLogger.AddAppender(this.MemoryAppender);
this.MemoryAppender.ActivateOptions();
}
// log to a console
PatternLayout consolePattern = new PatternLayout
{
ConversionPattern = "[%date{o}] %-5level - %message%newline%exception",
};
consolePattern.ActivateOptions();
this.standardConsoleAppender =
colorConsole ? (AppenderSkeleton) new ManagedColoredConsoleAppender() : new ConsoleAppender();
this.standardConsoleAppender.Layout = consolePattern;
PatternLayout cleanPattern = new PatternLayout
{
ConversionPattern = "%message%newline",
};
cleanPattern.ActivateOptions();
this.cleanConsoleAppender =
colorConsole ? (AppenderSkeleton) new ManagedColoredConsoleAppender() : new ConsoleAppender();
this.cleanConsoleAppender.Layout = cleanPattern;
if (colorConsole)
{
var mapping = new[]
{
new LevelColors {
ForeColor = ConsoleColor.Magenta, Level = LogExtensions.PromptLevel
},
new LevelColors {
ForeColor = ConsoleColor.Red, Level = Level.Fatal
},
new LevelColors {
ForeColor = ConsoleColor.DarkRed, Level = Level.Error
},
new LevelColors {
ForeColor = ConsoleColor.Yellow, Level = Level.Warn
},
new LevelColors {
ForeColor = ConsoleColor.Green, Level = LogExtensions.SuccessLevel
},
new LevelColors {
ForeColor = ConsoleColor.Green, Level = Level.Notice
},
new LevelColors {
ForeColor = ConsoleColor.Gray, Level = Level.Info
},
new LevelColors {
ForeColor = ConsoleColor.Cyan, Level = Level.Debug
},
new LevelColors {
ForeColor = ConsoleColor.DarkCyan, Level = Level.Trace
},
new LevelColors {
ForeColor = ConsoleColor.DarkBlue, Level = Level.Verbose
},
};
foreach (var map in mapping)
{
((ManagedColoredConsoleAppender)this.standardConsoleAppender).AddMapping(map);
((ManagedColoredConsoleAppender)this.cleanConsoleAppender).AddMapping(map);
}
}
this.standardConsoleAppender.ActivateOptions();
this.cleanConsoleAppender.ActivateOptions();
this.rootLogger.AddAppender(this.standardConsoleAppender);
this.cleanLogger.AddAppender(this.cleanConsoleAppender);
this.repository.Configured = true;
this.ModifyVerbosity(defaultLevel, quietConsole);
if (enableFileLogger)
{
// Fire and forget the async cleaning task.
// We'll never know if this fails or not, the exception is captured in the task
// that we do NOT await. We do however log any exceptions.
// ReSharper disable once AssignmentIsFullyDiscarded
_ = this.CleanLogs(this.LogFilePath);
}
}
/// <summary>
/// Configure the log4net logging infrastructure at runtime from app settings
/// </summary>
/// <summary>
/// Configure a specific appender to use the specified logging level as the threshold
/// </summary>
/// <param name="appenderName">Appender name to use when indexing <paramref name="appenderMap"/></param>
/// <param name="level">Level to set the appender threshold to</param>
private static void ConfigureLog4NetAppender(
IAppSettings settings,
log4net.Repository.Hierarchy.Hierarchy hierarchy,
Dictionary <string, AppenderSkeleton> appenderMap,
string appenderName,
string level,
ILogger logger)
{
AppenderSkeleton appender = null;
if (appenderMap.ContainsKey(appenderName))
{
appender = appenderMap[appenderName];
}
if (appender != null)
{
try
{
if (string.IsNullOrWhiteSpace(level) == false)
{
appender.Threshold = hierarchy.LevelMap[level];
}
}
catch (Exception ex)
{
logger.ErrorFormat("IoCSetup::ConfigureLog4NetAppender[{0}] - Unable to Set {1} Level: {2} - {3}", ContainerName, appenderName, level, ex.Message);
}
var fileAppender = appender as FileAppender;
if (fileAppender != null)
{
string path = null;
switch (appenderName)
{
case Log4NetTraceLogAppenderName:
path = settings.TraceLogPath;
break;
case Log4NetStatsLogAppenderName:
path = settings.StatsLogPath;
break;
}
try
{
if (string.IsNullOrWhiteSpace(path) == false)
{
fileAppender.File = path;
fileAppender.ActivateOptions();
}
}
catch (Exception ex)
{
logger.ErrorFormat("IoCSetup::ConfigureLog4NetAppender[{0}] - Unable to Set {1} File Path: {2} - {3}", ContainerName, appenderName, level, ex.Message);
}
}
}
}
public MRUCachePolicy(AppenderSkeleton appender = null)
{
this.queue = new LinkedList <CacheItem <K, V> >();
}
public TestDefinition(AppenderSkeleton appender)
{
_appender = appender;
}
public RolloverErrorHandler(AsyncRolloverAppender rolloverAppender, AppenderSkeleton appender)
{
_rolloverAppender = rolloverAppender;
_appender = appender;
}
private void SetAppenderErrorHandler(AppenderSkeleton appender) => appender.ErrorHandler = new PropogateErrorHandler();
internal void AppenderError(AppenderSkeleton appender)
{
_appenderError = appender;
}
