private bool VerifyLoggerBuildEvent(BuildOutputLogger loggerSender, BuildEventArgs eventArgs, ErrorLevel errorLevel)
{
var bec = eventArgs.BuildEventContext;
bool becIsInvalid = (bec == null ||
bec == BuildEventContext.Invalid ||
bec.ProjectContextId == BuildEventContext.InvalidProjectContextId ||
bec.ProjectInstanceId == BuildEventContext.InvalidProjectInstanceId);
if (becIsInvalid)
{
return(false);
}
if (errorLevel == ErrorLevel.Message)
{
var messageEventArgs = (BuildMessageEventArgs)eventArgs;
bool isUserMessage = (messageEventArgs.Importance == MessageImportance.High && loggerSender.IsVerbosityAtLeast(LoggerVerbosity.Minimal)) ||
(messageEventArgs.Importance == MessageImportance.Normal && loggerSender.IsVerbosityAtLeast(LoggerVerbosity.Normal)) ||
(messageEventArgs.Importance == MessageImportance.Low && loggerSender.IsVerbosityAtLeast(LoggerVerbosity.Detailed));
if (!isUserMessage)
{
return(false);
}
}
return(true);
}
public static RegisterLoggerResult Register(Guid loggerId, LoggerVerbosity loggerVerbosity, out BuildOutputLogger buildLogger)
{
try
{
const BindingFlags InterfacePropertyFlags = BindingFlags.GetProperty
| BindingFlags.Public
| BindingFlags.Instance;
BuildManager buildManager = BuildManager.DefaultBuildManager;
Type buildHostType = buildManager.GetType().Assembly.GetType("Microsoft.Build.BackEnd.IBuildComponentHost");
PropertyInfo loggingSeviceProperty = buildHostType.GetProperty("LoggingService", InterfacePropertyFlags);
object loggingServiceObj;
try
{
// Microsoft.Build.BackEnd.ILoggingService
loggingServiceObj = loggingSeviceProperty.GetValue(buildManager, null);
}
catch (TargetInvocationException ex)
{
ex.Trace("Microsoft.Build.BackEnd.ILoggingService is not available.");
buildLogger = null;
return(RegisterLoggerResult.FatalError);
}
PropertyInfo loggersProperty = loggingServiceObj.GetType().GetProperty("Loggers", InterfacePropertyFlags);
ICollection <ILogger> loggers = (ICollection <ILogger>)loggersProperty.GetValue(loggingServiceObj, null);
ILogger logger = loggers.FirstOrDefault(x => x is BuildOutputLogger && ((BuildOutputLogger)x)._id.Equals(loggerId));
if (logger != null)
{
buildLogger = (BuildOutputLogger)logger;
buildLogger.Verbosity = loggerVerbosity;
return(RegisterLoggerResult.AlreadyExists);
}
MethodInfo registerLoggerMethod = loggingServiceObj.GetType().GetMethod("RegisterLogger");
buildLogger = new BuildOutputLogger(loggerId)
{
Verbosity = loggerVerbosity
};
bool registerResult = (bool)registerLoggerMethod.Invoke(loggingServiceObj, new object[] { buildLogger });
return(registerResult ? RegisterLoggerResult.RegisterSuccess : RegisterLoggerResult.RegisterFailed);
}
catch (Exception ex)
{
ex.TraceUnknownException();
buildLogger = null;
return(RegisterLoggerResult.FatalError);
}
}
private void RegisterLogger()
{
_buildLogger = null;
// Same Verbosity as in the Error List.
const LoggerVerbosity LoggerVerbosity = LoggerVerbosity.Quiet;
RegisterLoggerResult result = BuildOutputLogger.Register(_parsingErrorsLoggerId, LoggerVerbosity, out _buildLogger);
if (result == RegisterLoggerResult.RegisterSuccess)
{
var eventSource = _buildLogger.EventSource;
eventSource.MessageRaised += (s, e) => EventSource_ErrorRaised(_buildLogger, e, ErrorLevel.Message);
eventSource.WarningRaised += (s, e) => EventSource_ErrorRaised(_buildLogger, e, ErrorLevel.Warning);
eventSource.ErrorRaised += (s, e) => EventSource_ErrorRaised(_buildLogger, e, ErrorLevel.Error);
}
else if (result == RegisterLoggerResult.AlreadyExists)
{
_buildLogger.Projects?.Clear();
}
}
private void EventSource_ErrorRaised(BuildOutputLogger loggerSender, LazyFormattedBuildEventArgs e, ErrorLevel errorLevel)
{
try
{
bool verified = VerifyLoggerBuildEvent(loggerSender, e, errorLevel);
if (!verified)
{
return;
}
int projectInstanceId = e.BuildEventContext.ProjectInstanceId;
int projectContextId = e.BuildEventContext.ProjectContextId;
var projectEntry = loggerSender.Projects.Find(t => t.InstanceId == projectInstanceId && t.ContextId == projectContextId);
if (projectEntry == null)
{
TraceManager.Trace(string.Format("Project entry not found by ProjectInstanceId='{0}' and ProjectContextId='{1}'.", projectInstanceId, projectContextId), EventLogEntryType.Warning);
return;
}
if (projectEntry.IsInvalid)
{
return;
}
if (!GetProjectItem(projectEntry, out var projectItem))
{
projectEntry.IsInvalid = true;
return;
}
BuildedProject buildedProject = BuildedProjects[projectItem];
var errorItem = new ErrorItem(errorLevel, (eI) =>
{
_packageContext.GetDTE().Solution.GetProject(x => x.UniqueName == projectItem.UniqueName).NavigateToErrorItem(eI);
});
switch (errorLevel)
{
case ErrorLevel.Message:
Init(errorItem, (BuildMessageEventArgs)e);
break;
case ErrorLevel.Warning:
Init(errorItem, (BuildWarningEventArgs)e);
break;
case ErrorLevel.Error:
Init(errorItem, (BuildErrorEventArgs)e);
break;
default:
throw new ArgumentOutOfRangeException("errorLevel");
}
errorItem.VerifyValues();
buildedProject.ErrorsBox.Add(errorItem);
OnErrorRaised(this, new BuildErrorRaisedEventArgs(errorLevel, buildedProject));
}
catch (Exception ex)
{
ex.TraceUnknownException();
}
}
