public void LogMsg(Level level, string message)
        {
            //Debug.WriteLine( String.Format( "{0} {1}", level.ToString(), message ) );

            if (level == Level.Info)
            {
                _log.Info(message);
            }
            else if (level == Level.Debug)
            {
                _log.Debug(message);
            }
            else if (level == Level.Error)
            {
                _log.Error(message);
            }
            else if (level == Level.Warn)
            {
                _log.Warn(message);
            }
            else
            {
                _log.Info(message);
            }
        }

 /// <summary>
 /// Lookup the mapping for the specified level
 /// </summary>
 /// <param name="level">the level to lookup</param>
 /// <returns>the <see cref="LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
 /// <remarks>
 /// <para>
 /// Lookup the value for the specified level. Finds the nearest
 /// mapping value for the level that is equal to or less than the
 /// <paramref name="level"/> specified.
 /// </para>
 /// <para>
 /// If no mapping could be found then <c>null</c> is returned.
 /// </para>
 /// </remarks>
 public LevelMappingEntry Lookup(Level level) {
   if (m_entries != null)
     foreach (LevelMappingEntry entry in m_entries)
       if (level >= entry.Level)
         return entry;
   return null;
 }

 static int GetIndexForLevel(Level level)
 {
   if (level == Level.Info) return 2;
   if (level == Level.Warn) return 3;
   if (level == Level.Error || level == Level.Fatal) return 4;
   return 1;
 }

		public static void BindConsole(PatternLayout layout = null, Level level = null)
		{
			layout = layout ?? new PatternLayout
			{
				ConversionPattern = "%date{ISO8601} %level %logger - %message%newline"
			};

			layout.ActivateOptions();

			var consoleAppender = new ConsoleAppender
			{
				Name = "console",
				Layout = layout
			};

			consoleAppender.ActivateOptions();

			var hierarchy = (Hierarchy)LogManager.GetRepository();

			if (hierarchy.Root.GetAppender("console") != null)
			{
				return;
			}

			hierarchy.Root.AddAppender(consoleAppender);
			hierarchy.Root.Level = level ?? Level.Info;

			hierarchy.Configured = true;
		}

 /// <summary>
 /// Helper method to convert <see cref="Level"/> into a string ID that is mapped based upon the TOPS Syslog standard: https://confluence.mw.inc/display/TO/TOps+Syslog+Standard
 /// </summary>
 /// <param name="level"><see cref="Level"/> to convert to string</param>
 /// <returns>string representing the syslog priority code as defined in the TOPS Syslog standard</returns>
 public static string ConvertLevelToPriority(Level level)
 {
     if (level >= Level.Emergency)
     {
         return "128";
     }
     else if (level >= Level.Fatal)
     {
         return "130";
     }
     else if (level >= Level.Error)
     {
         return "131";
     }
     else if (level >= Level.Warn)
     {
         return "132";
     }
     else if (level >= Level.Info)
     {
         return "134";
     }
     else
     {
         return "135"; // debug
     }
 }

 private static void Log(string message, Level logLevel, string exceptionMessage, params object[] parameters)
 {
     if (WriteAsync)
     {
         BackgroundWorker worker = new BackgroundWorker();
         worker.DoWork += LogEvent;
         worker.RunWorkerAsync(new LogMessageSpec
         {
             ExceptionMessage = exceptionMessage,
             LogLevel = logLevel,
             Message = message,
             Parameters = parameters,
             Stack = new StackTrace(),
             LogTime = DateTime.Now
         });
     }
     else
     {
         PerformLog(new LogMessageSpec
         {
             ExceptionMessage = exceptionMessage,
             LogLevel = logLevel,
             Message = message,
             Parameters = parameters,
             Stack = new StackTrace(),
             LogTime = DateTime.Now
         });
     }
 }

        private void PerformLog(Type type, Level level, Func<string> messageDelegate, Exception ex)
        {
            ThreadContext.Properties["subscriber"] = _subscriber.Email;
            ThreadContext.Properties["subscriberId"] = _subscriber.Id;

            _log.Logger.Log(type, level, messageDelegate.Invoke(), ex);
        }

        /// <summary>
        /// Configures the log4net environment
        /// </summary>
        private void Setup(Level logLevel)
        {
            Directory.CreateDirectory(_logFolder);


            var hierarchy = (Hierarchy)LogManager.GetRepository();

            // Log to a file
            var roller = new RollingFileAppender();
            roller.AppendToFile = false;
            roller.File = _logFile;
            roller.Layout = new PatternLayout("%date %type.%method [%-5level] - %message%newline");
            roller.MaxSizeRollBackups = 5;
            roller.RollingStyle = RollingFileAppender.RollingMode.Size;
            roller.StaticLogFileName = true;
            roller.ActivateOptions();
            hierarchy.Root.AddAppender(roller);

            // Log to the visual studio console
            var appender = new TraceAppender();
            appender.ActivateOptions();
            appender.Layout = new PatternLayout("%method (%line) %date [%-5level] - %message%newline");
            hierarchy.Root.AddAppender(appender);

            hierarchy.Root.Level = logLevel;
            hierarchy.Configured = true;
        }

        public void InfoFormat(string format, IMessage message, MessageId messageId, int messageSize, IList<Peer> peers, Level logLevel = null)
        {
            if (peers.Count == 0)
            {
                InfoFormat(format, message, messageId, messageSize);
                return;
            }
            if (peers.Count == 1)
            {
                InfoFormat(format, message, messageId, messageSize, peerId: peers[0].Id);
                return;
            }

            var logInfo = GetLogInfo(message);
            if (!logInfo.Logger.IsInfoEnabled)
                return;

            var messageText = logInfo.GetMessageText(message);
            var otherPeersCount = peers.Count - 1;
            var peerIdText = otherPeersCount > 1
                ? peers[0].Id + " and " + otherPeersCount + " other peers"
                : peers[0].Id + " and " + otherPeersCount + " other peer";

            _logger.Logger.Log(_loggerType, logLevel ?? Level.Info, string.Format(format, messageText, messageId, messageSize, peerIdText), null);
        }

 internal static LogLevel FromLog4Net( Level level )
 {
     if ( level == Level.Error )
     {
         return LogLevel.Error;
     }
     else if ( level == Level.Warn )
     {
         return LogLevel.Warning;
     }
     else if ( level == Level.Notice )
     {
         return LogLevel.Notice;
     }
     else if ( level == Level.Info )
     {
         return LogLevel.Info;
     }
     else if ( level == Level.Debug )
     {
         return LogLevel.Debug;
     }
     else
     {
         throw new NotSupportedException( "LogLevel not supported: " + level );
     }
 }

        private static void ConfigureColoredConsoleAppender(Level threshold)
        {
            var appender = new ColoredConsoleAppender
                           {
                Threshold = threshold
            };

            appender.AddMapping(
                new ColoredConsoleAppender.LevelColors
                {
                    Level = Level.Debug,
                    ForeColor = ColoredConsoleAppender.Colors.White
                });
            appender.AddMapping(
                new ColoredConsoleAppender.LevelColors
                {
                    Level = Level.Info,
                    ForeColor = ColoredConsoleAppender.Colors.Green
                });
            appender.AddMapping(
                new ColoredConsoleAppender.LevelColors
                {
                    Level = Level.Warn,
                    ForeColor = ColoredConsoleAppender.Colors.Yellow | ColoredConsoleAppender.Colors.HighIntensity
                });
            appender.AddMapping(
                new ColoredConsoleAppender.LevelColors
                {
                    Level = Level.Error,
                    ForeColor = ColoredConsoleAppender.Colors.Red | ColoredConsoleAppender.Colors.HighIntensity
                });

            ConfigureAppender(appender);
        }

        /// <summary>
        /// Create a new evaluator using the specified <see cref="Level"/> threshold.
        /// </summary>
        /// <param name="threshold">the threshold to trigger at</param>
        /// <remarks>
        /// <para>
        /// Create a new evaluator using the specified <see cref="Level"/> threshold.
        /// </para>
        /// <para>
        /// This evaluator will trigger if the level of the event
        /// passed to <see cref="IsTriggeringEvent(LoggingEvent)"/>
        /// is equal to or greater than the <see cref="Threshold"/>
        /// level.
        /// </para>
        /// </remarks>
        public LevelEvaluator(Level threshold)
        {
            if (threshold == null)
                throw new ArgumentNullException("threshold");

            m_threshold = threshold;
        }

 public TextWriterToLog4Net(string loggerName, Level defaultLevel)
     : base()
 {
     this.LoggerName = loggerName;
     this.DefaultLevel = defaultLevel;
     this.TrimHeaders = true;
 }

        public static void WriteMessage(string message, Level level)
        {
            var stackTrace = new StackTrace(true);
            var frame = stackTrace.GetFrame(1);

            if (level == Level.Debug && Logger.IsDebugEnabled)
            {
                Logger.Debug(LoggerMessage.CreateMessage(message, frame));
            }
            if (level == Level.Error && Logger.IsErrorEnabled)
            {
                Logger.Error(LoggerMessage.CreateMessage(message, frame));
            }
            if (level == Level.Fatal && Logger.IsFatalEnabled)
            {
                Logger.Fatal(LoggerMessage.CreateMessage(message, frame));
            }
            if (level == Level.Warn && Logger.IsWarnEnabled)
            {
                Logger.Warn(LoggerMessage.CreateMessage(message, frame));
            }
            if (level == Level.Info && Logger.IsInfoEnabled)
            {
                Logger.Info(LoggerMessage.CreateMessage(message, frame));
            }
        }

        public LogControl()
        {
            InitializeComponent();


            this.SuspendLayout();
            var levels = new Level[] { Level.Debug, Level.Info, Level.Warn, Level.Error, Level.Fatal };
            chkLevels = new List<CheckBox>(levels.Length);
            foreach (var level in levels)
            {
                var chkLevel = new CheckBox();
                chkLevel.Checked = level != Level.Debug;
                chkLevel.Text = level.ToString();
                chkLevel.Tag = level;
                chkLevel.CheckedChanged += new EventHandler(chkLevel_CheckedChanged);
                pnlFilter.Controls.Add(chkLevel);
                chkLevels.Add(chkLevel);
            }
            btnClean = new Button();
            btnClean.Margin = chkLevels.First().Margin;
            btnClean.Text = "clean";
            btnClean.Click += new EventHandler(btnClean_Click);
            pnlFilter.Controls.Add(btnClean);

            lblCount = new Label();
            lblCount.Margin = chkLevels.First().Margin;
            lblCount.Text = "0";
            pnlFilter.Controls.Add(lblCount);
            this.ResumeLayout(true);
        }

 public virtual long Map(Level log4NetLevel)
 {
     if (log4NetLevel == null) return (long)LocalSyslogAppender.SyslogSeverity.Debug;
     var mappedValue = (long)LocalSyslogAppender.SyslogSeverity.Debug;
     levelMappings.TryGetValue(log4NetLevel.Name, out mappedValue);
     return mappedValue;
 }

        public LoggerConfiguration(string appDataFolder, Level logLevel)
        {
            _logFolder = appDataFolder + "\\Logs";
            _logFile = _logFolder + "\\events.log";

            Setup(logLevel);
        }

        public static void SetThresholdForAppender(string appenderName, Level threshold)
        {
            var appender = (AppenderSkeleton) GetAppender(appenderName);

            appender.Threshold = threshold;
            appender.ActivateOptions();
            return;
        }

 private void SetUpLog(Level level)
 {
     _memoryAppender = new MemoryAppender();
     Logger root = ((Hierarchy) LogManager.GetRepository()).Root;
     root.Level = level;
     root.AddAppender(_memoryAppender);
     root.Repository.Configured = true;
 }

 public MethodLogger(string text, string methodName, ILog logger, Level logLevel)
 {
     _text = text;
     _methodName = methodName;
     _logger = logger;
     _logLevel = logLevel;
     _logger.Logger.Log(typeof (MethodLogger), _logLevel, $"Entered method {_methodName}: {_text}", null);
     _stopWatch = Stopwatch.StartNew();
 }