public StoryLogEntry(LogSeverity severity, string text, TimeSpan elapsed)
 {
     this.severity = severity;
     this.text = text;
     this.elapsed = elapsed;
     this.dateTime = DateTime.UtcNow;
 }

        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            StringBuilder fullMessage = new StringBuilder();
            fullMessage.Append(GetCaption(severity));
            fullMessage.Append(": ");
            fullMessage.Append(message);

            if (exceptionData != null)
                fullMessage.Append('\n').Append(exceptionData);

            switch (severity)
            {
                case LogSeverity.Debug:
                    facadeLogger.LogMessage(fullMessage.ToString());
                    break;
                case LogSeverity.Info:
                case LogSeverity.Important:
                case LogSeverity.Warning:
                    facadeLogger.LogMessage(fullMessage.ToString());
                    break;
                case LogSeverity.Error:
                    facadeLogger.LogError(fullMessage.ToString());
                    break;
            }
        }

        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            if (severity < MinLogSeverity || LogMessage == null)
                return;

            Color color = Color.Black;
            switch (severity)
            {
                case LogSeverity.Error:
                    color = Color.Red;
                    break;

                case LogSeverity.Warning:
                    color = Color.Gold;
                    break;

                case LogSeverity.Important:
                    color = Color.Black;
                    break;

                case LogSeverity.Info:
                    color = Color.Gray;
                    break;

                case LogSeverity.Debug:
                    color = Color.DarkGray;
                    break;
            }

            LogMessage(this, new RuntimeLogEventArgs(message, color));

            if (exceptionData != null)
                LogMessage(this, new RuntimeLogEventArgs(exceptionData.ToString(), color));
        }

 public void Log(string message, LogSeverity severity, Exception exception)
 {
     LastMessageSeverity = severity;
     LastMessage = message;
     LastException = exception;
     MessagesReceived++;
 }

        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            if (exceptionData != null)
                message += "\n" + exceptionData;

            switch (severity)
            {
                case LogSeverity.Error:
                    task.Log(Level.Error, message);
                    break;

                case LogSeverity.Warning:
                    task.Log(Level.Warning, message);
                    break;

                case LogSeverity.Important:
                    task.Log(Level.Info, message);
                    break;

                case LogSeverity.Info:
                    task.Log(Level.Verbose, message);
                    break;

                case LogSeverity.Debug:
                    task.Log(Level.Debug, message);
                    break;
            }
        }

 public SpellbookLoggerEventArgs(string message, object source, Exception exception, LogSeverity severity)
 {
     Message = message;
     Source = source;
     Exception = exception;
     Severity = severity;
 }

		/// <summary>
		/// Logs the specified severity.
		/// </summary>
		/// <param name="severity">The severity.</param>
		/// <param name="message">The message.</param>
		public void Log(LogSeverity severity, string message)
		{
			RequiresNotNull(message);
			var con = factory.OpenConnection();
			con.ContinueWith(pt =>
			{
				var connection = pt.Result;
				try
				{
					var cmd = connection.CreateCommand();
					cmd.CommandText = "INSERT INTO Log (Id, Timestamp, Severity, Message) VALUES (NEWID(), @time, @sev, @msg)";

					var timestampParameter = cmd.CreateParameter();
					timestampParameter.ParameterName = "@time";
					timestampParameter.Value = DateTime.Now;
					cmd.Parameters.Add(timestampParameter);

					var severityParameter = cmd.CreateParameter();
					severityParameter.ParameterName = "@sev";
					severityParameter.Value = severity.ToString();
					cmd.Parameters.Add(severityParameter);

					var messageParameter = cmd.CreateParameter();
					messageParameter.ParameterName = "@msg";
					messageParameter.Value = message;
					cmd.Parameters.Add(messageParameter);

					cmd.ExecuteNonQuery();
				}
				finally
				{
					connection.Dispose();
				}
			});
		}

 /// <summary>
 /// Log a message.
 /// </summary>
 /// <param name="severity">Severity.</param>
 /// <param name="message">Message.</param>
 /// <param name="args">Format arguments.</param>
 public static void Log(LogSeverity severity, string message, params string[] args)
 {
     if (OnLog != null)
     {
         OnLog(severity, string.Format(message, args));
     }
 }

        public void Log(LogSeverity severity, string message, params object[] args)
        {
            if (!Environment.UserInteractive) return;
            if ((int)severity < (int)this.minimalSeverity) return;

            var color = Console.ForegroundColor;

            switch (severity)
            {
                case LogSeverity.Debug:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
                    Console.ForegroundColor = color;
                    break;
                case LogSeverity.Info:
                case LogSeverity.Warn:
                    Console.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
                    break;
                case LogSeverity.Error:
                case LogSeverity.Critical:
                default:
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Error.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
                    Console.ForegroundColor = color;
                    break;
            }
        }

 public LogMessageEventArgs(LogSeverity severity, string source, string msg, Exception exception)
 {
     Severity = severity;
     Source = source;
     Message = msg;
     Exception = exception;
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="LogItem"/> struct.
		/// </summary>
		/// <param name="timestamp">The timestamp.</param>
		/// <param name="severity">The severity.</param>
		/// <param name="message">The message.</param>
		public LogItem(DateTimeOffset? timestamp, LogSeverity severity, string message)
		{
			RequiresNotNull(message);
			this.timestamp = timestamp;
			this.severity = severity;
			this.message = message;
		}

 /// <summary>
 /// Constructor of LogEventArgs.
 /// </summary>
 /// <param name="severity">Log severity.</param>
 /// <param name="message">Log message</param>
 /// <param name="exception">Inner exception.</param>
 /// <param name="date">Log date.</param>
 public LogEventArgs(LogSeverity severity, string message, Exception exception, DateTime date)
 {
     Severity = severity;
     Message = message;
     Exception = exception;
     Date = date;
 }

        /// <inheritdoc />
        public void Log(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            if (message == null)
                throw new ArgumentNullException("message");

            LogImpl(severity, message, exceptionData);
        }

        /// <inheritdoc />
        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            switch (severity)
            {
                case LogSeverity.Error:
                    testListener.WriteLine(message, FacadeCategory.Error);
                    break;

                case LogSeverity.Warning:
                    testListener.WriteLine(message, FacadeCategory.Warning);
                    break;

                case LogSeverity.Important:
                case LogSeverity.Info:
                    testListener.WriteLine(message, FacadeCategory.Info);
                    break;

                case LogSeverity.Debug:
                    testListener.WriteLine(message, FacadeCategory.Debug);
                    break;
            }

            if (exceptionData != null)
                testListener.WriteLine(exceptionData.ToString(), FacadeCategory.Error);
        }

 public void Log(string message, LogSeverity logSeverity)
 {
     Console.ForegroundColor = DetermineColor(logSeverity);
     Console.Write(message);
     Console.WriteLine();
     Console.ResetColor();
 }

        /// <summary>
        /// Writes a message into the log given the logger name, the severity and the message.
        /// </summary>
        /// <param name="loggerName">Name of the logger.</param>
        /// <param name="severity">The severity.</param>
        /// <param name="message">The message.</param>
        protected override void InnerWriteLog(string loggerName, LogSeverity severity, string message)
        {
            if (!configured)
            {
                Configure();
            }

            switch (severity)
            {
                case LogSeverity.Debug:
                    logger.Debug(message);
                    break;
                case LogSeverity.Info:
                    logger.Info(message);
                    break;
                case LogSeverity.Warning:
                    logger.Warn(message);
                    break;
                case LogSeverity.Error:
                    logger.Error(message);
                    break;
                case LogSeverity.Fatal:
                    logger.Fatal(message);
                    break;
                default:
                    logger.Debug(message);
                    break;
            }
        }

        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            var warning = exceptionData == null
                   ? message
                   : string.Concat(message, "\n", exceptionData.ToString());

            switch (severity)
            {
                case LogSeverity.Info:
                    _messageLogger.SendMessage(TestMessageLevel.Informational, warning);
                    break;
                case LogSeverity.Warning:
                    _messageLogger.SendMessage(TestMessageLevel.Warning, warning);
                    break;
                case LogSeverity.Debug:
                    _messageLogger.SendMessage(TestMessageLevel.Informational, warning);
                    break;
                case LogSeverity.Important:
                    _messageLogger.SendMessage(TestMessageLevel.Informational, warning);
                    break;
                case LogSeverity.Error:
                    _messageLogger.SendMessage(TestMessageLevel.Error, warning);
                    break;
            }
        }

 /// <summary>
 /// Performs log operation in all registered loggers
 /// </summary>
 /// <param name="severity"></param>
 /// <param name="msg"></param>
 /// <param name="exc"></param>
 public void DoLog(LogSeverity severity, string msg, Exception exc)
 {
     switch (severity)
     {
         case LogSeverity.Info:
             foreach (var logger in _cache.Values)
             {
                 ILogProvider provider = GetCasted(logger);
                 provider.Info(msg);
             }
             break;
         case LogSeverity.Warn:
             foreach (var logger in _cache.Values)
             {
                 ILogProvider provider = GetCasted(logger);
                 provider.Warn(msg, exc);
             }
             break;
         case LogSeverity.Error:
             foreach (var logger in _cache.Values)
             {
                 ILogProvider provider = GetCasted(logger);
                 provider.Error(msg, exc);
             }
             break;
         case LogSeverity.Fatal:
             foreach (var logger in _cache.Values)
             {
                 ILogProvider provider = GetCasted(logger);
                 provider.Fatal(msg, exc);
             }
             break;
     }
 }

 private void Write(LogSeverity logSeverity, string description)
 {
     foreach (var logSource in _logSources)
     {
         logSource.AddItem(logSeverity, description);
     }
 }

        protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
        {
            if (exceptionData != null)
                message += "\n" + exceptionData;

            switch (severity)
            {
                case LogSeverity.Error:
                    taskLoggingHelper.LogError(message);
                    break;

                case LogSeverity.Warning:
                    taskLoggingHelper.LogWarning(message);
                    break;

                case LogSeverity.Important:
                    taskLoggingHelper.LogMessage(MessageImportance.High, message);
                    break;

                case LogSeverity.Info:
                    taskLoggingHelper.LogMessage(MessageImportance.Normal, message);
                    break;

                case LogSeverity.Debug:
                    taskLoggingHelper.LogMessage(MessageImportance.Low, message);
                    break;
            }
        }