public static void Log(this ILogger logger, LoggingEventType eventType, Exception exception, string message, params object[] formatArgs) { if (logger.IsLogEventEnabled(eventType)) { logger.Log(new LogEntry(eventType, string.Format(message, formatArgs), exception)); } }
public void Log_WithValidArguments_Succeeds() { // Arrange LoggingEventType validSeverity = LoggingEventType.Critical; string validMessage = "Valid message"; MethodBase validSource = MethodBase.GetCurrentMethod(); // Act Logger.Log(validSeverity, validMessage, validSource); }
/// <summary>Logs an event to the wrapped <see cref="Logger"/>.</summary> /// <param name="logger">The logger.</param> /// <param name="severity">The severity of the event.</param> /// <param name="message">The description of the event.</param> /// <param name="source">A source where the event occurred.</param> /// <returns>The id of the logged event or null in one of the following reasons: /// The event hasn't been logged, because of the current /// <see cref="LoggingProviderBase.Threshold">Threshold</see> level; /// Returning an id is not supported by the current implementation; /// The event has been logged to a fallback provider, because of an error in the current implementation. /// </returns> /// <exception cref="ArgumentException">Thrown when the supplied <paramref name="message"/> or /// <paramref name="source"/> are empty strings.</exception> /// <exception cref="ArgumentNullException"> /// Thrown when the supplied <paramref name="message"/>, <paramref name="source"/> or /// <paramref name="logger"/> are null references (Nothing in VB).</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when the supplied <paramref name="severity"/> /// has an unexpected value.</exception> /// <exception cref="Exception">Thrown when the logging provider failed to log the event. The /// exact type of exception thrown depends on the actual provider implementation. See documentation /// of the <see cref="LoggingProviderBase.LogInternal">LogInternal</see> method of the used logging /// provider for more information.</exception> public static object Log(this ILogger logger, LoggingEventType severity, string message, string source) { LoggingHelper.ValideLoggerIsNotNull(logger); LoggingHelper.ValidateSeverityInValidRange(severity); LoggingHelper.ValidateSourceNotNullOrEmpty(source); LogEntry entry = new LogEntry(severity, message, source, null); return(logger.Log(entry)); }
public void Log_WithInvalidSeverity_ThrowsException() { // Arrange LoggingEventType invalidSeverity = (LoggingEventType)6; string validMessage = "Valid message"; MethodBase validSource = MethodBase.GetCurrentMethod(); // Act Logger.Log(invalidSeverity, validMessage, validSource); }
public void Log_WithEmptyMessage_ThrowsException() { // Arrange LoggingEventType validSeverity = LoggingEventType.Critical; string invalidMessage = string.Empty; MethodBase validSource = MethodBase.GetCurrentMethod(); // Act Logger.Log(validSeverity, invalidMessage, validSource); }
public void Log_WithValidArguments_Succeeds() { // Arrange LoggingEventType validSeverity = LoggingEventType.Critical; string validMessage = "Valid message"; string validSource = "Valid source"; // Act Logger.Log(validSeverity, validMessage, validSource); }
public void Log_WithInvalidSeverity_ThrowsException() { // Arrange LoggingEventType invalidSeverity = (LoggingEventType)6; string validMessage = "Valid message"; string validSource = "Valid source"; // Act Logger.Log(invalidSeverity, validMessage, validSource); }
public void Log_WithNullMessage_ThrowsException() { // Arrange LoggingEventType validSeverity = LoggingEventType.Critical; string invalidMessage = null; string validSource = "Valid source"; // Act Logger.Log(validSeverity, invalidMessage, validSource); }
/// <summary> /// Adds an entry to the log. /// </summary> /// <param name="severity">The type of event to log.</param> /// <param name="message">The message to log.</param> /// <param name="exception">The exception (optional).</param> public LogEntry(LoggingEventType severity, string message, Exception exception = null) { if (message == null) { throw new ArgumentNullException("message"); } Severity = severity; Message = message; Exception = exception; }
/// <summary> /// Writes the message. /// </summary> /// <param name="logLevel">The log level.</param> /// <param name="message">The message function.</param> /// <param name="exception">The exception.</param> private static void WriteMessageConsole( LoggingEventType logLevel, string message, Exception exception) { if (exception != null) { message = message + "|" + exception; } Console.WriteLine("{0} | {1} | {2}", DateTime.UtcNow, logLevel, message); }
public LogEntry(LoggingEventType severity, string message, Exception exception = null) { if (string.IsNullOrEmpty(message)) { throw new ArgumentNullException("message"); } this.Severity = severity; this.Message = message; this.Exception = exception; }
public MailLoggingProvider(LoggingEventType threshold, string subjectFormatString, LoggingProviderBase fallbackProvider, params MailAddress[] recipients) : base(threshold, fallbackProvider) { this.To = BuildAddressList(recipients); this.ValidateSubjectFormatString(subjectFormatString, InitializationModel.CodeOnly); this.SetSubjectFormatString(subjectFormatString); this.ValidateDotNetMailConfiguration(); }
public static ILogger Create(string queueName, LoggingEventType logLevel, string initText) { if (!Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\Logs\\")) { Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "\\Logs\\"); } return (new TextFileLogProvider( AppDomain.CurrentDomain.BaseDirectory + $"\\Logs\\{queueName}.txt", logLevel, initText)); }
internal static LogLevel ToNLogSeverity(this LoggingEventType severity) { return(severity switch { LoggingEventType.Debug => LogLevel.Debug, LoggingEventType.Information => LogLevel.Info, LoggingEventType.Warning => LogLevel.Warn, LoggingEventType.Error => LogLevel.Error, LoggingEventType.Fatal => LogLevel.Fatal, _ => throw new ArgumentOutOfRangeException(nameof(severity), severity, null) });
public LogEntry(LoggingEventType loggingEventType, string message, Exception exception = null) { if (String.IsNullOrEmpty(message)) { // ReSharper disable once NotResolvedInText throw new ArgumentNullException("Log message is null or empty"); } LoggingEventType = loggingEventType; Message = message; Exception = exception; }
private static LogEventLevel MapLogEventLevel(LoggingEventType type) { return(type switch { LoggingEventType.Verbose => LogEventLevel.Verbose, LoggingEventType.Debug => LogEventLevel.Debug, LoggingEventType.Information => LogEventLevel.Information, LoggingEventType.Warning => LogEventLevel.Warning, LoggingEventType.Error => LogEventLevel.Error, LoggingEventType.Fatal => LogEventLevel.Fatal, _ => throw new ArgumentOutOfRangeException(nameof(type), type, null), });
NLog.LogLevel GetNLogLevel(LoggingEventType level) { switch (level) { case LoggingEventType.Debug: return NLog.LogLevel.Debug; case LoggingEventType.Information: return NLog.LogLevel.Info; case LoggingEventType.Warning: return NLog.LogLevel.Warn; case LoggingEventType.Error: return NLog.LogLevel.Error; case LoggingEventType.Fatal: return NLog.LogLevel.Fatal; default: return NLog.LogLevel.Trace; } }
private static LogEntry CreateLogEntry(WebBaseEvent eventRaised) { LoggingEventType eventType = GetEventTypeFromWebEvent(eventRaised); string message = string.Format(CultureInfo.InvariantCulture, "{0} (Event Code: {1})", eventRaised.Message, eventRaised.EventCode); string source = eventRaised.GetType().Name; Exception exception = GetExceptionFromWebEvent(eventRaised); return(new LogEntry(eventType, message, source, exception)); }
/// <summary>Logs an event to the wrapped <see cref="Logger"/>.</summary> /// <param name="logger">The logger.</param> /// <param name="severity">The severity of the event.</param> /// <param name="message">The description of the event.</param> /// <param name="source">A source where the event occurred.</param> /// <returns>The id of the logged event or null in one of the following reasons: /// The event hasn't been logged, because of the current /// <see cref="LoggingProviderBase.Threshold">Threshold</see> level; /// Returning an id is not supported by the current implementation; /// The event has been logged to a fallback provider, because of an error in the current implementation. /// </returns> /// <exception cref="ArgumentException">Thrown when the supplied <paramref name="message"/> is /// an empty string.</exception> /// <exception cref="ArgumentNullException"> /// Thrown when the supplied <paramref name="message"/>, <paramref name="source"/> or /// <paramref name="logger"/> are null references (Nothing in VB).</exception> /// <exception cref="InvalidEnumArgumentException">Thrown when the supplied <paramref name="severity"/> /// has an unexpected value.</exception> /// <exception cref="Exception">Thrown when the logging provider failed to log the event. The /// exact type of exception thrown depends on the actual provider implementation. See documentation /// of the <see cref="LoggingProviderBase.LogInternal">LogInternal</see> method of the used logging /// provider for more information.</exception> public static object Log(this ILogger logger, LoggingEventType severity, string message, MethodBase source) { LoggingHelper.ValideLoggerIsNotNull(logger); LoggingHelper.ValidateSeverityInValidRange(severity); LoggingHelper.ValidateSourceIsNotNull(source); string methodName = LoggingHelper.BuildMethodName(source); LogEntry entry = new LogEntry(severity, message, methodName, null); return(logger.Log(entry)); }
/// <summary>Initializes a new instance of the <see cref="SqlLoggingProvider"/> class.</summary> /// <param name="threshold">The <see cref="LoggingEventType"/> logging threshold. The threshold limits /// the number of event logged. <see cref="LoggingProviderBase.Threshold">Threshold</see> for more /// information.</param> /// <param name="connectionString">The connection string.</param> /// <param name="fallbackProvider">The optional fallback provider.</param> /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="threshold"/> has an /// invalid value.</exception> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="connectionString"/> is a /// null reference (Nothing in VB).</exception> /// <exception cref="ArgumentException">Thrown when the <paramref name="connectionString"/> is an /// empty string.</exception> public SqlLoggingProvider(LoggingEventType threshold, string connectionString, LoggingProviderBase fallbackProvider) : base(threshold, fallbackProvider) { if (connectionString == null) { throw new ArgumentNullException("connectionString"); } if (connectionString.Length == 0) { throw new ArgumentException(SR.ValueShouldNotBeAnEmptyString(), "connectionString"); } this.connectionString = connectionString; }
/// <summary>Initializes a new instance of the <see cref="LoggingProviderBase"/> class.</summary> /// <param name="threshold">The <see cref="LoggingEventType"/> logging threshold. The threshold limits /// the number of event logged. <see cref="Threshold"/> for more information.</param> /// <param name="fallbackProvider">The optional fallback provider.</param> /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="threshold"/> has an /// invalid value.</exception> protected LoggingProviderBase(LoggingEventType threshold, LoggingProviderBase fallbackProvider) { if (threshold < LoggingEventType.Debug || threshold > LoggingEventType.Critical) { throw new InvalidEnumArgumentException("threshold", (int)threshold, typeof(LoggingEventType)); } base.Initialize(this.GetType().Name, null); this.threshold = threshold; // NOTE: We don't have to check for circular references, because a provider is immutable after // creation and can therefore never be circular referencing itself. this.FallbackProvider = fallbackProvider; }
public LogEntry(LoggingEventType severity, string message, Exception exception = null) { if (message == null) { throw new ArgumentNullException("message"); } if (message == string.Empty) { throw new ArgumentException("empty", "message"); } this.Severity = severity; this.Message = message; this.Exception = exception; }
public LogEntry(LoggingEventType severity, string message, Exception exception = null) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (message == string.Empty) { throw new ArgumentException("empty", nameof(message)); } Severity = severity; Message = message; Exception = exception; }
private static ILog GetLoggerWithThreshold(LoggingEventType threshold) { var loggingProvider = (from provider in Logger.Providers where provider.Threshold == threshold select provider).FirstOrDefault(); if (loggingProvider == null) { Assert.Fail("No LoggingProvider with threshold of {0} was found.", threshold); } var adapter = new CuttingEdgeLoggerFactoryAdapter(); return(adapter.GetLogger(loggingProvider.Name)); }
public LogEntry(Type callingType, LoggingEventType severity, string message, Exception exception = null) { if (message == null) { throw new ArgumentNullException("message"); } if (message == string.Empty) { throw new ArgumentException("empty", "message"); } CallingType = callingType; Severity = severity; Message = message; Exception = exception; }
public LogEntry(LoggingEventType severity, string message, Exception exception = null, params object[] args) { if (message == null) { throw new ArgumentNullException("message"); } if (message == string.Empty) { throw new ArgumentException("message cannot be empty", "message"); } Severity = severity; Message = message; Exception = exception; Args = args; }
public LogEntry(LoggingEventType severity, string messageTemplate, Dictionary <string, object> properties = null, Exception exception = null) { if (messageTemplate == null) { throw new ArgumentNullException(nameof(messageTemplate)); } if (messageTemplate == string.Empty) { throw new ArgumentException("Message Template cannot be empty.", nameof(messageTemplate)); } Severity = severity; MessageTemplate = messageTemplate; Exception = exception; Properties = properties ?? new Dictionary <string, object>(); }
NLog.LogLevel GetNLogLevel(LoggingEventType level) { switch (level) { case LoggingEventType.Debug: return(NLog.LogLevel.Debug); case LoggingEventType.Information: return(NLog.LogLevel.Info); case LoggingEventType.Warning: return(NLog.LogLevel.Warn); case LoggingEventType.Error: return(NLog.LogLevel.Error); case LoggingEventType.Fatal: return(NLog.LogLevel.Fatal); default: return(NLog.LogLevel.Trace); } }
private ConsoleColors GetLogLevelConsoleColors(LoggingEventType logLevel) { // do not change user's background color except for Critical switch (logLevel) { case LoggingEventType.Fatal: return new ConsoleColors(ConsoleColor.White, ConsoleColor.Red); case LoggingEventType.Error: return new ConsoleColors(ConsoleColor.Red, defaultConsoleColor); case LoggingEventType.Warning: return new ConsoleColors(ConsoleColor.DarkYellow, defaultConsoleColor); case LoggingEventType.Information: return new ConsoleColors(ConsoleColor.DarkGreen, defaultConsoleColor); default: return new ConsoleColors(ConsoleColor.Gray, defaultConsoleColor); } }
/// <summary> /// Initializes a new instance of the <see cref="AspNetSqlLoggingProvider"/> class. /// </summary> /// <param name="threshold">The <see cref="LoggingEventType"/> logging threshold. The threshold limits /// the number of event logged. <see cref="LoggingProviderBase.Threshold">Threshold</see> for more /// information.</param> /// <param name="configuration">The configuration that initializes this provider.</param> /// <param name="connectionString">The connection string.</param> /// <param name="fallbackProvider">The optional fallback provider.</param> /// <exception cref="ArgumentNullException">Thrown when the <paramref name="connectionString"/> or the /// <paramref name="configuration"/> are null references (Nothing in VB).</exception> /// <exception cref="ArgumentException">Thrown when the <paramref name="connectionString"/> is an /// empty string.</exception> public AspNetSqlLoggingProvider(LoggingEventType threshold, AspNetSqlLoggingProviderConfiguration configuration, string connectionString, LoggingProviderBase fallbackProvider) : base(threshold, connectionString, fallbackProvider) { if (configuration == null) { throw new ArgumentNullException("configuration"); } // We don't have to validate the configuration properties, because the configuration already did // this itself. this.logQueryString = configuration.LogQueryString; this.logFormData = configuration.LogFormData; this.applicationName = configuration.ApplicationName; this.retrievalType = configuration.RetrievalType; }
/// <summary> /// Given a build event that is presumed to be 2.0 (due to its lack of a "ReadFromStream" method) and its /// LoggingEventType, read that event from the stream. /// </summary> private BuildEventArgs ReadEventFromStream(LoggingEventType eventType, ITranslator translator) { string message = null; string helpKeyword = null; string senderName = null; translator.Translate(ref message); translator.Translate(ref helpKeyword); translator.Translate(ref senderName); BuildEventArgs buildEvent = null; switch (eventType) { case LoggingEventType.TaskCommandLineEvent: buildEvent = ReadTaskCommandLineEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildErrorEvent: buildEvent = ReadTaskBuildErrorEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.ProjectStartedEvent: buildEvent = ReadExternalProjectStartedEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.ProjectFinishedEvent: buildEvent = ReadExternalProjectFinishedEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildMessageEvent: buildEvent = ReadBuildMessageEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildWarningEvent: buildEvent = ReadBuildWarningEventFromStream(translator, message, helpKeyword, senderName); break; default: ErrorUtilities.ThrowInternalError("Not Supported LoggingEventType {0}", eventType.ToString()); break; } return(buildEvent); }
/// <summary> /// Takes in a id (LoggingEventType as an int) and creates the correct specific logging class /// </summary> private BuildEventArgs GetBuildEventArgFromId(LoggingEventType id) { switch (id) { case LoggingEventType.BuildErrorEvent: return(new BuildErrorEventArgs(null, null, null, -1, -1, -1, -1, null, null, null)); case LoggingEventType.BuildFinishedEvent: return(new BuildFinishedEventArgs(null, null, false)); case LoggingEventType.BuildMessageEvent: return(new BuildMessageEventArgs(null, null, null, MessageImportance.Normal)); case LoggingEventType.BuildStartedEvent: return(new BuildStartedEventArgs(null, null)); case LoggingEventType.BuildWarningEvent: return(new BuildWarningEventArgs(null, null, null, -1, -1, -1, -1, null, null, null)); case LoggingEventType.ProjectFinishedEvent: return(new ProjectFinishedEventArgs(null, null, null, false)); case LoggingEventType.ProjectStartedEvent: return(new ProjectStartedEventArgs(-1, null, null, null, null, null, null, null)); case LoggingEventType.TargetStartedEvent: return(new TargetStartedEventArgs(null, null, null, null, null)); case LoggingEventType.TargetFinishedEvent: return(new TargetFinishedEventArgs(null, null, null, null, null, false)); case LoggingEventType.TaskStartedEvent: return(new TaskStartedEventArgs(null, null, null, null, null)); case LoggingEventType.TaskFinishedEvent: return(new TaskFinishedEventArgs(null, null, null, null, null, false)); case LoggingEventType.TaskCommandLineEvent: return(new TaskCommandLineEventArgs(null, null, MessageImportance.Normal)); default: ErrorUtilities.VerifyThrow(false, "Should not get to the default of getBuildEventArgFromId ID:" + id); return(null); } }
public bool IsLogEventEnabled(LoggingEventType eventType) { switch (eventType) { case LoggingEventType.Debug: return logger.IsDebugEnabled; case LoggingEventType.Info: return logger.IsInfoEnabled; case LoggingEventType.Warn: return logger.IsWarnEnabled; case LoggingEventType.Error: return logger.IsErrorEnabled; case LoggingEventType.Fatal: return logger.IsFatalEnabled; default: return false; } }
public LogEntry(LoggingEventType eventType, string message, Exception exception) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (string.IsNullOrWhiteSpace(message)) { throw new ArgumentException(nameof(message)); } if (eventType < LoggingEventType.Debug || eventType > LoggingEventType.Fatal) { throw new ArgumentOutOfRangeException(nameof(eventType)); } this.EventType = eventType; this.Message = message; this.Exception = exception; }
public LogEntry(LoggingEventType severity, string message, string source, Exception exception) { if (message == null) { throw new ArgumentNullException("message"); } if (string.IsNullOrEmpty(message)) { throw new ArgumentException("message"); } if (severity < LoggingEventType.Verbose || severity > LoggingEventType.Fatal) { throw new ArgumentOutOfRangeException("severity"); } this.Severity = severity; this.Message = message; this.Source = source; this.Exception = exception; }
/// <summary> /// Given a build event that is presumed to be 2.0 (due to its lack of a "WriteToStream" method) and its /// LoggingEventType, serialize that event to the stream. /// </summary> private void WriteEventToStream(BuildEventArgs buildEvent, LoggingEventType eventType, INodePacketTranslator translator) { string message = buildEvent.Message; string helpKeyword = buildEvent.HelpKeyword; string senderName = buildEvent.SenderName; translator.Translate(ref message); translator.Translate(ref helpKeyword); translator.Translate(ref senderName); // It is essential that you translate in the same order during writing and reading switch (eventType) { case LoggingEventType.BuildMessageEvent: WriteBuildMessageEventToStream((BuildMessageEventArgs)buildEvent, translator); break; case LoggingEventType.TaskCommandLineEvent: WriteTaskCommandLineEventToStream((TaskCommandLineEventArgs)buildEvent, translator); break; case LoggingEventType.BuildErrorEvent: WriteBuildErrorEventToStream((BuildErrorEventArgs)buildEvent, translator); break; case LoggingEventType.BuildWarningEvent: WriteBuildWarningEventToStream((BuildWarningEventArgs)buildEvent, translator); break; case LoggingEventType.ProjectStartedEvent: WriteExternalProjectStartedEventToStream((ExternalProjectStartedEventArgs)buildEvent, translator); break; case LoggingEventType.ProjectFinishedEvent: WriteExternalProjectFinishedEventToStream((ExternalProjectFinishedEventArgs)buildEvent, translator); break; default: ErrorUtilities.ThrowInternalError("Not Supported LoggingEventType {0}", eventType.ToString()); break; } }
/// <summary> /// Takes in a id (LoggingEventType as an int) and creates the correct specific logging class /// </summary> private BuildEventArgs GetBuildEventArgFromId(LoggingEventType id) { switch (id) { case LoggingEventType.BuildErrorEvent: return new BuildErrorEventArgs(null, null, null, -1, -1, -1, -1, null, null, null); case LoggingEventType.BuildFinishedEvent: return new BuildFinishedEventArgs(null, null, false); case LoggingEventType.BuildMessageEvent: return new BuildMessageEventArgs(null, null, null, MessageImportance.Normal); case LoggingEventType.BuildStartedEvent: return new BuildStartedEventArgs(null, null); case LoggingEventType.BuildWarningEvent: return new BuildWarningEventArgs(null, null, null, -1, -1, -1, -1,null,null,null); case LoggingEventType.ProjectFinishedEvent: return new ProjectFinishedEventArgs(null, null, null, false); case LoggingEventType.ProjectStartedEvent: return new ProjectStartedEventArgs(-1, null, null, null, null, null, null, null); case LoggingEventType.TargetStartedEvent: return new TargetStartedEventArgs(null, null, null, null, null); case LoggingEventType.TargetFinishedEvent: return new TargetFinishedEventArgs(null, null, null, null, null, false); case LoggingEventType.TaskStartedEvent: return new TaskStartedEventArgs(null, null, null, null, null); case LoggingEventType.TaskFinishedEvent: return new TaskFinishedEventArgs(null, null, null, null, null, false); case LoggingEventType.TaskCommandLineEvent: return new TaskCommandLineEventArgs(null, null, MessageImportance.Normal); default: ErrorUtilities.VerifyThrow(false, "Should not get to the default of getBuildEventArgFromId ID:" + id); return null; } }
/// <summary> /// Log with specified severity. /// </summary> /// <param name="logger"></param> /// <param name="severity"></param> /// <param name="message"></param> /// <param name="source"></param> /// <param name="exception"></param> public static void Log(this ILogger logger, LoggingEventType severity, string message, string source = null, Exception exception = null) { logger.Log(new LogEntry(severity, message, source, exception)); }
public bool IsLogEventEnabled(LoggingEventType eventType) { return true; }
/// <summary> /// Verify the LoggingMessagePacket is properly created from a build event. /// This includes the packet type and the event type depending on which build event arg is passed in. /// </summary> /// <param name="buildEvent">Build event to put into a packet, and verify after packet creation</param> /// <param name="logEventType">What is the expected logging event type</param> private static void VerifyLoggingPacket(BuildEventArgs buildEvent, LoggingEventType logEventType) { LogMessagePacket packet = new LogMessagePacket(new KeyValuePair<int, BuildEventArgs>(0, buildEvent)); Assert.Equal(logEventType, packet.EventType); Assert.Equal(NodePacketType.LogMessage, packet.Type); Assert.True(Object.ReferenceEquals(buildEvent, packet.NodeBuildEvent.Value.Value)); // "Expected buildEvent to have the same object reference as packet.BuildEvent" }
/// <summary> /// Reads the logging packet from the translator. /// </summary> internal void ReadFromStream(INodePacketTranslator translator) { if (LoggingEventType.CustomEvent != _eventType) { _buildEvent = GetBuildEventArgFromId(); // The other side is telling us whether the event knows how to log itself, or whether we're going to have // to do it manually int packetVersion = s_defaultPacketVersion; translator.Translate(ref packetVersion); bool eventCanSerializeItself = true; translator.Translate(ref eventCanSerializeItself); if (eventCanSerializeItself) { MethodInfo methodInfo = null; lock (s_readMethodCache) { if (!s_readMethodCache.TryGetValue(_eventType, out methodInfo)) { Type eventDerivedType = _buildEvent.GetType(); methodInfo = eventDerivedType.GetMethod("CreateFromStream", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod); s_readMethodCache.Add(_eventType, methodInfo); } } ArgsReaderDelegate readerMethod = (ArgsReaderDelegate)CreateDelegateRobust(typeof(ArgsReaderDelegate), _buildEvent, methodInfo); readerMethod(translator.Reader, packetVersion); if (_eventType == LoggingEventType.TargetFinishedEvent && _targetFinishedTranslator != null) { _targetFinishedTranslator(translator, (TargetFinishedEventArgs)_buildEvent); } } else { _buildEvent = ReadEventFromStream(_eventType, translator); } } else { string fileLocation = null; translator.Translate(ref fileLocation); bool resolveAssembly = false; lock (s_lockObject) { if (!s_customEventsLoaded.Contains(fileLocation)) { resolveAssembly = true; } // If we are to resolve the assembly add it to the list of assemblies resolved if (resolveAssembly) { s_customEventsLoaded.Add(fileLocation); } } if (resolveAssembly) { s_resolver = new TaskEngineAssemblyResolver(); s_resolver.InstallHandler(); s_resolver.Initialize(fileLocation); } try { translator.TranslateDotNet(ref _buildEvent); } finally { if (resolveAssembly) { s_resolver.RemoveHandler(); s_resolver = null; } } } _eventType = GetLoggingEventId(_buildEvent); }
/// <summary> /// Given a build event that is presumed to be 2.0 (due to its lack of a "ReadFromStream" method) and its /// LoggingEventType, read that event from the stream. /// </summary> private BuildEventArgs ReadEventFromStream(LoggingEventType eventType, INodePacketTranslator translator) { string message = null; string helpKeyword = null; string senderName = null; translator.Translate(ref message); translator.Translate(ref helpKeyword); translator.Translate(ref senderName); BuildEventArgs buildEvent = null; switch (eventType) { case LoggingEventType.TaskCommandLineEvent: buildEvent = ReadTaskCommandLineEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildErrorEvent: buildEvent = ReadTaskBuildErrorEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.ProjectStartedEvent: buildEvent = ReadExternalProjectStartedEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.ProjectFinishedEvent: buildEvent = ReadExternalProjectFinishedEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildMessageEvent: buildEvent = ReadBuildMessageEventFromStream(translator, message, helpKeyword, senderName); break; case LoggingEventType.BuildWarningEvent: buildEvent = ReadBuildWarningEventFromStream(translator, message, helpKeyword, senderName); break; default: ErrorUtilities.ThrowInternalError("Not Supported LoggingEventType {0}", eventType.ToString()); break; } return buildEvent; }
public LogEntry(LoggingEventType severity, string message, Exception exception = null) { Severity = severity; Message = message; Exception = exception; }
/// <summary> /// Encapsulates the buildEventArg in this packet. /// </summary> internal LogMessagePacketBase(KeyValuePair<int, BuildEventArgs>? nodeBuildEvent, TargetFinishedTranslator targetFinishedTranslator) { ErrorUtilities.VerifyThrow(nodeBuildEvent != null, "nodeBuildEvent was null"); _buildEvent = nodeBuildEvent.Value.Value; _sinkId = nodeBuildEvent.Value.Key; _eventType = GetLoggingEventId(_buildEvent); _targetFinishedTranslator = targetFinishedTranslator; }