/// <summary>
 /// Parses a single line of text to identify any errors or warnings in canonical format.
 /// </summary>
 /// <param name="singleLine">A single line of text for the method to parse.</param><param name="messageImportance">A value of <see cref="T:Microsoft.Build.Framework.MessageImportance"/> that indicates the importance level with which to log the message.</param>
 protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
 {
     if (!string.IsNullOrEmpty(singleLine))
     {
         base.LogEventsFromTextOutput(singleLine, messageImportance);
     }
 }

        protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
        {
            if (singleLine.StartsWith("Successfully created package"))
            {
                var outputPackage = singleLine.Split('\'').Skip(1).First();
                var outputPackageItem = new TaskItem(outputPackage);
                if (outputPackage.EndsWith(".symbols.nupkg", StringComparison.OrdinalIgnoreCase))
                {
                    OutputSymbolsPackage = new[] { outputPackageItem };
                }
                else
                {
                    OutputPackage = new[] { outputPackageItem };
                }
            }

            if (messageImportance == MessageImportance.High)
            {
                Log.LogError(singleLine);
                return;
            }

            if (singleLine.StartsWith("Issue:") || singleLine.StartsWith("Description:") || singleLine.StartsWith("Solution:"))
            {
                Log.LogWarning(singleLine);
                return;
            }

            base.LogEventsFromTextOutput(singleLine, messageImportance);
        }

 /// <summary>
 /// Log a comment
 /// </summary>
 /// <param name="buildEventContext">Event context information which describes who is logging the event</param>
 /// <param name="importance">How important is the message, this will determine which verbosities the message will show up on. 
 /// The higher the importance the lower the verbosity needs to be for the message to be seen</param>
 /// <param name="message">Message to log</param>
 /// <exception cref="InternalErrorException">BuildEventContext is null</exception>
 /// <exception cref="InternalErrorException">Message is null</exception>
 public void LogCommentFromText(BuildEventContext buildEventContext, MessageImportance importance, string message)
 {
     lock (_lockObject)
     {
         this.LogCommentFromText(buildEventContext, importance, message, null);
     }
 }

 /// <summary>
 /// Handle a raised message. 
 /// </summary>
 /// <param name="message">
 /// The message.
 /// </param>
 /// <param name="importance">
 /// The importance.
 /// </param>
 public void HandleMessage(string message, MessageImportance importance = MessageImportance.Normal)
 {
     if (this.OutputMessage(importance))
     {
         NotificationWriter.Write(message);
     }
 }

 protected void LogMessage(string message, MessageImportance importance = MessageImportance.High)
 {
     if (BuildEngine != null)
     {
         BuildEngine.LogMessageEvent(new BuildMessageEventArgs("CrmCross: " + message, "CrmCross", "CrmCross", importance));
     }
 }

 public BuildMessageEventArgs(string message,
     string helpKeyword,
     string senderName,
     MessageImportance importance)
     : base(message, helpKeyword, senderName)
 {
     this.importance = importance;
 }

 private static void LogItemMetadata(Task task, ITaskItem item, MessageImportance importance)
 {
     var metadata = item.CloneCustomMetadata();
     foreach (var name in metadata.Keys.Cast<string>())
     {
         LogMetadata(task, name, (string)metadata[name], importance);
     }
 }

		public TaskCommandLineEventArgs (string commandLine,
						 string taskName,
						 MessageImportance importance)
			: base (commandLine, null, null, importance)
		{
			this.taskName = taskName;
			this.commandLine = commandLine;
		}

        /// <summary>
        /// Initializes a new instance of the OutputEventArgs class.
        /// </summary>
        /// <param name="text">The output text.</param>
        /// <param name="importance">The level of importance for this output event.</param>
        public OutputEventArgs(string text, MessageImportance importance)
        {
            Param.RequireNotNull(text, "text");
            Param.Ignore(importance);

            this.Output = text;
            this.Importance = importance;
        }

        /// <summary>
        /// Parses a single line of text to identify any errors or warnings in canonical format.
        /// </summary>
        /// <param name="singleLine">A single line of text for the method to parse.</param>
        /// <param name="messageImportance">A value of <see cref="T:Microsoft.Build.Framework.MessageImportance"/> that indicates the importance level with which to log the message.</param>
        protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
        {
            bool isError = messageImportance == StandardErrorLoggingImportance;

            if (isError)
                base.LogEventsFromTextOutput(singleLine, messageImportance);
            else
                CommitHash = singleLine.Trim();
        }

        public static void LogInputs(this Task task, MessageImportance importance)
        {
            task.Log.LogMessage(importance, "Inputs:");

            foreach (var propertyInfo in GetInputProperties(task))
            {
                LogProperty(propertyInfo, importance, task);
            }
        }

        private static void LogTaskItems(ITaskItem[] taskItems, string itemGroup, MessageImportance importance, Task task)
        {
            task.Log.LogMessage(importance, "  {0} =", itemGroup);

            foreach (var item in taskItems)
            {
                LogTaskItem(task, item, importance);
            }
        }

        protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
        {
            if ((Set == null || Set.Length == 0) && !String.IsNullOrWhiteSpace(singleLine) && !singleLine.StartsWith("WARNING", StringComparison.OrdinalIgnoreCase))
            {
                Value = singleLine;
            }

            base.LogEventsFromTextOutput(singleLine, messageImportance);
        }

		/// <summary>
		/// Parse the output of the console and gets the Branch or Tag.
		/// </summary>
		/// <param name="singleLine">the line being parsed</param>
		/// <param name="messageImportance">message importance</param>
		protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
		{
			bool isError = messageImportance == StandardErrorLoggingImportance;

			if (isError)
				base.LogEventsFromTextOutput(singleLine, messageImportance);
			else if (IsBranchStatusLine(singleLine))
				Branch = ParseStatusLineOutput(singleLine);
		}

		public ConcurrentLoggingHelper (TaskLoggingHelper taskLog,
						StreamReader messageStream,
						MessageImportance messageImportance)
		{
			this.taskLog = taskLog;
			this.messageStream = messageStream;
			this.messageImportance = messageImportance;
			this.hasLoggedErrors = false;
		}

        protected override void LogEventsFromTextOutput(string singleLine, MessageImportance messageImportance)
        {
            if (CommandVerbosity != CommandVerbosity.Detailed)
            {
                var match = SingleLineNuGetPackageRegex.Match(singleLine);

                if (match.Success)
                {
                    _packages.Add(new TaskItem($"{match.Groups["id"].Value}.{match.Groups["version"].Value}", new Dictionary<string, string>
                    {
                        {"Id", match.Groups["id"].Value},
                        {"Version", match.Groups["version"].Value},
                    }));
                }
            }
            else
            {
                if (_lastTaskItem == null)
                {
                    var match = MultiLineNuGetPackageIdRegex.Match(singleLine);

                    if (match.Success)
                    {
                        _lastTaskItem = new TaskItem(match.Groups["id"].Value, new Dictionary<string, string>
                        {
                            {"Id", match.Groups["id"].Value}
                        });
                    }
                }
                else
                {
                    if (String.Empty.Equals(singleLine))
                    {
                        _packages.Add(_lastTaskItem);

                        _lastTaskItem = null;
                    }
                    else
                    {
                        var match = MultiLineNuGetPackageVersionRegex.Match(singleLine);

                        if (match.Success)
                        {
                            _lastTaskItem.ItemSpec = $"{_lastTaskItem.ItemSpec}.{match.Groups["version"].Value}";
                            _lastTaskItem.SetMetadata("Version", match.Groups["version"].Value);
                        }
                        else
                        {
                            _lastTaskItem.SetMetadata("Description", singleLine.Trim());
                        }
                    }
                }
            }

            base.LogEventsFromTextOutput(singleLine, messageImportance);
        }

        /// <summary>
        /// Logs the specified message.
        /// </summary>
        /// <param name="task">
        /// A task to provide actual logger.
        /// </param>
        /// <param name="message">
        /// Message.
        /// </param>
        /// <param name="messageImportance">
        /// Message importance.
        /// </param>
        public void Log(Task task, string message, MessageImportance messageImportance)
        {
            if (task == null)
                throw new ArgumentNullException("task");

            if (message == null)
                throw new ArgumentNullException("message");

            task.Log.LogMessageFromText(message, messageImportance);
        }

 /// <summary>
 /// Creates an instance of this class for the given task command line.
 /// </summary>
 /// <param name="commandLine">The command line used by a task to launch
 /// its underlying tool/executable.</param>
 /// <param name="taskName">The name of the task raising this event.</param>
 /// <param name="importance">Importance of command line -- controls whether
 /// the command line will be displayed by less verbose loggers.</param>
 public TaskCommandLineEventArgs
 (
     string commandLine,
     string taskName,
     MessageImportance importance
 )
     : this(commandLine, taskName, importance, DateTime.UtcNow)
 {
     // do nothing
 }

 private StringBuilder SelectStringBuilder(MessageImportance messageImportance)
 {
     switch (messageImportance)
     {
         case MessageImportance.High: return this._highImportanceStringBuilder;
         case MessageImportance.Normal: return this._normalImportanceStringBuilder;
         case MessageImportance.Low: return this._lowImportanceStringBuilder;
         default: throw new ArgumentOutOfRangeException("messageImportance");
     }
 }

 /// <summary>
 /// This constuctor allows all event data to be initialized
 /// </summary>
 /// <param name="message">text message</param>
 /// <param name="helpKeyword">help keyword </param>
 /// <param name="senderName">name of event sender</param>
 /// <param name="importance">importance of the message</param>
 public BuildMessageEventArgs
 (
     string message,
     string helpKeyword,
     string senderName,
     MessageImportance importance
 )
     : this(message, helpKeyword, senderName, importance, DateTime.UtcNow)
 {
 }