static void WriteLine(LoggerLevel level, string message)
 {
     ConsoleColor color = ConsoleColor.White;
     switch (level)
     {
         case LoggerLevel.Info:
             color = ConsoleColor.Green;
             break;
         case LoggerLevel.Debug:
             color = ConsoleColor.White;
             break;
         case LoggerLevel.Warn:
             color = ConsoleColor.Yellow;
             break;
         case LoggerLevel.Error:
             color = ConsoleColor.Red;
             break;
         default:
             break;
     }
     if (WaitForInput)
     {
         message = Environment.NewLine + message;
     }
     Console.ForegroundColor = color;
     Console.WriteLine(message);
     Console.ResetColor();
     if (WaitForInput)
     {
         Console.Write(Prefix);
     }
 }

 // ----------------------------------------------------------------------
 protected override void Output( LoggerLevel level, object message, Exception exception )
 {
     buffer.Append( level.ToString() );
     buffer.Append( ": " );
     buffer.AppendLine( message == null ? "null" : message.ToString() );
     Output( exception );
 }

 /// <summary>
 /// Instantiates an Azure Web Farm Role.
 /// </summary>
 /// <param name="logFactory">The Castle.Core Logger Factory to use for logging, AzureDiagnosticsTraceListenerFactory by default</param>
 /// <param name="loggerLevel">The Castle.Core Log Level to use for logging, LoggerLevel.Info by default</param>
 /// <param name="diagnosticsLogLevel">The log level to use for Azure Diagnostics, LogLevel.Information by default</param>
 public WebFarmRole(ILoggerFactory logFactory = null, LoggerLevel? loggerLevel = null, LogLevel? diagnosticsLogLevel = null)
 {
     _logFactory = logFactory ?? new AzureDiagnosticsTraceListenerFactory();
     _logLevel = loggerLevel ?? LoggerLevel.Info;
     _logger = _logFactory.Create(GetType(), _logLevel);
     _diagnosticsLogLevel = diagnosticsLogLevel ?? LogLevel.Information;
 }

		public override ILogger Create(string name, LoggerLevel level)
		{
			StreamLogger logger =
				new StreamLogger(name, new FileStream(name + ".log", FileMode.Append, FileAccess.Write), Encoding.Default);
			logger.Level = level;
			return logger;
		}

 public BackgroundWorkerService(string sitesPath, string executablePath, ILoggerFactory loggerFactory, LoggerLevel logLevel)
 {
     _executablePath = executablePath;
     _executables = new Dictionary<string, List<Executable>>();
     _executableFinder = new ExecutableFinder(sitesPath);
     _logger = loggerFactory.Create(GetType(), logLevel);
 }

        public override void Write(string logText, LoggerLevel loggerLevel, string source = "", string category = "", string metaData = "")
        {
            lock (this)
            {
                var useSource = string.Format(
                    "{0}{1}{2}",
                    GlobalSource,
                    (GlobalSource != "" & source != "" ? ":" : ""),
                    source);

                var dateString = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff");

                _file.WriteLine(
                    "{0}|{1}|{2}|{3}|{4}",
                    dateString,
                    useSource,
                    loggerLevel,
                    metaData,
                    logText);

                if (FlushAfterEachWrite)
                {
                    _file.Flush();
                }
            }
        }

        public void Log(String logMessage, LoggerLevel messageLevel, params ComponentType[] messageComponentTypes)
        {
            if (messageLevel < _logThreshholdLevel) { return; }

            string date = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss");
            string level = messageLevel == LoggerLevel.NULL ? "   " : messageLevel.ToString();
            string type = messageComponentTypes[0] == ComponentType.NULL ? "   " : ComponentTypeUtil.GetCodeFromType(messageComponentTypes[0]);

            // If no component types are specified, log everything.
            if (componentTypesToLog == null || componentTypesToLog.Count == 0)
            {
                _streamWriter.WriteLine(date + " | " + level + " | " + type + " | " + logMessage);
                _streamWriter.Flush();
                return;
            }
            else // Else, only log messages matching one of the specified component types.
            {
                foreach (ComponentType componentType in messageComponentTypes)
                {
                    if (componentTypesToLog.Contains(componentType))
                    {
                        _streamWriter.WriteLine(date + " | " + level + " | " + type + " | " + logMessage);
                        _streamWriter.Flush();
                        return;
                    }
                }
            }
        }

      private static string FormatMessage(LoggerLevel loggerLevel, string message)
      {
         string messageIdentifier = String.Empty;

         switch (loggerLevel)
         {
            case LoggerLevel.Off:
               messageIdentifier = " ";
               break;
            case LoggerLevel.Error:
            case LoggerLevel.Fatal:
               messageIdentifier = "X";
               break;
            case LoggerLevel.Warn:
               messageIdentifier = "!";
               break;
            case LoggerLevel.Info:
               messageIdentifier = "-";
               break;
            case LoggerLevel.Debug:
               messageIdentifier = "+";
               break;
         }

         DateTime dateTime = DateTime.Now;
         return String.Format("[{0}-{1}] {2} {3}", dateTime.ToShortDateString(), dateTime.ToLongTimeString(), messageIdentifier, message);
      }

 public IISManager(string localSitesPath, string tempSitesPath, ISyncStatusRepository syncStatusRepository, ILoggerFactory loggerFactory, LoggerLevel logLevel)
 {
     _syncStatusRepository = syncStatusRepository;
     _localSitesPath = localSitesPath;
     _tempSitesPath = tempSitesPath;
     _logger = loggerFactory.Create(GetType(), logLevel);
 }

 public static void SetLogLevel(LoggerLevel logLevel)
 {
     lock (lockObject)
     {
         maxLogLevel = logLevel;
     }
 }

		public ConsoleLogger(LoggerLevel level, bool console = true, bool trace = false, bool debug = false) :
			base(level)
		{
			_console = console;
			_debug = debug;
			_trace = trace;
			_color = Console.BackgroundColor;
		}

 protected override void Log(LoggerLevel loggerLevel, string loggerName, string message, Exception exception)
 {
     Console.Out.WriteLine("[{0} - {3}] '{1}' {2}", loggerLevel, loggerName, message, DateTime.Now.ToLongTimeString());
     if (exception == null)
         return;
     Console.Out.WriteLine("[{0} - {5}] '{1}' {2}: {3} {4}", loggerLevel, loggerName,
         exception.GetType().FullName, exception.Message, exception.StackTrace, DateTime.Now.ToLongTimeString());
 }

        public static void LogEntry(LoggerLevel level, string message, int code)
        {
            LogEntry log = new Code.LogEntry() { Level = level, Message = message, Code = code };

            IDocumentSession conn = JournalDb.GetDBConnection();
            conn.Store(log);
            conn.SaveChanges();
        }

		public virtual ILogger Create(Type type, LoggerLevel level)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}

			return Create(type.FullName, level);
		}

 // ----------------------------------------------------------------------
 public LoggerEvent( LoggerLevel level, string source, string context, string message, Exception caughtException )
 {
     int levelValue = (int)level;
     this.level = levelValue < 0 ? LoggerLevel.Fatal : ( levelValue > 4 ? LoggerLevel.Fatal : level );
     this.source = ArgumentCheck.NonemptyTrimmedString( source, "source" );
     this.context = context ?? string.Empty;
     this.message = message ?? string.Empty;
     this.caughtException = caughtException;
 }

 public static void Initialize(ILogger newLogger, LoggerLevel logLevel)
 {
     if (logger != null)
     {
         throw new InvalidOperationException("Logger may only be initialized once");
     }
     logger = newLogger;
     maxLogLevel = logLevel;
 }

        public void WriteEntry(LoggerLevel level, string format, params object[] args)
        {
            var now = DateTime.Now.ToLongTimeString();

            var message = string.Format(format, args);

            textWriter.WriteLine("[{0}] {1} {2}", now, level, message);
            textWriter.Flush();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WhiteLogRedirector"/> class.
        /// </summary>
        /// <param name="name">The name for the logger.</param>
        /// <param name="level">The default log level.</param>
        /// <param name="diagnostics">The object that provides the logging for the application.</param>
        /// <exception cref="ArgumentNullException">
        ///     Thrown if <paramref name="diagnostics"/> is <see langword="null" />.
        /// </exception>
        public WhiteLogRedirector(string name, LoggerLevel level, SystemDiagnostics diagnostics)
            : base(name, level)
        {
            {
                Lokad.Enforce.Argument(() => diagnostics);
            }

            m_Diagnostics = diagnostics;
        }

        /// <summary>
        ///   A Common method to log.
        /// </summary>
        /// <param name = "loggerLevel">The level of logging</param>
        /// <param name = "loggerName">The name of the logger</param>
        /// <param name = "message">The Message</param>
        /// <param name = "exception">The Exception</param>
        protected override void Log(LoggerLevel loggerLevel, String loggerName, String message, Exception exception)
        {
            Console.Out.WriteLine("[{0}] '{1}' {2}", loggerLevel, loggerName, message);

            if (exception != null)
            {
                Console.Out.WriteLine("[{0}] '{1}' {2}: {3} {4}", loggerLevel, loggerName, exception.GetType().FullName,
                                      exception.Message, exception.StackTrace);
            }
        }

        /// <summary>
        /// Write to the log.
        /// </summary>
        /// <param name="logText">Text to log</param>
        /// <param name="loggerLevel">Optional.</param>
        public static void Write(string logText, LoggerLevel loggerLevel = LoggerLevel.Debug, string source = "")
        {
            foreach (var logger in Loggers)
            {
                if (!logger.WillHandle(loggerLevel))
                    break;

                logger.Write(logText, loggerLevel, source);
            }
        }