private static NLog.LogLevel ConvertToNLogLevel(log4net.Core.Level level)
{
if (level == log4net.Core.Level.Trace)
{
return(NLog.LogLevel.Trace);
}
if (level == log4net.Core.Level.Debug)
{
return(NLog.LogLevel.Debug);
}
if (level == log4net.Core.Level.Info)
{
return(NLog.LogLevel.Info);
}
if (level == log4net.Core.Level.Warn)
{
return(NLog.LogLevel.Warn);
}
if (level == log4net.Core.Level.Error)
{
return(NLog.LogLevel.Error);
}
if (level == log4net.Core.Level.Fatal)
{
return(NLog.LogLevel.Fatal);
}
if (level == log4net.Core.Level.Off)
{
return(NLog.LogLevel.Off);
}
throw new NotSupportedException("Level " + level + " is currently not supported.");
}
public static void Analyse(System.Exception ex, Boolean includeStackTrace = false)
{
log4net.Core.Level logLevel = log4net.Core.Level.Error;
if (LoggingAsFail(ex))
{
if (ex is ApplicationException)
{
return;
}
logLevel = Program.MyFailLevel;
}
log.ErrorOrFail(ex.GetType().FullName + ": " + ex.Message, logLevel);
int errorCode = getErrorCode(ex);
log.ErrorOrFail("Code: 0x" + errorCode.ToString("X8") + ";" + errorCode.ToString(), logLevel);
if (ex.InnerException != null)
{
log.ErrorOrFail("InnerException:-", logLevel);
Analyse(ex.InnerException, false);
}
if (includeStackTrace)
{
log.ErrorOrFail(ex.StackTrace, logLevel);
}
}
public virtual FileAppender AddFileLogging(string sFileFullPath, log4net.Core.Level threshold, bool bAppendfile)
{
FileAppender appender = GetFileAppender(sFileFullPath, threshold, bAppendfile);
root.AddAppender(appender);
return(appender);
}
public void addLogLine(String sender, String msg, log4net.Core.Level severity)
{
if (messageLog.InvokeRequired)
{
AddLogLineCallback ac = new AddLogLineCallback(addLogLine);
this.BeginInvoke(ac, new object[] { sender, msg, severity });
}
else
{
if (severity.Equals(log4net.Core.Level.Error))
{
messageLog.Text += "(!!!) ";
}
else if (severity.Equals(log4net.Core.Level.Warn))
{
messageLog.Text += "(!) ";
}
else if (severity.Equals(log4net.Core.Level.Debug))
{
messageLog.Text += "(D) ";
}
if (sender.StartsWith("SkypeBot.plugins."))
{
messageLog.Text += String.Format("{0}: {1}", sender.Split('.').Last <String>(), msg) + Environment.NewLine;
}
else
{
messageLog.Text += msg + Environment.NewLine;
}
messageLog.SelectionStart = messageLog.Text.Length;
messageLog.ScrollToCaret();
}
}
public static void AddNotifyAppender(NotifyAppender.NewLogEntryHandler newLogEntryAction,
log4net.Core.Level threshold = null,
string logPattern = CodeConfiguredUtilities.DefaultLogPattern)
{
// add in our notify appender
var repository = (log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository();
var logPatternLayout = new log4net.Layout.PatternLayout(logPattern);
if (newLogEntryAction != null)
{
var notifyAppender = new NotifyAppender();
notifyAppender.NewLogEntry += newLogEntryAction;
if (threshold != null)
{
notifyAppender.Threshold = threshold;
}
notifyAppender.Layout = logPatternLayout;
notifyAppender.ActivateOptions();
repository.Root.AddAppender(notifyAppender);
}
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.AddFacility<LoggingFacility>(f => f.UseLog4Net());
var securityLevel = new log4net.Core.Level(50000, "Security","SEC");
log4net.LogManager.GetRepository().LevelMap.Add(securityLevel);
}
public static void AddRollingFileAppender(string filePath = "logs/log.txt",
log4net.Core.Level threshold = null,
string logPattern = CodeConfiguredUtilities.DefaultLogPattern,
log4net.Appender.RollingFileAppender.RollingMode rollingMode = log4net.Appender.RollingFileAppender.RollingMode.Date,
string rollingModeDatePattern = "yyyyMMdd",
int maxNumberOfLogFilesToKeep = 5)
{
// it's cast to a Hierarchy because we need repo.Root to add appenders
var repo = (log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository();
var logPatternLayout = new log4net.Layout.PatternLayout(logPattern);
var fileAppender = new log4net.Appender.RollingFileAppender();
fileAppender.File = filePath;
fileAppender.AppendToFile = true;
fileAppender.Layout = logPatternLayout;
fileAppender.MaxSizeRollBackups = maxNumberOfLogFilesToKeep; // http://stackoverflow.com/questions/95286/log4net-set-max-backup-files-on-rollingfileappender-with-rolling-date
fileAppender.RollingStyle = rollingMode;
if (rollingMode == log4net.Appender.RollingFileAppender.RollingMode.Date && !string.IsNullOrEmpty(rollingModeDatePattern))
{
fileAppender.DatePattern = "yyyyMMdd";
}
if (threshold != null)
{
fileAppender.Threshold = threshold;
}
fileAppender.ActivateOptions();
repo.Root.AddAppender(fileAppender);
}
public static void AddSmtpAppender(string toAddress, string fromAddress, string subject, string smtpHost,
int smtpPort = 25,
int bufferSize = 100000,
log4net.Core.Level threshold = null,
string logPattern = CodeConfiguredUtilities.DefaultLogPattern)
{
// it's cast to a Hierarchy because we need repo.Root to add appenders
var repo = (log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository();
var logPatternLayout = new log4net.Layout.PatternLayout(logPattern);
var smtpAppender = new log4net.Appender.SmtpAppender();
smtpAppender.Layout = logPatternLayout;
smtpAppender.To = toAddress;
smtpAppender.From = fromAddress;
smtpAppender.Subject = subject;
smtpAppender.SmtpHost = smtpHost;
smtpAppender.Port = smtpPort;
smtpAppender.BufferSize = bufferSize;
if (threshold != null)
{
smtpAppender.Threshold = threshold;
}
smtpAppender.ActivateOptions();
repo.Root.AddAppender(smtpAppender);
}
private Level FromLog4NetLevel(log4net.Core.Level level)
{
if (level == log4net.Core.Level.Debug)
{
return(Level.Debug);
}
if (level == log4net.Core.Level.Error)
{
return(Level.Error);
}
if (level == log4net.Core.Level.Fatal)
{
return(Level.Fatal);
}
if (level == log4net.Core.Level.Info)
{
return(Level.Information);
}
if (level == log4net.Core.Level.Warn)
{
return(Level.Warning);
}
throw new ArgumentException("Unsupported Level.", "level");
}
/// <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;
}
}
public static void ChangeLogLevel(log4net.Core.Level logLevel)
{
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Root.Level = logLevel;
hierarchy.RaiseConfigurationChanged(System.EventArgs.Empty);
}
/// <summary>
/// Make sure that the repository thresholds are at least as high
/// as the level we set here. This does not allow us to lower the
/// logging level. That would be complex, because even in cases
/// where we don't want heavy logging, we still want to make sure
/// we get our status messages.
/// </summary>
/// <param name="loglevel"></param>
/// <param name="force"></param>
private static void SetLogLevel(string loglevel, bool force)
{
log4net.Core.Level logLevel = log4net.Core.Level.Off;
switch (loglevel.ToLowerInvariant())
{
case "0":
case "debug":
logLevel = log4net.Core.Level.Debug;
break;
case "1":
case "2":
case "info":
logLevel = log4net.Core.Level.Info;
break;
case "3":
case "warn":
logLevel = log4net.Core.Level.Warn;
break;
case "4":
case "error":
logLevel = log4net.Core.Level.Error;
break;
default:
log.WarnFormat("Invalid log level: {0}", loglevel);
return;
}
LogUtil.SetLogLevel(logLevel, force);
}
public static void Log(object obj, LogLevel level, string format, params object[] args)
{
Initialize();
log4net.Core.Level logLevel = GetLevel(level);
if (logLevel == null || !logger.Logger.IsEnabledFor(logLevel))
{
return;
}
Exception ex = args != null?args.OfType <Exception>().FirstOrDefault() : null;
string message = (format != null) ? (args != null ? String.Format(format, args) : format) : format;
Type objType = (obj is Type) ? (obj as Type) : obj.GetType();
string type = (obj == null || obj is Unknown) ? "static|" :
objType.FullName + "|";
// determine which logger to use
ILog iLog = (separatedLoggers.ContainsKey(objType)) ? separatedLoggers[objType] : logger;
iLog.Logger.Log(objType, logLevel, type + message, ex);
Console.WriteLine(type + message);
}
/// <summary>
/// Method for logging a given message to the test bed core log
/// </summary>
/// <param name="level">The <see cref="log4net.Core.Level"/> indicating the severity of the message</param>
/// <param name="msg">The message to be logged</param>
public void Log(log4net.Core.Level level, string msg)
{
// Send the message to the callback function
if (_logHandler != null)
{
_logHandler.Invoke(level + "::" + msg);
}
// Send out the log towards the core log topic
if (_logProducer != null)
{
Message <EDXLDistribution, Log> message = new Message <EDXLDistribution, Log>()
{
Key = CreateCoreKey(),
Value = new Log()
{
id = _configuration.Settings.clientid,
log = msg,
},
};
_logProducer.ProduceAsync(Configuration.CoreTopics["log"], message);
}
else
{
throw new NullReferenceException($"Could not create the log producer that should send the following log:\n{msg}");
}
}
/// <summary>
/// Log the various User Properties.
/// </summary>
/// <param name="ai">The Appointment item.</param>
/// <param name="thresholdLevel">Only log if logging configured at this level or higher.</param>
public static void LogProperties(AppointmentItem ai, log4net.Core.Level thresholdLevel)
{
if (((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root.Level.Value > thresholdLevel.Value)
{
return;
}
UserProperties ups = null;
UserProperty up = null;
try {
log.Debug(OutlookOgcs.Calendar.GetEventSummary(ai));
ups = ai.UserProperties;
for (int p = 1; p <= ups.Count; p++)
{
try {
up = ups[p];
log.Debug(up.Name + "=" + up.Value.ToString());
} finally {
up = (UserProperty)OutlookOgcs.Calendar.ReleaseObject(up);
}
}
} catch (System.Exception ex) {
OGCSexception.Analyse("Failed to log Appointment UserProperties", ex);
} finally {
ups = (UserProperties)OutlookOgcs.Calendar.ReleaseObject(ups);
}
}
/// <summary>
/// Convert log4net log level enum to key int
/// </summary>
/// <param name="logLevel">log4net.Core.Level; Enum for log level</param>
/// <returns>int; Key integer code</returns>
private static int lookupIntFromLogLevel(log4net.Core.Level logLevel)
{
if (logLevel == log4net.Core.Level.Debug)
{
return(6);
}
else if (logLevel == log4net.Core.Level.Info)
{
return(5);
}
else if (logLevel == log4net.Core.Level.Warn)
{
return(4);
}
else if (logLevel == log4net.Core.Level.Error)
{
return(3);
}
else if (logLevel == log4net.Core.Level.Fatal)
{
return(2);
}
else
{
return(5);
}
}
public void AppendText(string text, log4net.Core.Level level)
{
var col = AppenderTextBox.ForeColor;
if (level.Value < log4net.Core.Level.Info.Value)
{
col = Color.Gray;
}
if (level.Value >= log4net.Core.Level.Warn.Value)
{
col = Color.Blue;
}
if (level.Value >= log4net.Core.Level.Error.Value)
{
col = Color.Red;
}
AppenderTextBox.SelectionStart = AppenderTextBox.TextLength;
if (col != AppenderTextBox.ForeColor && AppenderTextBox is RichTextBox rtb)
{
AppenderTextBox.SelectionLength = 0;
rtb.SelectionColor = col;
}
AppenderTextBox.ScrollToCaret();
AppenderTextBox.AppendText(StringUtils.HandleCRLFCombinations(text, " "));
if (col != AppenderTextBox.ForeColor && AppenderTextBox is RichTextBox rtb2)
{
rtb2.SelectionColor = AppenderTextBox.ForeColor;
}
}
public void ConfigureAppender(CrossDomainParentAppender parentAppender, log4net.Core.Level level)
{
CrossDomainOutboundAppender outboundAppender = new CrossDomainOutboundAppender(parentAppender);
outboundAppender.Threshold = level;
log4net.Config.BasicConfigurator.Configure(outboundAppender);
}
public LogConfig()
{
rootLevel = log4net.Core.Level.Debug;
patternLayout = new PatternLayout();
patternLayout.ConversionPattern = "%d %-7p [TID=%3t] %m%n";
consoleAppender = new ManagedColoredConsoleAppender();
consoleAppender.Layout = patternLayout;
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.Red, BackColor=ConsoleColor.White, Level = log4net.Core.Level.Fatal });
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.Red, Level = log4net.Core.Level.Error});
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.Yellow, Level = log4net.Core.Level.Warn });
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.Green, Level = log4net.Core.Level.Info});
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.White, Level = log4net.Core.Level.Debug});
consoleAppender.AddMapping(new ManagedColoredConsoleAppender.LevelColors() { ForeColor = ConsoleColor.Gray, Level = log4net.Core.Level.Verbose });
rollingAppender = new RollingFileAppender();
rollingAppender.Layout = patternLayout;
rollingAppender.MaxFileSize = 10 * 1048576;
rollingAppender.MaxSizeRollBackups = 20;
rollingAppender.AppendToFile = true;
rollingAppender.RollingStyle = RollingFileAppender.RollingMode.Size;
rollingAppender.StaticLogFileName = true;
rollingAppender.File = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Assembly.GetEntryAssembly().GetName().Name + ".log");
}
/// <summary>
///
/// </summary>
/// <param name="log"></param>
/// <param name="level"></param>
/// <param name="exception"></param>
/// <param name="message"></param>
/// <param name="args"></param>
private static void Write(log4net.ILog log, log4net.Core.Level level, Exception exception, string message, params object[] args)
{
if (args != null)
{
message = string.Format(message, args);
}
log.Logger.Log(declaringType, level, message, exception);
}
/// <summary>
/// Write an entry to the registered log appenders.
/// </summary>
/// <param name="logLevel">The severity level of the log entry.</param>
/// <param name="exception">The exception to record in the log entry.</param>
/// <param name="message">
/// The message for the log entry, optionally in a <see cref="String.Format(string, object[])"/>
/// form when there are <paramref name="arguments"/>.
/// </param>
/// <param name="arguments">Optional arguments to format the <paramref name="message"/>.</param>
/// <remarks>
/// Both <see cref="LogLevel.Debug"/> and <see cref="LogLevel.Trace"/> levels are fed
/// to <see cref="log4net.ILog.Debug(object, Exception)"/>.
/// </remarks>
public void Log(LogLevel logLevel, Exception exception, string message, params object[] arguments)
{
string formattedMessage = String.Format(message, arguments);
log4net.Core.Level log4netLevel = TranslateToLog4netLevel(logLevel);
log.Logger.Log(GetType(), log4netLevel, formattedMessage, exception);
}
/// <summary>
/// Write an entry to the registered log appenders.
/// </summary>
/// <param name="logLevel">The severity level of the log entry.</param>
/// <param name="formatProvider">The formatter to use for the <paramref name="message"/>.</param>
/// <param name="message">
/// The message for the log entry, in a <see cref="String.Format(IFormatProvider, string, object[])"/> form.
/// </param>
/// <param name="arguments">Optional arguments to format the <paramref name="message"/>.</param>
/// <remarks>
/// Both <see cref="LogLevel.Debug"/> and <see cref="LogLevel.Trace"/> levels are fed
/// to <see cref="log4net.ILog.DebugFormat(IFormatProvider, string, object[])"/>.
/// </remarks>
public void Log(LogLevel logLevel, IFormatProvider formatProvider, string message, params object[] arguments)
{
string formattedMessage = String.Format(formatProvider, message, arguments);
log4net.Core.Level log4netLevel = TranslateToLog4netLevel(logLevel);
log.Logger.Log(GetType(), log4netLevel, formattedMessage, null);
}
/// <summary>
/// Converts a log4net <see cref="log4net.Core.Level"/> to a <see cref="Level"/>.
/// </summary>
/// <param name="level">The <see cref="log4net.Core.Level"/> to convert.</param>
/// <returns>The <see cref="Level"/>. If an unknown <see cref="log4net.Core.Level"/> is used
/// <see cref="Level.Other"/> is returned.</returns>
internal static Level ToLevel(log4net.Core.Level level)
{
if (_reverseLevelTable.TryGetValue(level, out Level result))
{
return(result);
}
return(Level.Other);
}
private static void actualLog(log4net.Core.Level level, object message, Exception exception, ILog internalLogger, int skipFrames)
{
StackFrame frame = new StackTrace(skipFrames, true).GetFrame(0);
MethodBase methodBase = frame.GetMethod();
getFrame(skipFrames, frame, methodBase);
log4net.Core.LoggingEventData eventData = getEventData(level, message, exception, frame, methodBase);
log4net.Core.LoggingEvent le = new log4net.Core.LoggingEvent(methodBase.DeclaringType, logueador.Logger.Repository, eventData, log4net.Core.FixFlags.All);
internalLogger.Logger.Log(le);
}
private void AddCountItem(log4net.Core.Level level)
{
var countLvi = new ListViewItem(level + ": 0");
countLvi.Tag = 0;
countLvi.Name = level.DisplayName;
countLvi.BackColor = GetColour(level);
countLvi.Checked = IsVisible(level);
Counts.Add(level, countLvi);
}
/// <summary>
/// Initializes log4net to log to a memory appender which can then be referenced
/// </summary>
public Logging(log4net.Core.Level level = null)
{
Logger.Level = level ?? log4net.Core.Level.All;
Logger.RemoveAllAppenders();
Logger.AddAppender(MemoryAppender);
Logger.Repository.Configured = true;
Log.Initialize(new Logger());
}
/// <summary>
/// 日志对象
/// </summary>
//private static log4net.ILog log = null;
/// <summary>
/// 写入日志
/// </summary>
/// <param name="value"></param>
/// <param name="path"></param>
/// <param name="level"></param>
public static void WriteToLog(this string value, string path = "", log4net.Core.Level level = null)
{
log4net.ILog log = null;
log4net.GlobalContext.Properties["LogUrl"] = WorkPath.ApplicationWorkPath + "\\logs\\" + path;
string config = WorkPath.ExecPath + @"\Log4net.config";
if (File.Exists(path))
{
log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo(config));
log = log4net.LogManager.GetLogger("");
}
else
{
log = log4net.LogManager.GetLogger("");
}
if (level == log4net.Core.Level.Debug)
{
log.Debug(value);
}
else if (level == log4net.Core.Level.Info)
{
log.Info(value);
}
else if (level == log4net.Core.Level.Error)
{
log.Error(value);
}
else if (level == log4net.Core.Level.Fatal)
{
log.Fatal(value);
}
else if (level == log4net.Core.Level.Warn)
{
log.Warn(value);
}
else
{
log.Info(value);
}
//try
//{
// using (StreamWriter s = System.IO.File.AppendText(System.IO.Path.GetFullPath(Constant.ApplicationWorkPath + @"\Log.log")))
// {
// s.WriteLine(value);
// }
//}
//catch (Exception ex)
//{
// ex.ToString();
//}
}
public static void SetLogLevel(log4net.Core.Level logLevel, bool force)
{
log4net.Repository.ILoggerRepository[] repositories = log4net.LogManager.GetAllRepositories();
foreach (log4net.Repository.ILoggerRepository repository in repositories)
{
log4net.Repository.Hierarchy.Hierarchy hierarchy = repository as log4net.Repository.Hierarchy.Hierarchy;
if (hierarchy.Root.Level > logLevel || force)
{
hierarchy.Root.Level = logLevel;
}
}
}
private static log4net.Appender.TraceAppender GetTraceAppender(
log4net.Core.Level traceLogLevel)
{
log4net.Appender.TraceAppender appender = new log4net.Appender.TraceAppender();
appender.Name = "Trace";
appender.Layout = new log4net.Layout.PatternLayout(
"%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p %c - %m%n");
appender.Threshold = traceLogLevel;
appender.ActivateOptions();
return(appender);
}
public bool SetLogLevel(string level)
{
if (!_levelMap.ContainsKey(level))
{
return(false);
}
log4net.Core.Level lvl = _levelMap[level];
((log4net.Repository.Hierarchy.Hierarchy)log4net.LogManager.GetRepository()).Root.Level = lvl;
return(true);
}
/// <summary>
/// Sets the root of the log4net hierarchy to the level specified
/// </summary>
/// <param name="level">the level to which to set the root</param>
private static void SetRootLevel(log4net.Core.Level level)
{
if (level == null)
{
return;
}
log4net.Repository.Hierarchy.Hierarchy hierarchy = log4net.LogManager.GetRepository() as log4net.Repository.Hierarchy.Hierarchy;
if (null != hierarchy)
{
lock (hierarchy) { hierarchy.Root.Level = level; }
}
}
#pragma warning disable 0618
/// <summary>
/// Initializes a new instance of the <see cref="HighPerformance"/> class.
/// </summary>
internal HighPerformance() {
////if (!WaitForQuietCpu()) {
//// Assert.Inconclusive("Timed out waiting for a quiet CPU in which to perform perf tests.");
////}
this.originalLoggerThreshold = LogManager.GetLoggerRepository().Threshold;
LogManager.GetLoggerRepository().Threshold = LogManager.GetLoggerRepository().LevelMap["OFF"];
this.powerSetting = new PowerManagment.PowerSetting(PowerManagment.PowerProfiles.HighPerformance);
this.originalProcessPriority = Process.GetCurrentProcess().PriorityClass;
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
Thread.CurrentThread.Priority = ThreadPriority.Highest;
SpinCpu();
}
private void ConfigureLog4Net(log4net.Core.Level LogLevel = null)
{
if (Equals(LogLevel, null))
{
LogLevel = log4net.Core.Level.All;
}
log4net.Appender.ColoredConsoleAppender appender = new log4net.Appender.ColoredConsoleAppender();
appender.Layout = new log4net.Layout.SimpleLayout();
appender.Threshold = LogLevel;
appender.Name = "TESTING";
appender.ActivateOptions();
log4net.Config.BasicConfigurator.Configure(appender);
}
private Log()
{
using (MediaPortal.Profile.Settings xmlreader = new MediaPortal.Profile.MPSettings())
{
var MPminLevel = (MediaPortal.Services.Level)Enum.Parse(typeof(MediaPortal.Services.Level), xmlreader.GetValueAsString("general", "loglevel", "2"));
switch(MPminLevel)
{
case MediaPortal.Services.Level.Information: minLevel = log4net.Core.Level.Info; break;
case MediaPortal.Services.Level.Warning: minLevel = log4net.Core.Level.Warn; break;
case MediaPortal.Services.Level.Error: minLevel = log4net.Core.Level.Error; break;
}
}
Hierarchy hierarchy = (Hierarchy)LogManager.CreateRepository("OnlineVideos");
PatternLayout patternLayout = new PatternLayout();
patternLayout.ConversionPattern = "[%date{MM-dd HH:mm:ss,fff}] [%-12thread] [%-5level] %message%newline";
patternLayout.ActivateOptions();
RollingFileAppender roller = new RollingFileAppender();
roller.Encoding = System.Text.UTF8Encoding.UTF8;
roller.Layout = patternLayout;
roller.LockingModel = new FileAppender.MinimalLock();
roller.AppendToFile = true;
roller.RollingStyle = RollingFileAppender.RollingMode.Once;
roller.PreserveLogFileNameExtension = true;
roller.MaxSizeRollBackups = 1;
roller.MaximumFileSize = "10MB";
roller.StaticLogFileName = true;
roller.File = MediaPortal.Configuration.Config.GetFile(MediaPortal.Configuration.Config.Dir.Log, "OnlineVideos.log");
roller.ActivateOptions();
hierarchy.Root.AddAppender(roller);
hierarchy.Root.Level = minLevel;
hierarchy.Configured = true;
logger = log4net.LogManager.GetLogger("OnlineVideos", "OnlineVideos");
}
public LogConfig SetRootLevel(Level level)
{
rootLevel = Log.Get4NetLevel(level);
return this;
}
