private void InitializeLog4Net()
{
nativeLogger = log4net.LogManager.GetLogger("UnityLog4NetLogger");
// set log rotate to daily
log4net.Appender.RollingFileAppender rollingFileAppender = new log4net.Appender.RollingFileAppender();
rollingFileAppender.RollingStyle = log4net.Appender.RollingFileAppender.RollingMode.Date;
rollingFileAppender.AppendToFile = true;
rollingFileAppender.StaticLogFileName = false;
rollingFileAppender.File = Path.GetFullPath(outputLogDir) + "/";
rollingFileAppender.DatePattern = "yyyyMMdd\".log\"";
rollingFileAppender.Layout = new log4net.Layout.PatternLayout("%date{yyyy/MM/dd HH:mm:ss} %message%newline");
log4net.Filter.LevelRangeFilter filter = new log4net.Filter.LevelRangeFilter();
switch (filterLevel)
{
case FILTER_LEVEL.VERBOSE: filter.LevelMin = log4net.Core.Level.Verbose; break;
case FILTER_LEVEL.DEBUG: filter.LevelMin = log4net.Core.Level.Debug; break;
case FILTER_LEVEL.INFO: filter.LevelMin = log4net.Core.Level.Info; break;
case FILTER_LEVEL.WARN: filter.LevelMin = log4net.Core.Level.Warn; break;
case FILTER_LEVEL.ERROR: filter.LevelMin = log4net.Core.Level.Error; break;
}
filter.LevelMax = log4net.Core.Level.Fatal;
rollingFileAppender.AddFilter(filter);
rollingFileAppender.ActivateOptions();
((log4net.Repository.Hierarchy.Logger)nativeLogger.Logger).AddAppender(rollingFileAppender);
((log4net.Repository.Hierarchy.Logger)nativeLogger.Logger).Hierarchy.Configured = true;
}
public Logging(string sFileName, string sLocation, bool bUseLogging)
{
m_sFileName = sFileName;
if (!bUseLogging) return;
if (sLocation.Length > 0)
if (sLocation[sLocation.Length - 1] != '\\')
sLocation += "\\";
m_RFL = new log4net.Appender.RollingFileAppender();
m_RFL.File = sLocation + m_sFileName + m_sFileExt;
m_RFL.StaticLogFileName = true;
m_RFL.AppendToFile = true;
m_RFL.RollingStyle = log4net.Appender.RollingFileAppender.RollingMode.Size;
m_RFL.MaximumFileSize = "10mb";
m_RFL.MaxSizeRollBackups = 2;
m_RFL.Threshold = log4net.Core.Level.All;
//m_RFL.CountDirection = 1;
//m_RFL.DatePattern = "HH:MM::SS";
log4net.Layout.PatternLayout layout = new log4net.Layout.PatternLayout("%message%newline");
layout.ActivateOptions();
log4net.Filter.LevelRangeFilter filter = new log4net.Filter.LevelRangeFilter();
filter.LevelMax = log4net.Core.Level.Emergency;
filter.LevelMin = log4net.Core.Level.All;
m_RFL.AddFilter(filter);
m_RFL.Layout = layout;
m_RFL.ActivateOptions();
log4net.Config.BasicConfigurator.Configure(m_RFL);
// Set up
Log(Logging.LOGTYPE.ERROR, "Start logging...");
}
public static void Start(LogTargets target) //server remote mode will be set auto when use SetRemote
{
type = target;
List<IAppender> appenders = new List<IAppender>();
if ((type & LogTargets.ServerRemote) != 0 && remoteIP != "")
{
UdpAppender appender = new UdpAppender();
appender.Layout = new PatternLayout(format);
appender.RemoteAddress = IPAddress.Parse(remoteIP);
appender.RemotePort = remotePort;
LevelRangeFilter filter = new LevelRangeFilter();
filter.LevelMin = Level.Debug;
filter.LevelMax = Level.Fatal;
appender.AddFilter(filter);
appender.ActivateOptions();
appenders.Add(appender);
}
if ((type & LogTargets.ServerConsole) != 0)
{
ColoredConsoleAppender appender = new ColoredConsoleAppender();
appender.Layout = new PatternLayout(format);
ColoredConsoleAppender.LevelColors mapcolor = new ColoredConsoleAppender.LevelColors();
mapcolor.Level = Level.Fatal;
mapcolor.BackColor = ColoredConsoleAppender.Colors.Red;
appender.AddMapping(mapcolor);
mapcolor = new ColoredConsoleAppender.LevelColors();
mapcolor.Level = Level.Error;
mapcolor.BackColor = ColoredConsoleAppender.Colors.Red;
appender.AddMapping(mapcolor);
mapcolor = new ColoredConsoleAppender.LevelColors();
mapcolor.Level = Level.Warn;
mapcolor.ForeColor = ColoredConsoleAppender.Colors.Purple;
appender.AddMapping(mapcolor);
mapcolor = new ColoredConsoleAppender.LevelColors();
mapcolor.Level = Level.Info;
mapcolor.ForeColor = ColoredConsoleAppender.Colors.Green;
appender.AddMapping(mapcolor);
appender.ActivateOptions();
appenders.Add(appender);
}
if ((type & LogTargets.File) != 0)
{
FileAppender appender = new FileAppender();
appender.Layout = new PatternLayout(format);
appender.File = string.Format("Log/{0}-{1}-{2}.log", DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day);
appender.AppendToFile = true;
appender.Name = "FileAppender";
appender.ActivateOptions();
appenders.Add(appender);
}
BasicConfigurator.Configure(appenders.ToArray());
}
/// <summary>
/// Appends inclusive filter to the log
/// </summary>
/// <param name="minRange">The min range.</param>
/// <param name="maxRange">The max range.</param>
/// <returns>same syntax</returns>
public LogSyntax Filter(LogLevel minRange, LogLevel maxRange)
{
var filter = new LevelRangeFilter
{
LevelMin = minRange.ToLog4Net(),
LevelMax = maxRange.ToLog4Net(),
AcceptOnMatch = true
};
filter.ActivateOptions();
_skeleton.AddFilter(filter);
//_skeleton.ActivateOptions();
return this;
}
public static void Configure(string logFilesFolderPath, Log4NetConfigurator configurator)
{
if (logFilesFolderPath.StartsWith("~")) logFilesFolderPath = logFilesFolderPath.Substring(1);
if (logFilesFolderPath.StartsWith("/")) logFilesFolderPath = logFilesFolderPath.Substring(1);
var hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.Level = Level.Warn;
hierarchy.Configured = true;
var patternLayout = new PatternLayout
{
ConversionPattern = "%date [%thread] %-5level %logger - %P{Tenant} - %message%newline"
};
patternLayout.ActivateOptions();
var debugFileAppender = BaseFileAppender(patternLayout);
debugFileAppender.Name = "debug-file";
debugFileAppender.File = Path.Combine(logFilesFolderPath, "orchard-debug");
debugFileAppender.ActivateOptions();
hierarchy.Root.AddAppender(debugFileAppender);
var errorFileAppender = BaseFileAppender(patternLayout);
errorFileAppender.Name = "error-file";
errorFileAppender.File = Path.Combine(logFilesFolderPath, "orchard-error");
var levelFilter = new LevelRangeFilter { LevelMin = Level.Error };
levelFilter.ActivateOptions();
errorFileAppender.AddFilter(levelFilter);
errorFileAppender.ActivateOptions();
hierarchy.Root.AddAppender(errorFileAppender);
var simpleLayout = new SimpleLayout();
simpleLayout.ActivateOptions();
var debuggerAppender = new DebugAppender();
debuggerAppender.Name = "debugger";
debuggerAppender.ImmediateFlush = true;
debuggerAppender.Layout = simpleLayout;
debuggerAppender.ActivateOptions();
hierarchy.Root.AddAppender(debuggerAppender);
GetLogger("Orchard").AddAppender(debuggerAppender);
GetLogger("Orchard.Localization").Level = Level.Warn;
GetLogger("NHibernate.Cache").Level = Level.Error;
GetLogger("NHibernate.AdoNet.AbstractBatcher").Level = Level.Off;
GetLogger("NHibernate.Util.ADOExceptionReporter").Level = Level.Off;
configurator(hierarchy);
}
private AqiRemind()
{
RollingFileAppender appender = new RollingFileAppender();
appender.File = this.getLogFile();
appender.AppendToFile = true;
appender.RollingStyle = RollingFileAppender.RollingMode.Date;
appender.StaticLogFileName = true;
appender.Layout = new PatternLayout(AqiManage.Setting["AqiRemind.LogLayout"]);
LevelRangeFilter filter = new LevelRangeFilter();
filter.LevelMax = Level.Fatal;
filter.LevelMin = Level.Debug;
appender.AddFilter(filter);
appender.ActivateOptions();
BasicConfigurator.Configure(appender);
this.log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
}
public OutputWindowPaneAppender(EnvDTE.OutputWindowPane outputWindowPane, Level maxLevel)
{
this.outputWindowPane = outputWindowPane;
LevelRangeFilter filter = new LevelRangeFilter();
filter.LevelMin = maxLevel;
base.AddFilter(filter);
PatternLayout layout = new PatternLayout();
if (maxLevel.CompareTo(Level.Debug) <= 0)
{
layout.ConversionPattern = "%date %-5level %logger - %message%newline";
}
else
{
layout.ConversionPattern = "[%level] %message%newline";
}
layout.ActivateOptions();
base.Layout = layout;
}
public Logging(string sFileName, string sLocation, bool bUseLogging)
{
m_sFileName = sFileName;
if (!bUseLogging)
{
return;
}
if (sLocation.Length > 0)
{
if (sLocation[sLocation.Length - 1] != '\\')
{
sLocation += "\\";
}
}
m_RFL = new log4net.Appender.RollingFileAppender();
m_RFL.File = sLocation + m_sFileName + m_sFileExt;
m_RFL.StaticLogFileName = true;
m_RFL.AppendToFile = true;
m_RFL.RollingStyle = log4net.Appender.RollingFileAppender.RollingMode.Size;
m_RFL.MaximumFileSize = "10mb";
m_RFL.MaxSizeRollBackups = 2;
m_RFL.Threshold = log4net.Core.Level.All;
//m_RFL.CountDirection = 1;
//m_RFL.DatePattern = "HH:MM::SS";
log4net.Layout.PatternLayout layout = new log4net.Layout.PatternLayout("%message%newline");
layout.ActivateOptions();
log4net.Filter.LevelRangeFilter filter = new log4net.Filter.LevelRangeFilter();
filter.LevelMax = log4net.Core.Level.Emergency;
filter.LevelMin = log4net.Core.Level.All;
m_RFL.AddFilter(filter);
m_RFL.Layout = layout;
m_RFL.ActivateOptions();
log4net.Config.BasicConfigurator.Configure(m_RFL);
// Set up
Log(Logging.LOGTYPE.ERROR, "Start logging...");
}
private void InitializeLog4Net()
{
// ログローテーション設定
nativeLogger = log4net.LogManager.GetLogger("Logger");
log4net.Appender.RollingFileAppender rollingFileAppender = new log4net.Appender.RollingFileAppender();
rollingFileAppender.RollingStyle = log4net.Appender.RollingFileAppender.RollingMode.Date;
rollingFileAppender.AppendToFile = true;
rollingFileAppender.StaticLogFileName = false;
rollingFileAppender.File = Path.GetFullPath(outputLogDir) + "/";
rollingFileAppender.DatePattern = "yyyyMMdd\".log\"";
rollingFileAppender.Layout = new log4net.Layout.PatternLayout("%date{yyyy/MM/dd HH:mm:ss} %message%newline");
log4net.Filter.LevelRangeFilter filter = new log4net.Filter.LevelRangeFilter();
filter.LevelMin = log4net.Core.Level.Info;
filter.LevelMax = log4net.Core.Level.Fatal;
rollingFileAppender.AddFilter(filter);
rollingFileAppender.ActivateOptions();
((log4net.Repository.Hierarchy.Logger)nativeLogger.Logger).AddAppender(rollingFileAppender);
((log4net.Repository.Hierarchy.Logger)nativeLogger.Logger).Hierarchy.Configured = true;
}
public static void Initialize(TestContext ctx)
{
var appender = new MyDebugAppender
{
Layout =
new PatternLayout(
"%date{HH:mm:ss:fffff} %-10logger{1} %-5level - [%thread] %message%newline")
};
var filterLevels = new LevelRangeFilter { LevelMin = Level.All, AcceptOnMatch = true };
//filterLevels.LevelMax = Level.Fatal;
filterLevels.ActivateOptions();
// var filterDeny = new DenyAllFilter();
appender.AddFilter(filterLevels);
appender.Threshold = Level.Trace;
appender.ActivateOptions();
BasicConfigurator.Configure(appender);
}
/// <summary>
/// update details with use of minimum and maximum level of log
/// </summary>
/// <param name="minlevel">refers level name like "warn"</param>
/// <param name="maxlevel">refers level name like "error"</param>
public static void UpdateAppender(Level minlevel, Level maxlevel)
{
var hierarchy = LogManager.GetRepository() as log4net.Repository.Hierarchy.Hierarchy;
if (hierarchy != null)
{
var appenders = hierarchy.GetAppenders();
foreach (IAppender appender in appenders)
{
var appenderSkeleton = appender as AppenderSkeleton;
if (appenderSkeleton != null)
{
IFilter filterHead = appenderSkeleton.FilterHead;
log4net.Filter.LevelRangeFilter filter = (log4net.Filter.LevelRangeFilter)filterHead;
filter.LevelMax = minlevel;
filter.LevelMin = maxlevel;
filter.ActivateOptions();
((log4net.Appender.AppenderSkeleton)appender).ActivateOptions();
}
}
}
}
private static RollingFileAppender CreateRollingFileAppender(string filename, PatternLayout patternLayout,
int maxSizeRollBackups, string maximumFileSize, Level level)
{
RollingFileAppender rfa = new RollingFileAppender();
rfa.AppendToFile = true;
rfa.File = filename;
rfa.Layout = patternLayout;
rfa.MaxSizeRollBackups = maxSizeRollBackups;
rfa.MaximumFileSize = maximumFileSize;
rfa.RollingStyle = RollingFileAppender.RollingMode.Size;
rfa.StaticLogFileName = true;
LevelRangeFilter levelRangeFilter = new log4net.Filter.LevelRangeFilter();
levelRangeFilter.LevelMin = level;
rfa.AddFilter(levelRangeFilter);
rfa.ActivateOptions();
return(rfa);
}
private void SetupLogger()
{
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
PatternLayout patternLayout = new PatternLayout();
patternLayout.ConversionPattern = "%date [%thread] %-5level [%class.%method] - %message%newline";
patternLayout.ActivateOptions();
RollingFileAppender roller = new RollingFileAppender();
roller.AppendToFile = false;
roller.File = @"ResultExporterLog.txt";
roller.Layout = patternLayout;
roller.MaxSizeRollBackups = 5;
roller.MaximumFileSize = "1GB";
roller.RollingStyle = RollingFileAppender.RollingMode.Size;
roller.StaticLogFileName = true;
roller.ActivateOptions();
ConsoleAppender console = new ConsoleAppender();
PatternLayout consolePatternLayout = new PatternLayout();
consolePatternLayout.ConversionPattern = "%date [Testlink Result Exporter] [%level] %message%newline";
consolePatternLayout.ActivateOptions();
LevelRangeFilter consoleLevelFilter = new LevelRangeFilter();
consoleLevelFilter.LevelMin = Level.Info;
consoleLevelFilter.LevelMax = Level.Fatal;
console.AddFilter(consoleLevelFilter);
console.Layout = consolePatternLayout;
hierarchy.Root.AddAppender(roller);
hierarchy.Root.AddAppender(console);
hierarchy.Root.Level = Level.All;
hierarchy.Configured = true;
}
internal static void ReconfigureLogger()
{
string logFile = Path.Combine(AppSettings.AppSettingsPath, "ErrorLog.txt");
if (Log.Logger.Repository.Configured)
{
Log.Logger.Repository.Shutdown();
Log.Logger.Repository.ResetConfiguration();
}
if (_clearLog)
{
try
{
File.Delete(logFile);
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
_clearLog = false;
}
PatternLayout layout = new PatternLayout();
LevelRangeFilter filter = new LevelRangeFilter();
if (AppSettings.UseDebug)
{
layout.ConversionPattern = "%date{HH:mm:ss} [%thread] %-5level %logger.%method(%line) - %message%newline";
filter.LevelMin = Level.All;
}
else
{
layout.ConversionPattern = "%date{HH:mm:ss} %-5level %logger - %message%newline";
filter.LevelMin = Level.Warn;
}
filter.AcceptOnMatch = true;
layout.ActivateOptions();
FileAppender file = new FileAppender
{
Layout = layout,
AppendToFile = true,
Encoding = new UTF8Encoding(),
File = logFile,
ImmediateFlush = true
};
file.AddFilter(filter);
file.ActivateOptions();
BasicConfigurator.Configure(file);
if (AppSettings.UseDebug)
{
Log.Info("Debug information enabled");
}
}
private static void CustomizeLogDirectory(string logDir, string customFile, Level min, Level max)
{
if (!string.IsNullOrEmpty(logDir))
{
var repository = LogManager.GetRepository();
var appenders = repository.GetAppenders();
foreach (var appender in appenders)
{
FileAppender fileAppender = null;
if (appender is RollingFileAppender)
{
fileAppender = (FileAppender)appender;
}
else if (appender is FileAppender)
{
fileAppender = (FileAppender)appender;
}
if (fileAppender != null)
{
string file = fileAppender.File;
int lastPos = file.LastIndexOf(Path.DirectorySeparatorChar);
if (lastPos > 0)
{
file = file.Substring(lastPos + 1, file.Length - lastPos - 1);
}
if (file == "default.log" && !string.IsNullOrEmpty(customFile)) //Only default.log change to customFile, keep all the others log file
{
fileAppender.File = logDir + Path.DirectorySeparatorChar + customFile;
}
else
{
fileAppender.File = logDir + Path.DirectorySeparatorChar + file;
}
if (min != null && max != null)
{
var levelRangeFilter = new LevelRangeFilter { LevelMax = max, LevelMin = min };
levelRangeFilter.ActivateOptions();
fileAppender.AddFilter(levelRangeFilter);
}
//make sure to call fileAppender.ActivateOptions() to notify the logging
//sub system that the configuration for this appender has changed.
fileAppender.ActivateOptions();
}
}
GlobalContext.Properties["pid"] = Process.GetCurrentProcess().Id;
return;
}
throw new Exception(String.Format("CustomizeLogDirectory {0} fault!", logDir));
}
public void MessagesExcludedByFilterShouldNotBeAppended()
{
// Arrange
var levelFilter =
new LevelRangeFilter
{
LevelMin = Level.Warn,
LevelMax = Level.Error,
};
asyncForwardingAppender.AddFilter(levelFilter);
// Act
log.Info("Info");
log.Warn("Warn");
log.Error("Error");
log.Fatal("Fatal");
asyncForwardingAppender.Close();
//Assert
Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(2));
}
