public void Log(MessageLevel level, string message, params object[] args)
        {
            var calleeType = new StackTrace().GetFrame(1).GetMethod().DeclaringType ?? GetType();

            var logger = LogManager.GetLogger(calleeType);

            Action<Action<FormatMessageHandler>> logMethod;

            switch (level)
            {
                case MessageLevel.Debug:
                    logMethod = logger.Debug;
                    break;
                case MessageLevel.Info:
                    logMethod = logger.Info;
                    break;
                case MessageLevel.Error:
                    logMethod = logger.Error;
                    break;
                case MessageLevel.Warning:
                default:
                    logMethod = logger.Warn;
                    break;
            }

            logMethod(m => m(message, args));
        }

        public void Log(MessageLevel level, string message, params object[] args)
        {
            if (args.Length > 0)
            {
                message = string.Format(CultureInfo.CurrentCulture, message, args);
            }

            switch (level)
            {
                case MessageLevel.Debug:
                    _logger.LogDebug(message);
                    break;

                case MessageLevel.Info:
                    _logger.LogMinimal(message);
                    break;

                case MessageLevel.Warning:
                    _logger.LogWarning(message);
                    break;

                case MessageLevel.Error:
                    _logger.LogError(message);
                    break;
            }
        }

 public LogMessageAttributes(Stream stream)
 {
     Classification = (MessageClass)stream.ReadByte();
     Level = (MessageLevel)stream.ReadByte();
     MessageSuppression = (MessageSuppression)stream.ReadByte();
     Flags = (MessageFlags)stream.ReadByte();
 }

 public void SetNewMessage(MessageLevel Level,string Message,string CodeIndex)
 {
     MessageItem newItem = new MessageItem();
     newItem.CodeIndex = CodeIndex;
     newItem.Message = Message;
     newItem.SelectedMessageLevel = Level;
 }

 public Message(MessageLevel level, int code, string phrase, params string[] phraseTokens)
 {
     Level = level;
     Code = code;
     Phrase = phrase;
     Tokens = phraseTokens;
 }

        public void Write(MessageLevel level, Exception ex)
        {
            if (this.MessageReceived == null) return;

            MessageEventArgs msgArgs = new MessageEventArgs(level, ex.GetAllMessage());
            this.MessageReceived(null, msgArgs);
        }

		public static void SendMessage(this StreamWriter writer, ReportType type, MessageLevel level, string message)
		{
			var encodedMessage = Convert.ToBase64String(Encoding.UTF8.GetBytes(message));
			var report = "{0}|{1}|{2}".FormatWith(type, level, encodedMessage);
			writer.WriteLine(report);
			writer.Flush();
		}

        public Task ShowMessage(string message, string title, MessageLevel level)
        {
            //TODO:Need to implement tooltip and message logging in case for none
              return Task.Factory.StartNew(() =>
              {
            switch (this._messageTarget)
            {
              case MessageTarget.MessageBox:
            if (this.InvokeRequired)
            {
              this.Invoke(new Action(() =>
              {
                MessageBox.Show(message, title, MessageBoxButtons.OK, FrmMain.GetIcon(level));
              }));
            }
            else
              MessageBox.Show(message, title, MessageBoxButtons.OK, FrmMain.GetIcon(level));
            break;
              case MessageTarget.ToolTip:
            break;
              case MessageTarget.None:
            break;
              default:
            break;
            }

              });
        }

 public void Log(string message, MessageLevel messageLevel)
 {
     if(EventLog != null)
     {
         EventLog(message, messageLevel);
     }
 }

        /// <summary>
        /// Creates a new generc message event arg.
        /// </summary>
        /// <param name="sourceLineNumbers">Source line numbers for the message.</param>
        /// <param name="id">Id for the message.</param>
        /// <param name="level">Level for the message.</param>
        /// <param name="format">Format message for arguments.</param>
        /// <param name="messageArgs">Arguments for the format string.</param>
        public WixGenericMessageEventArgs(SourceLineNumberCollection sourceLineNumbers, int id, MessageLevel level, string format, params object[] messageArgs)
            : base(sourceLineNumbers, id, format, messageArgs)
        {
            this.resourceManager = new GenericResourceManager();

            this.Level = level;
        }

		public PackageOperationMessageLoggedEventArgs(
			MessageLevel level,
			string message,
			params object[] args)
		{
			this.Message = new PackageOperationMessage(level, message, args);
		}

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="message"><c>String</c> that specifies the name of the <c>LogMessage</c>.</param>
 /// <param name="level"><c>MessageLevel</c> that specifies the level of the <c>LogMessage</c>.</param>
 /// <returns><c>LogMessage</c> object</returns>
 public LogMessage(
     String message,
     MessageLevel level)
 {
     this.Message = message;
     this.Level = level;
 }

 private void SendMessage(ReportType type, MessageLevel level, string message)
 {
     var encodedMessage = Convert.ToBase64String(Encoding.UTF8.GetBytes(message));
     var report = "{0}|{1}|{2}".FormatWith(type, level, encodedMessage);
     _output.WriteLine(report);
     _output.Flush();
 }

 public void OnPackageOperationMessageLogged(MessageLevel level, string message, params object[] args)
 {
     if (PackageOperationMessageLogged != null) {
         var eventArgs = new PackageOperationMessageLoggedEventArgs(level, message, args);
         PackageOperationMessageLogged(this, eventArgs);
     }
 }

        public IObservable<bool> Post(string url, string message, MessageLevel level = MessageLevel.Info)
        {
            // Create an HttpClient and send content payload
            using (var httpClient = HttpClient)
            {
            #if __IOS__ || __ANDROID__ || NET45
                var content = new FormUrlEncodedContent(new Dictionary<string, string>
                {
                    {"message", message},
                    {"level", level.ToString().ToLower()}
                });
            #endif
            #if NETFX_CORE
                var content = new HttpFormUrlEncodedContent(new Dictionary<string, string>
                {
                    {"message", message},
                    {"level", level.ToString().ToLower()}
                });
            #endif

            #if __IOS__ || __ANDROID__ || NET45
                return httpClient.PostAsync(new Uri(url), content)
                    .ToObservable()
                    .Select(response => response.IsSuccessStatusCode);
            #endif
            #if NETFX_CORE
                return httpClient.PostAsync(new Uri(url), content)
                    .AsTask()
                    .ToObservable()
                    .Select(response => response.IsSuccessStatusCode);
            #endif
            }
        }

        /// <summary>
        /// Last chance logging if primary logging sink fails.  Usually used on application boot strapping.  Log file will be located in
        /// either the file location of Log.LastChangeLogFile or in the default folder of the running application.  NOTE:  Bypasses
        /// any configured log provider (log4Net, NLog, TraceLog, etc) and writes directly to text file.  Use with extreme care and is
        /// not configured for high performance.
        /// </summary>
        /// <param name="logLevel">Level this message will be logged at</param>
        /// <param name="message">Text of message</param>
        /// <param name="args">Arguments to supply to message text (if any)</param>
        public static void LastChanceLog(MessageLevel logLevel, string message, params object[] args)
        {
            string logMessage = "";
            try
            {
                _lastChanceLock.EnterWriteLock();

                if (CoreConfig.Log.IsLastChanceLogEnabled == false) return; // last chance logging not enabled

                logMessage = TextUtils.StringFormat("{0:yyyy-MM-dd HH:mm:ss.fff} {1} {2}", DateTime.Now, logLevel.ToString().ToUpper(), TextUtils.StringFormat(message, args));

                File.AppendAllText(CoreConfig.Log.LastChanceLogFile, logMessage + Environment.NewLine);
            }
            catch (Exception ex)
            {
                try // write to event log if unable to log to last chance file.  This is really the last chance of the last chance!
                {
                    EventLog.WriteEntry("Application Error", string.Format(logMessage, args), EventLogEntryType.Error);
                    EventLog.WriteEntry("Application Error", string.Format(ex.ToString()), EventLogEntryType.Error);
                }
                catch (Exception ex2) //couldn't write log to last chance log file or event viewer so swallow exception
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("Error in LastChanceLog: {0}{1}{2}", ex2.Message, Environment.NewLine, logMessage));
                }
            }
            finally
            {
                _lastChanceLock.ExitWriteLock();
            }
        }

 public Error(MessageLevel category, string message, int code, Node node)
     : this()
 {
     Node = node;
     Message = message;
     Code = code;
     Category = category;
 }

        public void AddMessage(MessageLevel level, string text, params object[] args)
        {
            var formattedText = args.Length > 0 ?
                string.Format(text, args) :
                text;

            _callback.Invoke(new Message(formattedText, level));
        }

        private void SendMessage(ReportType type, MessageLevel level, string message)
        {
            var encodedMessage = Convert.ToBase64String(Encoding.UTF8.GetBytes(message));
            var report = $"{type}|{level}|{encodedMessage}";
            _output.WriteLine(report);
            _output.Flush();

        }

 private StatusReport(string text, MessageLevel level, OperationType type, ReportType reportType)
 {
     Message = text;
     MessageLevel = level;
     OperationType = type;
     MessageTime = DateTime.Now;
     ReportType = reportType;
 }