private void Log(BuildErrorEventArgs eventArgs)
{
if (includeSourceInformation)
Messages.Add($"ERROR: [FILE {eventArgs.File}][LINE {eventArgs.LineNumber}] {eventArgs.Message}");
else
Messages.Add($"ERROR: {eventArgs.Message}");
}
private void Log(BuildErrorEventArgs eventArgs)
{
if (includeSourceInformation)
Messages.Add(String.Format("ERROR: [FILE {0}][LINE {1}] {2}", eventArgs.File, eventArgs.LineNumber, eventArgs.Message));
else
Messages.Add(String.Format("ERROR: {0}", eventArgs.Message));
}
void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
// BuildErrorEventArgs adds LineNumber, ColumnNumber, File, amongst other parameters
BuildError error = new BuildError() {
File = e.File,
Timestamp = e.Timestamp,
LineNumber = e.LineNumber,
ColumnNumber = e.ColumnNumber,
Code = e.Code,
Message = e.Message,
};
Errors.Add(error);
}
/*
* Method: LoggerEventHandler
*
* Receives build events and logs them the way we like.
*
*/
internal void LoggerEventHandler(object sender, BuildEventArgs eventArgs)
{
if (eventArgs is BuildWarningEventArgs)
{
BuildWarningEventArgs w = (BuildWarningEventArgs)eventArgs;
// hack: disregard the MTA warning.
// need the second condition to pass on ploc builds
if (w.Code != "MSB4056" && !w.Message.Contains("MSB4056"))
{
_fullLog.AppendFormat("{0}({1},{2}): {3} warning {4}: {5}\r\n",
w.File,
w.LineNumber,
w.ColumnNumber,
w.Subcategory,
w.Code,
w.Message);
++_warningCount;
_warnings.Add(w);
}
}
else if (eventArgs is BuildErrorEventArgs)
{
BuildErrorEventArgs e = (BuildErrorEventArgs)eventArgs;
_fullLog.AppendFormat("{0}({1},{2}): {3} error {4}: {5}\r\n",
e.File,
e.LineNumber,
e.ColumnNumber,
e.Subcategory,
e.Code,
e.Message);
++_errorCount;
_errors.Add(e);
}
else
{
// Log the message unless we are a build finished event and logBuildFinished is set to false.
bool logMessage = !(eventArgs is BuildFinishedEventArgs) || (eventArgs is BuildFinishedEventArgs && _logBuildFinishedEvent);
if (logMessage)
{
_fullLog.Append(eventArgs.Message);
_fullLog.Append("\r\n");
}
}
if (eventArgs is ExternalProjectStartedEventArgs)
{
this.ExternalProjectStartedEvents.Add((ExternalProjectStartedEventArgs)eventArgs);
}
else if (eventArgs is ExternalProjectFinishedEventArgs)
{
this.ExternalProjectFinishedEvents.Add((ExternalProjectFinishedEventArgs)eventArgs);
}
if (eventArgs is ProjectStartedEventArgs)
{
this.ProjectStartedEvents.Add((ProjectStartedEventArgs)eventArgs);
}
else if (eventArgs is ProjectFinishedEventArgs)
{
this.ProjectFinishedEvents.Add((ProjectFinishedEventArgs)eventArgs);
}
else if (eventArgs is TargetStartedEventArgs)
{
this.TargetStartedEvents.Add((TargetStartedEventArgs)eventArgs);
}
else if (eventArgs is TargetFinishedEventArgs)
{
this.TargetFinishedEvents.Add((TargetFinishedEventArgs)eventArgs);
}
else if (eventArgs is TaskStartedEventArgs)
{
this.TaskStartedEvents.Add((TaskStartedEventArgs)eventArgs);
}
else if (eventArgs is TaskFinishedEventArgs)
{
this.TaskFinishedEvents.Add((TaskFinishedEventArgs)eventArgs);
}
else if (eventArgs is BuildMessageEventArgs)
{
this.BuildMessageEvents.Add((BuildMessageEventArgs)eventArgs);
}
else if (eventArgs is BuildStartedEventArgs)
{
this.BuildStartedEvents.Add((BuildStartedEventArgs)eventArgs);
}
else if (eventArgs is BuildFinishedEventArgs)
{
this.BuildFinishedEvents.Add((BuildFinishedEventArgs)eventArgs);
if (!AllowTaskCrashes)
{
// We should not have any task crashes. Sometimes a test will validate that their expected error
// code appeared, but not realize it then crashed.
AssertLogDoesntContain("MSB4018");
}
// We should not have any Engine crashes.
AssertLogDoesntContain("MSB0001");
// Console.Write in the context of a unit test is very expensive. A hundred
// calls to Console.Write can easily take two seconds on a fast machine. Therefore, only
// do the Console.Write once at the end of the build.
Console.Write(FullLog);
}
}
private void ErrorRaised(object sender, BuildErrorEventArgs e) => _logger.LogError(e.Message);
protected override void ErrorHandler(object sender, BuildErrorEventArgs errorEvent)
{
++_errorCount;
QueueOutputText(GetFormattedErrorMessage(Path.GetFullPath(errorEvent.File),
errorEvent.LineNumber, errorEvent.ColumnNumber, MsgKind.Error, errorEvent.Code, errorEvent.Message));
}
public abstract void ErrorHandler(object sender, BuildErrorEventArgs e);
public void ErrorHandler(object sender, BuildErrorEventArgs args)
{
GetBuildRecord(sender).ErrorHandler(args);
}
void OnError(object sender, BuildErrorEventArgs e)
{
TaskService.BuildMessageViewCategory.AppendLine(e.Message);
}
internal static string FormatEventMessage(BuildErrorEventArgs e)
{
return(FormatEventMessage(e, false));
}
private bool CaptureErrorMessage(BuildErrorEventArgs eventArgs, List<string> messages)
{
messages.Add(eventArgs.Message);
return true;
}
public virtual void LogErrorEvent(BuildErrorEventArgs eventArgs)
{
errors.Add(eventArgs);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
Console.WriteLine(e.Message);
}
public virtual string FormatErrorEvent(BuildErrorEventArgs args)
{
return(EventArgsFormatting.FormatEventMessage(args));
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
Log(e.Message);
}
private void ErrorRaised(object sender, BuildErrorEventArgs e)
{
this.errors++;
this.LogErrorOrWarning("error", e.Message, e.Code, e.File, e.LineNumber, e.ColumnNumber, e.Subcategory);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
LogErrorEvents.Add(e);
}
internal static string FormatEventMessage(BuildErrorEventArgs e, bool removeCarriageReturn, bool showProjectFile)
{
ErrorUtilities.VerifyThrowArgumentNull(e, "e");
return(FormatEventMessage("error", e.Subcategory, removeCarriageReturn ? EscapeCarriageReturn(e.Message) : e.Message, e.Code, e.File, showProjectFile ? e.ProjectFile : null, e.LineNumber, e.EndLineNumber, e.ColumnNumber, e.EndColumnNumber, e.ThreadId));
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
Codes.Add(e.Code);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
this.ConsoleLogger.LogError(e.Message);
}
void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
Debug.LogErrorFormat("{0}: ERROR {1}({2},{3}): {4}", e.SenderName, e.File, e.LineNumber, e.ColumnNumber, e.Message);
}
/// <summary>
/// Prints an error event
/// </summary>
public void ErrorHandler(object sender, BuildErrorEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.ErrorHandler(sender, e);
}
private void RecurseVSIX(DirectoryInfo directory, Package zipPackage, string rootPath, bool skipZips = true, bool zipSubDirectories = true)
{
var subZips = new List <string>();
if (zipSubDirectories)
{
foreach (var subDirectory in directory.GetDirectories())
{
var fileInfo = new FileInfo(Path.Combine(subDirectory.FullName, subDirectory.Name + ".zip"));
subZips.Add(fileInfo.FullName);
using (var stream = fileInfo.Open(FileMode.Create, FileAccess.ReadWrite))
{
using (var zipStream = new ZipOutputStream(stream))
{
zipStream.UseZip64 = UseZip64.Off;
RecurseVSIX(subDirectory, zipStream, subDirectory.FullName);
}
}
foreach (var file in subDirectory.GetFiles("*.zip"))
{
if (subZips.Contains(file.FullName))
{
var name = file.FullName.Remove(0, rootPath.Length).Replace("\\", "/");
var part = zipPackage.CreatePart(new Uri(name, UriKind.Relative), "application/zip", CompressionOption.Normal);
var outputStream = part.GetStream();
using (var inputStream = File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write))
{
byte[] buffer = new byte[2048];
int length;
while ((length = inputStream.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, length);
}
}
}
}
}
}
else
{
foreach (var subDirectory in directory.GetDirectories())
{
RecurseVSIX(subDirectory, zipPackage, subDirectory.FullName, skipZips, false);
}
}
foreach (var file in directory.GetFiles())
{
if ((file.Extension.ToLower() != ".zip" || !skipZips || subZips.Contains(file.FullName)) && file.Extension.ToLower() != ".vsix" && file.Name.AsCaseless() != "[Content_Types].xml")
{
var mimeType = string.Empty;
if (file.Extension.IsOneOf(".jpg", ".ico", ".png", ".bmp", ".gif", ".dll", ".exe", ".pdb"))
{
mimeType = "application/octet-stream";
}
else if (file.Extension.IsOneOf(".xml", ".vsixmanifest", ".vsix", ".vstemplate", ".rtf", ".htm", ".config"))
{
mimeType = "text/xml";
}
else if (file.Extension == ".zip")
{
mimeType = "application/zip";
}
else
{
var message = new BuildErrorEventArgs(string.Empty, string.Empty, string.Empty, 0, 0, 0, 0, string.Format("Unexpected package file extension for '{0}'", file.Name), "", "", DateTime.Now);
this.BuildEngine.LogErrorEvent(message);
continue;
}
var name = file.FullName.Remove(0, rootPath.Length).Replace("\\", "/");
var part = zipPackage.CreatePart(new Uri(name, UriKind.Relative), mimeType, CompressionOption.Normal);
var outputStream = part.GetStream();
using (var inputStream = File.Open(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Write))
{
byte[] buffer = new byte[2048];
int length;
while ((length = inputStream.Read(buffer, 0, buffer.Length)) > 0)
{
outputStream.Write(buffer, 0, length);
}
}
}
}
}
/// <summary>
/// Stub implementation -- forwards to engine being proxied.
/// </summary>
public void LogErrorEvent(BuildErrorEventArgs e)
{
ErrorUtilities.VerifyThrowArgumentNull(e, nameof(e));
ErrorUtilities.VerifyThrowInvalidOperation(activeProxy, "AttemptingToLogFromInactiveTask");
if (parentModule.IsRunningMultipleNodes && !e.GetType().IsSerializable)
{
loggingServices.LogWarning(buildEventContext, new BuildEventFileInfo(string.Empty), "ExpectedEventToBeSerializable", e.GetType().Name);
return;
}
string message = GetUpdatedMessage(e.File, e.Message, parentProjectFullFileName);
if (ContinueOnError)
{
// Convert the error into a warning. We do this because the whole point of
// ContinueOnError is that a project author expects that the task might fail,
// but wants to ignore the failures. This implies that we shouldn't be logging
// errors either, because you should never have a successful build with errors.
BuildWarningEventArgs warningEvent = new BuildWarningEventArgs
(e.Subcategory,
e.Code,
e.File,
e.LineNumber,
e.ColumnNumber,
e.EndLineNumber,
e.EndColumnNumber,
message, // this is the new message from above
e.HelpKeyword,
e.SenderName);
warningEvent.BuildEventContext = buildEventContext;
loggingServices.LogWarningEvent(warningEvent);
// Log a message explaining why we converted the previous error into a warning.
loggingServices.LogComment(buildEventContext, MessageImportance.Normal, "ErrorConvertedIntoWarning");
}
else
{
if (e.GetType().Equals(BuildErrorEventArgsType))
{
// We'd like to add the project file to the subcategory, but since this property
// is read-only on the BuildErrorEventArgs type, this requires creating a new
// instance. However, if some task logged a custom error type, we don't want to
// impolitely (as we already do above on ContinueOnError) throw the custom type
// data away.
e = new BuildErrorEventArgs
(
e.Subcategory,
e.Code,
e.File,
e.LineNumber,
e.ColumnNumber,
e.EndLineNumber,
e.EndColumnNumber,
message, // this is the new message from above
e.HelpKeyword,
e.SenderName
);
}
e.BuildEventContext = buildEventContext;
loggingServices.LogErrorEvent(e);
}
}
private void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
Trace.WriteLine(@"Error: " + e.Message);
}
private void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
LogErrorOrWarning(XmlLoggerElements.Error, e.Message, e.Code, e.File, e.LineNumber, e.ColumnNumber, e.Timestamp);
}
private void EventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
try
{
if (e.BuildEventContext == null)
{
return;
}
Log.Debug("Error Raised");
int context = e.BuildEventContext.ProjectContextId;
if (_projects.TryGetValue(context, out Span projectSpan))
{
string correlation = $"[{CorrelationIdentifier.TraceIdKey}={projectSpan.TraceId},{CorrelationIdentifier.SpanIdKey}={projectSpan.SpanId}]";
string message = e.Message;
string type = $"{e.SenderName?.ToUpperInvariant()} ({e.Code}) Error";
string code = e.Code;
int? lineNumber = e.LineNumber > 0 ? (int?)e.LineNumber : null;
int? columnNumber = e.ColumnNumber > 0 ? (int?)e.ColumnNumber : null;
int? endLineNumber = e.EndLineNumber > 0 ? (int?)e.EndLineNumber : null;
int? endColumnNumber = e.EndColumnNumber > 0 ? (int?)e.EndColumnNumber : null;
string projectFile = e.ProjectFile;
string filePath = null;
string stack = null;
string subCategory = e.Subcategory;
projectSpan.Status = SpanStatus.Error;
projectSpan.SetTag(BuildTags.ErrorMessage, message);
projectSpan.SetTag(BuildTags.ErrorType, type);
projectSpan.SetTag(BuildTags.ErrorCode, code);
projectSpan.SetTag(BuildTags.ErrorStartLine, lineNumber.ToString());
projectSpan.SetTag(BuildTags.ErrorStartColumn, columnNumber.ToString());
projectSpan.SetTag(BuildTags.ErrorProjectFile, projectFile);
if (!string.IsNullOrEmpty(e.File))
{
filePath = Path.Combine(Path.GetDirectoryName(projectFile), e.File);
projectSpan.SetTag(BuildTags.ErrorFile, filePath);
if (lineNumber.HasValue && lineNumber != 0)
{
stack = $" at Source code in {filePath}:line {e.LineNumber}";
projectSpan.SetTag(BuildTags.ErrorStack, stack);
}
}
if (!string.IsNullOrEmpty(subCategory))
{
projectSpan.SetTag(BuildTags.ErrorSubCategory, subCategory);
}
if (endLineNumber.HasValue && endLineNumber != 0)
{
projectSpan.SetTag(BuildTags.ErrorEndLine, endLineNumber.ToString());
}
if (endColumnNumber.HasValue && endColumnNumber != 0)
{
projectSpan.SetTag(BuildTags.ErrorEndColumn, endColumnNumber.ToString());
}
LogItem logItem = new LogItem("error", message, type, code, lineNumber, columnNumber, endLineNumber, endColumnNumber, projectFile, filePath, stack, subCategory);
string logMessage = correlation + JsonConvert.SerializeObject(logItem);
Console.WriteLine(logMessage);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error in ErrorRaised event");
}
}
public void LogErrorEvent(BuildErrorEventArgs e) => _errors.AppendLine(e.Message);
public void LogErrorEvent(BuildErrorEventArgs e)
{
BuildErrorEventArgs.Add(e);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
Logger.ErrorEvents.Add(e);
}
/// <summary>
/// Format the error event message and all the other event data into
/// a single string.
/// </summary>
/// <param name="e">Error to format</param>
/// <param name="showProjectFile"><code>true</code> to show the project file which issued the event, otherwise <code>false</code>.</param>
/// <param name="projectConfigurationDescription">Properties to Print along with message</param>
/// <returns>The formatted message string.</returns>
internal static string FormatEventMessage(BuildErrorEventArgs e, bool showProjectFile, string projectConfigurationDescription)
{
return(FormatEventMessage("error", e.Subcategory, e.Message,
e.Code, e.File, showProjectFile ? e.ProjectFile : null, e.LineNumber, e.EndLineNumber,
e.ColumnNumber, e.EndColumnNumber, e.ThreadId, projectConfigurationDescription));
}
private void BuildError(object sender, BuildErrorEventArgs e)
{
SendMessage(FormatMessage(e));
}
/// <summary>
/// Handles error notification events by storing the error message string.
/// </summary>
void ErrorRaised(object sender, BuildErrorEventArgs e)
{
errors.Add(e.Message);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
LogErrorEvents.Add(e);
Console.WriteLine(e.Message);
}
void OnError(object sender, BuildErrorEventArgs e)
{
AppendError(e.File, e.LineNumber, e.ColumnNumber, e.Code, e.Message, false);
}
private void Log(BuildErrorEventArgs eventArgs)
{
Messages.Add(String.Format("ERROR: {0}", eventArgs.Message));
}
void eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
LogErrorOrWarning(XmlLoggerElements.Error, e.Message, e.Code, e.File, e.LineNumber, e.ColumnNumber, e.Timestamp);
}
private void _eventSource_ErrorRaised(object sender, BuildErrorEventArgs e)
{
//_messages.Add($"{e.Timestamp.ToString("dd/MM/yyyy hh:mm:ss")}, {e.Message}");
_messages.Add(e.Message);
}
public void LogErrorEvent(BuildErrorEventArgs e)
{
}
void ErrorRaised(object sender, BuildErrorEventArgs e)
{
writer.AppendLine(GetLogMessage("ErrorRaised", e));
}
