TimeSpan GetTimeToRestartErrorIngestionAfterFailure() { string message; var valueRead = SettingsReader <string> .Read("TimeToRestartErrorIngestionAfterFailure"); if (valueRead == null) { return(TimeSpan.FromSeconds(60)); } if (TimeSpan.TryParse(valueRead, out var result)) { if (ValidateConfiguration && result < TimeSpan.FromSeconds(5)) { message = "TimeToRestartErrorIngestionAfterFailure setting is invalid, value should be minimum 5 seconds."; InternalLogger.Fatal(message); throw new Exception(message); } if (ValidateConfiguration && result > TimeSpan.FromHours(1)) { message = "TimeToRestartErrorIngestionAfterFailure setting is invalid, value should be maximum 1 hour."; InternalLogger.Fatal(message); throw new Exception(message); } } else { message = "TimeToRestartErrorIngestionAfterFailure setting is invalid, please make sure it is a TimeSpan."; InternalLogger.Fatal(message); throw new Exception(message); } return(result); }
public void TimestampTests() { InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = true; InternalLogger.LogToConsole = true; StringWriter consoleOutWriter = new StringWriter() { NewLine = "\n" }; // Redirect the console output to a StringWriter. Console.SetOut(consoleOutWriter); // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW"); InternalLogger.Error("EEE"); InternalLogger.Fatal("FFF"); InternalLogger.Trace("TTT"); InternalLogger.Debug("DDD"); InternalLogger.Info("III"); string expectedDateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture); var strings = consoleOutWriter.ToString().Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var str in strings) { Assert.Contains(expectedDateTime + ".", str); } }
private void RequestCallback(IAsyncResult result) { InternalLogger.Trace("{0}.RequestCallback({1})", GetType(), result); // Get it back var request = result.AsyncState as HttpWebRequest; if (request == null) { InternalLogger.Fatal("{0}.AsyncState was null or not of type {1}.", typeof(IAsyncResult), typeof(HttpWebRequest)); return; } WebResponse response; // We want to swallow any error responses try { response = request.EndGetResponse(result); } catch (WebException exception) { // Since an exception was already thrown, allowing another one to bubble up is pointless InternalLogger.Fatal("An error occurred while retriving the Airbrake web response: {0}, web response: {1}", exception.Message, exception.Response); response = exception.Response; } OnRequestEnd(request, response); }
public void TimestampTests() { using (new InternalLoggerScope()) { InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = true; StringWriter consoleOutWriter = new StringWriter() { NewLine = ";" }; InternalLogger.LogWriter = consoleOutWriter; // Set fixed time source to test time output TimeSource.Current = new FixedTimeSource(DateTime.Now); // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW"); InternalLogger.Error("EEE"); InternalLogger.Fatal("FFF"); InternalLogger.Trace("TTT"); InternalLogger.Debug("DDD"); InternalLogger.Info("III"); string expectedDateTime = TimeSource.Current.Time.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture); var strings = consoleOutWriter.ToString().Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (var str in strings) { Assert.Contains(expectedDateTime + ".", str); } } }
private void OnRequestEnd(WebRequest request, WebResponse response) { if (response == null) { InternalLogger.Fatal("No response received!"); return; } string responseBody; using (var responseStream = response.GetResponseStream()) { if (responseStream == null) { return; } using (var sr = new StreamReader(responseStream)) { responseBody = sr.ReadToEnd(); InternalLogger.Debug("Received from Airbrake.\n{0}", responseBody); } } if (RequestEnd != null) { RequestEndEventArgs e = new RequestEndEventArgs(request, response, responseBody); RequestEnd(this, e); } }
protected override void Write(LogEventInfo logEvent) { var logMessage = Layout.Render(logEvent); var subject = Subject.Render(logEvent); var count = Encoding.UTF8.GetByteCount(logMessage); if (count > ConfiguredMaxMessageSizeInBytes) { if (InternalLogger.IsWarnEnabled) { InternalLogger.Warn("logging message will be truncted. original message is\n{0}", logMessage); } logMessage = logMessage.LeftB(TransferEncoding, truncateSizeInBytes) + TruncateMessage; } try { client.Publish(new PublishRequest() { Message = logMessage, Subject = subject, TopicArn = TopicArn }); } catch (AmazonSimpleNotificationServiceException e) { InternalLogger.Fatal("RequstId: {0},ErrorType: {1}, Status: {2}\nFailed to send log with\n{3}\n{4}", e.RequestId, e.ErrorType, e.StatusCode, e.Message, e.StackTrace); } }
public void Log(SentryLevel logLevel, string message, Exception exception = null, params object[] args) { switch (logLevel) { case SentryLevel.Fatal: InternalLogger.Fatal(exception, message, args); break; case SentryLevel.Error: InternalLogger.Error(exception, message, args); break; case SentryLevel.Warning: InternalLogger.Warn(exception, message, args); break; case SentryLevel.Info: InternalLogger.Info(exception, message, args); break; default: InternalLogger.Debug(exception, message, args); break; } if (_extraLogger?.IsEnabled(logLevel) == true) { _extraLogger.Log(logLevel, message, exception, args); } }
TimeSpan?GetAuditRetentionPeriod() { string message; var valueRead = SettingsReader <string> .Read("AuditRetentionPeriod"); if (valueRead == null) { return(null); } if (TimeSpan.TryParse(valueRead, out var result)) { if (ValidateConfiguration && result < TimeSpan.FromHours(1)) { message = "AuditRetentionPeriod settings is invalid, value should be minimum 1 hour."; InternalLogger.Fatal(message); throw new Exception(message); } if (ValidateConfiguration && result > TimeSpan.FromDays(365)) { message = "AuditRetentionPeriod settings is invalid, value should be maximum 365 days."; InternalLogger.Fatal(message); throw new Exception(message); } } else { message = "AuditRetentionPeriod settings is invalid, please make sure it is a TimeSpan."; InternalLogger.Fatal(message); throw new Exception(message); } return(result); }
public void ShouldLogToTraceWhenInternalLogToTraceIsOnAndLogLevelIsFatal(bool?internalLogToTrace, bool?logToTrace) { var mockTraceListener = SetupTestConfiguration <MockTraceListener>(LogLevel.Fatal, internalLogToTrace, logToTrace); InternalLogger.Fatal("Logger1 Hello"); Assert.Equal(1, mockTraceListener.Messages.Count); Assert.Equal("NLog: Fatal Logger1 Hello" + Environment.NewLine, mockTraceListener.Messages.First()); }
public void WriteToConsoleErrorTests() { using (var loggerScope = new InternalLoggerScope(true)) { // Expected result is the same for both types of method invocation. const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n"; InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = false; InternalLogger.LogToConsoleError = true; { StringWriter consoleWriter1 = new StringWriter() { NewLine = "\n" }; // Redirect the console output to a StringWriter. loggerScope.SetConsoleError(consoleWriter1); // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW"); InternalLogger.Error("EEE"); InternalLogger.Fatal("FFF"); InternalLogger.Trace("TTT"); InternalLogger.Debug("DDD"); InternalLogger.Info("III"); TestWriter(expected, loggerScope.ConsoleErrorWriter); } { // // Redirect the console output to another StringWriter. StringWriter consoleWriter2 = new StringWriter() { NewLine = "\n" }; loggerScope.SetConsoleError(consoleWriter2); // Invoke Log(LogLevel, string) for every log level. InternalLogger.Log(LogLevel.Warn, "WWW"); InternalLogger.Log(LogLevel.Error, "EEE"); InternalLogger.Log(LogLevel.Fatal, "FFF"); InternalLogger.Log(LogLevel.Trace, "TTT"); InternalLogger.Log(LogLevel.Debug, "DDD"); InternalLogger.Log(LogLevel.Info, "III"); TestWriter(expected, loggerScope.ConsoleErrorWriter); } } }
public static IFileWrapper CreateForPath([NotNull] string filePath) { try { return(new FileWrapper(filePath)); } catch (Exception ex) { InternalLogger.Fatal(ex, "Unable to use file {0}", filePath); } return(NullFileWrapper.Instance); }
public void WriteToStringWriterWithArgsTests() { try { // Expected result is the same for both types of method invocation. const string expected = "Warn WWW 0\nError EEE 0, 1\nFatal FFF 0, 1, 2\nTrace TTT 0, 1, 2\nDebug DDD 0, 1\nInfo III 0\n"; InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = false; { StringWriter writer1 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer1; // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW {0}", 0); InternalLogger.Error("EEE {0}, {1}", 0, 1); InternalLogger.Fatal("FFF {0}, {1}, {2}", 0, 1, 2); InternalLogger.Trace("TTT {0}, {1}, {2}", 0, 1, 2); InternalLogger.Debug("DDD {0}, {1}", 0, 1); InternalLogger.Info("III {0}", 0); TestWriter(expected, writer1); } { // // Reconfigure the LogWriter. StringWriter writer2 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer2; // Invoke Log(LogLevel, string) for every log level. InternalLogger.Log(LogLevel.Warn, "WWW {0}", 0); InternalLogger.Log(LogLevel.Error, "EEE {0}, {1}", 0, 1); InternalLogger.Log(LogLevel.Fatal, "FFF {0}, {1}, {2}", 0, 1, 2); InternalLogger.Log(LogLevel.Trace, "TTT {0}, {1}, {2}", 0, 1, 2); InternalLogger.Log(LogLevel.Debug, "DDD {0}, {1}", 0, 1); InternalLogger.Log(LogLevel.Info, "III {0}", 0); TestWriter(expected, writer2); } } finally { InternalLogger.Reset(); } }
/// <summary> /// Sends the specified notice to Airbrake. /// </summary> /// <param name="notice">The notice.</param> public void Send(AirbrakeNotice notice) { InternalLogger.Debug("{0}.Send({1})", GetType(), notice); try { // If no API key, get it from the appSettings if (String.IsNullOrEmpty(notice.ApiKey)) { // If none is set, just return... throwing an exception is pointless, since one was already thrown! if (String.IsNullOrEmpty(ConfigurationManager.AppSettings["Airbrake.ApiKey"])) { InternalLogger.Fatal("No 'Airbrake.ApiKey' found. Please define one in AppSettings."); return; } notice.ApiKey = this.builder.Configuration.ApiKey; } // Create the web request var request = WebRequest.Create(this.configuration.ServerUri) as HttpWebRequest; if (request == null) { InternalLogger.Fatal("Couldn't create a request to '{0}'.", this.configuration.ServerUri); return; } // Set the basic headers request.ContentType = "text/xml"; request.Accept = "text/xml"; request.KeepAlive = false; // It is important to set the method late... .NET quirk, it will interfere with headers set after request.Method = "POST"; InternalLogger.Debug("Sending Airbrake notice to {0} with key {1}, env: {2}", this.configuration.ServerUri, this.configuration.ApiKey, this.configuration.EnvironmentName); // Go populate the body SetRequestBody(request, notice); // Begin the request, yay async request.BeginGetResponse(RequestCallback, request); } catch (Exception ex) { InternalLogger.Fatal("An error occurred while trying to send to Airbrake: {0}", ex.Message); } }
public void TestMinLevelSwitch_lambda(string rawLogLevel, int count) { Action log = () => { InternalLogger.Fatal(() => "L1"); InternalLogger.Error(() => "L2"); InternalLogger.Warn(() => "L3"); InternalLogger.Info(() => "L4"); InternalLogger.Debug(() => "L5"); InternalLogger.Trace(() => "L6"); }; TestMinLevelSwitch_inner(rawLogLevel, count, log); }
public void ExceptionTests() { using (new InternalLoggerScope()) { InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.LogToConsole = true; InternalLogger.IncludeTimestamp = false; var ex1 = new Exception("e1"); var ex2 = new Exception("e2", new Exception("inner")); var ex3 = new NLogConfigurationException("config error"); var ex4 = new NLogConfigurationException("config error", ex2); var ex5 = new PathTooLongException(); ex5.Data["key1"] = "value1"; Exception ex6 = null; const string prefix = " Exception: "; string expected = "Warn WWW" + prefix + ex1 + Environment.NewLine + "Error EEE" + prefix + ex2 + Environment.NewLine + "Fatal FFF" + prefix + ex3 + Environment.NewLine + "Trace TTT" + prefix + ex4 + Environment.NewLine + "Debug DDD" + prefix + ex5 + Environment.NewLine + "Info III" + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. Console.SetOut(consoleOutWriter); // Named (based on LogLevel) public methods. InternalLogger.Warn(ex1, "WWW"); InternalLogger.Error(ex2, "EEE"); InternalLogger.Fatal(ex3, "FFF"); InternalLogger.Trace(ex4, "TTT"); InternalLogger.Debug(ex5, "DDD"); InternalLogger.Info(ex6, "III"); consoleOutWriter.Flush(); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } }
public void WriteToStringWriterTests() { // Expected result is the same for both types of method invocation. const string expected = "Warn WWW\nError EEE\nFatal FFF\nTrace TTT\nDebug DDD\nInfo III\n"; InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = false; StringWriter writer1 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer1; // Named (based on LogLevel) public methods. InternalLogger.Warn("WWW"); InternalLogger.Error("EEE"); InternalLogger.Fatal("FFF"); InternalLogger.Trace("TTT"); InternalLogger.Debug("DDD"); InternalLogger.Info("III"); Assert.True(writer1.ToString() == expected); // // Reconfigure the LogWriter. StringWriter writer2 = new StringWriter() { NewLine = "\n" }; InternalLogger.LogWriter = writer2; // Invoke Log(LogLevel, string) for every log level. InternalLogger.Log(LogLevel.Warn, "WWW"); InternalLogger.Log(LogLevel.Error, "EEE"); InternalLogger.Log(LogLevel.Fatal, "FFF"); InternalLogger.Log(LogLevel.Trace, "TTT"); InternalLogger.Log(LogLevel.Debug, "DDD"); InternalLogger.Log(LogLevel.Info, "III"); Assert.True(writer2.ToString() == expected); }
protected override void InitializeTarget() { base.InitializeTarget(); var size = MaxMessageSize ?? DefaultMaxMessageSize; if (size <= 0 || size >= 256) { ConfiguredMaxMessageSizeInBytes = 256 * 1024; } else if (size <= DefaultMaxMessageSize) { ConfiguredMaxMessageSizeInBytes = DefaultMaxMessageSize * 1024; } else { ConfiguredMaxMessageSizeInBytes = size * 1024; } InternalLogger.Info(string.Format("Max message size is set to {0} KB.", ConfiguredMaxMessageSizeInBytes / 1024)); truncateSizeInBytes = ConfiguredMaxMessageSizeInBytes - TransferEncoding.GetByteCount(TruncateMessage); try { if (string.IsNullOrEmpty(AwsAccessKey) && string.IsNullOrEmpty(AwsSecretKey)) { InternalLogger.Info("AWS Access Keys are not specified. Use Application Setting or EC2 Instance profile for keys."); client = new AmazonSimpleNotificationServiceClient(RegionEndpoint.GetBySystemName(Endpoint)); } else { client = new AmazonSimpleNotificationServiceClient(AwsAccessKey, AwsSecretKey, RegionEndpoint.GetBySystemName(Endpoint)); } } catch (Exception e) { InternalLogger.Fatal("Amazon SNS client failed to be configured. This logger wont'be send any message. Error is\n{0}\n{1}", e.Message, e.StackTrace); } }
public void VerifyInternalLoggerLevelFilter(bool? internalLogToTrace, bool? logToTrace) { foreach (LogLevel logLevelConfig in LogLevel.AllLevels) { var mockTraceListener = SetupTestConfiguration<MockTraceListener>(logLevelConfig, internalLogToTrace, logToTrace); List<string> expected = new List<string>(); string input = "Logger1 Hello"; expected.Add(input); InternalLogger.Trace(input); InternalLogger.Debug(input); InternalLogger.Info(input); InternalLogger.Warn(input); InternalLogger.Error(input); InternalLogger.Fatal(input); input += "No.{0}"; expected.Add(string.Format(input, 1)); InternalLogger.Trace(input, 1); InternalLogger.Debug(input, 1); InternalLogger.Info(input, 1); InternalLogger.Warn(input, 1); InternalLogger.Error(input, 1); InternalLogger.Fatal(input, 1); input += ", We come in {1}"; expected.Add(string.Format(input, 1, "Peace")); InternalLogger.Trace(input, 1, "Peace"); InternalLogger.Debug(input, 1, "Peace"); InternalLogger.Info(input, 1, "Peace"); InternalLogger.Warn(input, 1, "Peace"); InternalLogger.Error(input, 1, "Peace"); InternalLogger.Fatal(input, 1, "Peace"); input += " and we are {2} to god"; expected.Add(string.Format(input, 1, "Peace", true)); InternalLogger.Trace(input, 1, "Peace", true); InternalLogger.Debug(input, 1, "Peace", true); InternalLogger.Info(input, 1, "Peace", true); InternalLogger.Warn(input, 1, "Peace", true); InternalLogger.Error(input, 1, "Peace", true); InternalLogger.Fatal(input, 1, "Peace", true); input += ", Please don't {3}"; expected.Add(string.Format(input, 1, "Peace", true, null)); InternalLogger.Trace(input, 1, "Peace", true, null); InternalLogger.Debug(input, 1, "Peace", true, null); InternalLogger.Info(input, 1, "Peace", true, null); InternalLogger.Warn(input, 1, "Peace", true, null); InternalLogger.Error(input, 1, "Peace", true, null); InternalLogger.Fatal(input, 1, "Peace", true, null); input += " the {4}"; expected.Add(string.Format(input, 1, "Peace", true, null, "Messenger")); InternalLogger.Trace(input, 1, "Peace", true, null, "Messenger"); InternalLogger.Debug(input, 1, "Peace", true, null, "Messenger"); InternalLogger.Info(input, 1, "Peace", true, null, "Messenger"); InternalLogger.Warn(input, 1, "Peace", true, null, "Messenger"); InternalLogger.Error(input, 1, "Peace", true, null, "Messenger"); InternalLogger.Fatal(input, 1, "Peace", true, null, "Messenger"); Assert.Equal(expected.Count * (LogLevel.Fatal.Ordinal - logLevelConfig.Ordinal + 1), mockTraceListener.Messages.Count); for (int i = 0; i < expected.Count; ++i) { int msgCount = LogLevel.Fatal.Ordinal - logLevelConfig.Ordinal + 1; for (int j = 0; j < msgCount; ++j) { Assert.True(mockTraceListener.Messages.First().Contains(expected[i])); mockTraceListener.Messages.RemoveAt(0); } } Assert.Equal(0, mockTraceListener.Messages.Count); } }
public void ExceptionTests() { using (new InternalLoggerScope()) { InternalLogger.LogLevel = LogLevel.Trace; InternalLogger.IncludeTimestamp = false; var ex1 = new Exception("e1"); var ex2 = new Exception("e2", new Exception("inner")); var ex3 = new NLogConfigurationException("config error"); var ex4 = new NLogConfigurationException("config error", ex2); var ex5 = new PathTooLongException(); ex5.Data["key1"] = "value1"; Exception ex6 = null; const string prefix = " Exception: "; { string expected = "Warn WWW1" + prefix + ex1 + Environment.NewLine + "Error EEE1" + prefix + ex2 + Environment.NewLine + "Fatal FFF1" + prefix + ex3 + Environment.NewLine + "Trace TTT1" + prefix + ex4 + Environment.NewLine + "Debug DDD1" + prefix + ex5 + Environment.NewLine + "Info III1" + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. InternalLogger.LogWriter = consoleOutWriter; // Named (based on LogLevel) public methods. InternalLogger.Warn(ex1, "WWW1"); InternalLogger.Error(ex2, "EEE1"); InternalLogger.Fatal(ex3, "FFF1"); InternalLogger.Trace(ex4, "TTT1"); InternalLogger.Debug(ex5, "DDD1"); InternalLogger.Info(ex6, "III1"); consoleOutWriter.Flush(); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } { string expected = "Warn WWW2" + prefix + ex1 + Environment.NewLine + "Error EEE2" + prefix + ex2 + Environment.NewLine + "Fatal FFF2" + prefix + ex3 + Environment.NewLine + "Trace TTT2" + prefix + ex4 + Environment.NewLine + "Debug DDD2" + prefix + ex5 + Environment.NewLine + "Info III2" + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. InternalLogger.LogWriter = consoleOutWriter; // Named (based on LogLevel) public methods. InternalLogger.Warn(ex1, () => "WWW2"); InternalLogger.Error(ex2, () => "EEE2"); InternalLogger.Fatal(ex3, () => "FFF2"); InternalLogger.Trace(ex4, () => "TTT2"); InternalLogger.Debug(ex5, () => "DDD2"); InternalLogger.Info(ex6, () => "III2"); consoleOutWriter.Flush(); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } { string expected = "Warn WWW3" + prefix + ex1 + Environment.NewLine + "Error EEE3" + prefix + ex2 + Environment.NewLine + "Fatal FFF3" + prefix + ex3 + Environment.NewLine + "Trace TTT3" + prefix + ex4 + Environment.NewLine + "Debug DDD3" + prefix + ex5 + Environment.NewLine + "Info III3" + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. InternalLogger.LogWriter = consoleOutWriter; // Named (based on LogLevel) public methods. InternalLogger.Log(ex1, LogLevel.Warn, "WWW3"); InternalLogger.Log(ex2, LogLevel.Error, "EEE3"); InternalLogger.Log(ex3, LogLevel.Fatal, "FFF3"); InternalLogger.Log(ex4, LogLevel.Trace, "TTT3"); InternalLogger.Log(ex5, LogLevel.Debug, "DDD3"); InternalLogger.Log(ex6, LogLevel.Info, "III3"); consoleOutWriter.Flush(); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } { string expected = "Warn WWW4" + prefix + ex1 + Environment.NewLine + "Error EEE4" + prefix + ex2 + Environment.NewLine + "Fatal FFF4" + prefix + ex3 + Environment.NewLine + "Trace TTT4" + prefix + ex4 + Environment.NewLine + "Debug DDD4" + prefix + ex5 + Environment.NewLine + "Info III4" + Environment.NewLine; StringWriter consoleOutWriter = new StringWriter() { NewLine = Environment.NewLine }; // Redirect the console output to a StringWriter. InternalLogger.LogWriter = consoleOutWriter; // Named (based on LogLevel) public methods. InternalLogger.Log(ex1, LogLevel.Warn, () => "WWW4"); InternalLogger.Log(ex2, LogLevel.Error, () => "EEE4"); InternalLogger.Log(ex3, LogLevel.Fatal, () => "FFF4"); InternalLogger.Log(ex4, LogLevel.Trace, () => "TTT4"); InternalLogger.Log(ex5, LogLevel.Debug, () => "DDD4"); InternalLogger.Log(ex6, LogLevel.Info, () => "III4"); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } } }