protected override void OnShown(EventArgs e)
{
SearchUpdates();
if (_memoryLogger.Logs.Count > 0)
{
LogRichTextBox.Text =
_memoryLogger.Logs.Aggregate(new StringBuilder(), (x, y) => x.AppendLine(y)).ToString();
}
LogManager.Configuration.LoggingRules.Remove(_loggingRule);
_memoryLogger.Dispose();
_memoryLogger = null;
_loggingRule = null;
var target = new RichTextBoxTarget
{
Layout = Program.LogLayout,
ControlName = "LogRichTextBox",
FormName = Name,
AutoScroll = true,
CreatedForm = false,
Name = "textBox"
};
target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Debug", "Gray", "White"));
target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Info", "Black", "White"));
target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Warn", "DarkRed", "White"));
target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Error", "White", "DarkRed",
FontStyle.Bold));
target.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Fatal", "Yellow", "DarkRed",
FontStyle.Bold));
SimpleConfigurator.ConfigureForTargetLogging(target, Program.MinLogLevel);
}
public MainForm(TcpServer server, MemoryTarget memoryLogger, LoggingRule loggingRule, Settings settings)
{
InitializeComponent();
_server = server;
_memoryLogger = memoryLogger;
_loggingRule = loggingRule;
_settings = settings;
server.AdministrationsChanged += ServerAdministrationsChanged;
server.ClientsChanged += ServerClientsChanged;
server.IsRunningChanged += Server_IsRunningChanged;
_bindingSource = new BindingSource {
DataSource = settings.IpAddresses
};
ListenersListBox.DataSource = _bindingSource;
PasswordTextBox.Text = settings.Password;
Server_IsRunningChanged(this, null);
if (server.IsLoading)
{
ButtonStart.Enabled = false;
ButtonStop.Enabled = false;
}
}
public NLogLogProviderLoggingEnabledTests()
{
NLogLogManager.ProviderIsAvailableOverride = true;
var config = new LoggingConfiguration();
simpleLayoutTarget = new MemoryTarget
{
Layout = "${level:uppercase=true}|${message}|${exception}"
};
ndcLayoutTarget = new MemoryTarget
{
Layout = "${level:uppercase=true}|${ndc:bottomFrames=10:topFrames=10:separator=;}|${message}|${exception}"
};
mdcLayoutTarget = new MemoryTarget
{
Layout = "${level:uppercase=true}|${mdc:item=Key}|${message}|${exception}"
};
config.AddTarget("simpleLayoutMemory", simpleLayoutTarget);
config.AddTarget("mdcLayoutTarget", mdcLayoutTarget);
config.AddTarget("ndcLayoutMemory", ndcLayoutTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, simpleLayoutTarget));
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, mdcLayoutTarget));
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, ndcLayoutTarget));
LogManager.Configuration = config;
nLogLogManager = new NLogLogManager();
sut = nLogLogManager.GetLogger("Test");
}
public void MemoryTarget_LogLevelTest()
{
ILogger logger = LogManager.GetCurrentClassLogger();
var memoryTarget = new MemoryTarget
{
Layout = "${level} ${message}"
};
SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, LogLevel.Trace);
Assert.True(memoryTarget.Logs.Count() == 0);
logger.Trace("TTT");
logger.Debug("DDD");
logger.Info("III");
logger.Warn("WWW");
logger.Error("EEE");
logger.Fatal("FFF");
LogManager.Configuration = null;
Assert.True(memoryTarget.Logs.Count() == 6);
Assert.True(memoryTarget.Logs[0] == "Trace TTT");
Assert.True(memoryTarget.Logs[1] == "Debug DDD");
Assert.True(memoryTarget.Logs[2] == "Info III");
Assert.True(memoryTarget.Logs[3] == "Warn WWW");
Assert.True(memoryTarget.Logs[4] == "Error EEE");
Assert.True(memoryTarget.Logs[5] == "Fatal FFF");
}
public void ThreadLoggerTest()
{
LogManager.Configuration = new LoggingConfiguration();
ThreadLoggerFactory threadLoggerFactory = ThreadLogManager.GetCurrentClassLoggerFactory();
MemoryTarget target1 = new MemoryTarget("Test123");
LogManager.Configuration.AddRuleForAllLevels(target1, "Thread1.*");
LogManager.ReconfigExistingLoggers();
ThreadLogManager.ThreadName = "Thread1";
threadLoggerFactory.Logger.Debug("Test Thread1");
MemoryTarget target2 = new MemoryTarget("Test123");
Thread thread = new Thread(() =>
{
LogManager.Configuration.AddRuleForAllLevels(target2, "Thread2.*");
LogManager.ReconfigExistingLoggers();
ThreadLogManager.ThreadName = "Thread2";
threadLoggerFactory.Logger.Debug("Test Thread2");
});
thread.Start();
while (thread.ThreadState != ThreadState.Stopped)
{
Thread.Sleep(10);
}
Assert.AreEqual(target1.Logs.Count, 1);
Assert.AreEqual(target2.Logs.Count, 1);
}
internal async Task handleErrorMemory(CancellationToken cancelToken)
{
MemoryTarget target = LogManager.Configuration.FindTargetByName <MemoryTarget>("errormemory");
while (target.Logs.Count > 0)
{
string s = target.Logs[0];
if (needToSendThis(s))
{
await this.sendMessageWithKeyboard(s, Keyboards.getGotItDeleteButtonKeyboard());
try
{
await Task.Delay(3000, cancelToken);
}
catch (OperationCanceledException)
{
return;
}
updateLastSentMessage(s);
}
target.Logs.RemoveAt(0);
if (cancelToken.IsCancellationRequested)
{
return;
}
}
}
/// <summary>
/// Layout configuration for <see cref="NLog"/>
/// </summary>
/// <returns><see cref="LoggingConfiguration"/></returns>
public static LoggingConfiguration Configure()
{
var config = new LoggingConfiguration();
const string callSite = @"${callsite:className=True:skipFrames=1:includeNamespace=False:cleanNamesOfAnonymousDelegates=True:cleanNamesOfAsyncContinuations=True:fileName=False:includeSourcePath=False:methodName=True";
const string trace = @"<${threadid:padding=2}> |${level:format=FirstCharacter}| ${date:format=HH\:mm\:ss.ff} " +
callSite + @":when:when='${event-properties:dtype}' != '' and level<=LogLevel.Info}" +
@"${literal:text=(:when:when='${event-properties:dtype}' != ''}" + @"${event-properties:msg}" + @"${literal:text=):when:when='${event-properties:dtype}' != ''} " +
@"${literal:text=[:when:when='${event-properties:dtype}' != ''}" + @"${event-properties:dtype}" + @"${literal:text=]:when:when='${event-properties:dtype}' != ''} " +
@"${message:when='${event-properties:msg}' == ''}" +
@"${exception}";
var consoleTarget = new ColoredConsoleTarget
{
Name = "Console",
Layout = trace,
};
_memory = new MemoryTarget
{
Name = "Memory",
Layout = trace,
};
config.AddTarget(consoleTarget);
config.AddTarget(_memory);
LogManager.Configuration = config;
return(config);
}
public void NLogWithTransaction()
{
var assembly = typeof(ApmTraceIdLayoutRenderer).Assembly;
global::NLog.Config.ConfigurationItemFactory.Default.RegisterItemsFromAssembly(assembly);
Agent.Setup(new AgentComponents(payloadSender: new NoopPayloadSender()));
var target = new MemoryTarget();
target.Layout = "${ElasticApmTraceId}|${ElasticApmTransactionId}|${message}";
global::NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Debug);
var logger = LogManager.GetLogger("Example");
logger.Debug("PreTransaction");
string traceId = null;
string transactionId = null;
Agent.Tracer.CaptureTransaction("TestTransaction", "Test", t =>
{
traceId = t.TraceId;
transactionId = t.Id;
logger.Debug("InTransaction");
});
logger.Debug("PostTransaction");
target.Logs.Count.Should().Be(3);
target.Logs[0].Should().Be("||PreTransaction");
target.Logs[1].Should().Be($"{traceId}|{transactionId}|InTransaction");
target.Logs[2].Should().Be("||PostTransaction");
}
public void ExceptionTest()
{
var target = new MemoryTarget {
Layout = @"${exception:format=tostring}"
};
SimpleConfigurator.ConfigureForTargetLogging(target);
var logger = LogManager.GetCurrentClassLogger();
try
{
throw new InvalidOperationException();
}
catch (Exception ex)
{
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US", false);
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US", false);
logger.Error(ex, "");
#if !NETSTANDARD
Thread.CurrentThread.CurrentUICulture = new CultureInfo("de-DE", false);
Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE", false);
#endif
logger.Error(ex, "");
Assert.Equal(2, target.Logs.Count);
Assert.NotNull(target.Logs[0]);
Assert.NotNull(target.Logs[1]);
Assert.Equal(target.Logs[0], target.Logs[1]);
}
}
public void Should_preserve_correct_callsite_information()
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var target = new MemoryTarget();
config.AddTarget("target", target);
// Step 3. Set target properties
target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message}";
// Step 4. Define rules
var rule = new LoggingRule("*", LogLevel.Debug, target);
config.LoggingRules.Add(rule);
var factory = new NLogFactory(config);
WriteLogMessage(factory);
var logMessage = target.Logs[0];
Assert.Contains("CallSiteTests.WriteLogMessage", logMessage);
}
public string GetLogs()
{
MemoryTarget memoryTarget =
(MemoryTarget)LogManager.Configuration.FindTargetByName(MEMORY_TARGET_NAME);
return(string.Join(Environment.NewLine, memoryTarget.Logs));
}
public void MachineNameInPropertyIsRendered()
{
var layout = new JsonWithPropertiesLayout();
layout.Properties.Add(new StructuredLoggingProperty("machinename", "${machinename}"));
var target = new MemoryTarget
{
Name = Guid.NewGuid().ToString(),
Layout = layout
};
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
TimeSource.Current = new FakeTimeSource();
var logger = LogManager.GetCurrentClassLogger();
var logEvent = new LogEventInfo(LogLevel.Trace, LoggerName, TestMessage);
logger.Log(logEvent);
Assert.That(target.Logs.Count, Is.EqualTo(1));
var output = target.Logs[0];
Assert.That(output, Does.Contain("\"machinename\":\""));
Assert.That(output, Does.Not.Contain("${machinename}"));
}
public void VarInPropertyIsRendered()
{
var layout = new JsonWithPropertiesLayout();
layout.Properties.Add(new StructuredLoggingProperty("key1", "${var:foo}"));
var target = new MemoryTarget
{
Name = Guid.NewGuid().ToString(),
Layout = layout
};
var fooValue = Guid.NewGuid().ToString();
SimpleConfigurator.ConfigureForTargetLogging(target, LogLevel.Trace);
LogManager.Configuration.Variables.Add("foo", fooValue);
TimeSource.Current = new FakeTimeSource();
var logger = LogManager.GetCurrentClassLogger();
var logEvent = new LogEventInfo(LogLevel.Trace, LoggerName, TestMessage);
logger.Log(logEvent);
Assert.That(target.Logs.Count, Is.EqualTo(1));
var output = target.Logs[0];
Assert.That(output, Does.Contain(fooValue));
Assert.That(output, Does.Contain($"\"key1\":\"{fooValue}\""));
Assert.That(output, Does.Not.Contain("var:"));
Assert.That(output, Does.Not.Contain("${:"));
Assert.That(output, Does.Not.Contain("foo"));
}
void MvcApplication_BeginRequest(object sender, EventArgs e)
{
try
{
if (HttpContext.Current.Request.QueryString["vm"] != null && Convert.ToInt32(HttpContext.Current.Request.QueryString["vm"]) == 10)
{
MemoryTarget _logTarget = null;
_loggerName = Guid.NewGuid().ToString().Replace("-", string.Empty);
HttpContext.Current.Items.Add("LoggerName", _loggerName);
_logTarget = new MemoryTarget();
_logTarget.Name = _loggerName.ToString();
LoggingRule rule = new LoggingRule(_loggerName, _logTarget);
rule.EnableLoggingForLevel(LogLevel.Debug);
rule.EnableLoggingForLevel(LogLevel.Trace);
rule.EnableLoggingForLevel(LogLevel.Info);
rule.EnableLoggingForLevel(LogLevel.Warn);
rule.EnableLoggingForLevel(LogLevel.Error);
rule.EnableLoggingForLevel(LogLevel.Fatal);
LogManager.Configuration.LoggingRules.Add(rule);
LogManager.Configuration.Reload();
}
}
catch (Exception ex)
{
LogEventInfo info = new LogEventInfo(LogLevel.Error, ECMSSettings.DEFAULT_LOGGER, ex.ToString());
ECMSLogger.Instance.Log(info);
}
}
void MvcApplication_EndRequest(object sender, EventArgs e)
{
try
{
var loggerName = Convert.ToString(HttpContext.Current.Items["LoggerName"]);
if (!string.IsNullOrEmpty(loggerName))
{
var rule = LogManager.Configuration.LoggingRules.Where(x => x.NameMatches(loggerName)).FirstOrDefault();
if (rule != null && rule.Targets.Count > 0)
{
MemoryTarget target = rule.Targets.Where(x => x.Name == _loggerName).FirstOrDefault() as MemoryTarget;
if (target != null)
{
target.Dispose();
LogManager.Configuration.LoggingRules.Remove(rule);
LogManager.Configuration.RemoveTarget(target.Name);
LogManager.Configuration.Reload();
}
}
}
}
catch (Exception ex)
{
LogEventInfo info = new LogEventInfo(LogLevel.Error, ECMSSettings.DEFAULT_LOGGER, ex.ToString());
ECMSLogger.Instance.Log(info);
}
}
public void MemoryTarget_EmptyMessageTest()
{
ILogger logger = LogManager.GetCurrentClassLogger();
var memoryTarget = new MemoryTarget
{
Layout = "${level} ${message}"
};
SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, LogLevel.Trace);
logger.Trace("TTT");
logger.Debug(String.Empty);
logger.Info("III");
logger.Warn("");
logger.Error("EEE");
LogManager.Configuration = null;
Assert.True(memoryTarget.Logs.Count() == 5);
Assert.True(memoryTarget.Logs[0] == "Trace TTT");
Assert.True(memoryTarget.Logs[1] == "Debug ");
Assert.True(memoryTarget.Logs[2] == "Info III");
Assert.True(memoryTarget.Logs[3] == "Warn ");
Assert.True(memoryTarget.Logs[4] == "Error EEE");
}
private static void AssertSingleMessage(MemoryTarget memoryTarget, string expectedMessage)
{
Assert.Equal(1, memoryTarget.Logs.Count);
var log = memoryTarget.Logs.Single();
Assert.Equal(expectedMessage, log);
}
protected static void TestLogger(Action <ILogger, Func <List <string> > > act)
{
// These layout renderers need to registered statically as ultimately ConfigurationItemFactory.Default is called in the call stack.
LayoutRenderer.Register <ApmTraceIdLayoutRenderer>(ApmTraceIdLayoutRenderer.Name); //generic
LayoutRenderer.Register <ApmTransactionIdLayoutRenderer>(ApmTransactionIdLayoutRenderer.Name); //generic
var logFactory = new LogFactory();
var logConfig = new Config.LoggingConfiguration(logFactory);
var ecsLayout = new EcsLayout();
ecsLayout.ExcludeProperties.Add("NotX");
var memoryTarget = new MemoryTarget {
Layout = ecsLayout, OptimizeBufferReuse = true
};
logConfig.AddRule(LogLevel.Trace, LogLevel.Fatal, memoryTarget);
logConfig.DefaultCultureInfo = System.Globalization.CultureInfo.InvariantCulture;
logFactory.Configuration = logConfig;
List <string> GetLogEvents() => memoryTarget.Logs.ToList();
var logger = logFactory.GetCurrentClassLogger();
act(logger, GetLogEvents);
}
private async Task <IList <string> > RunCommand(string cmd, Dictionary <string, string> placeHolders = null)
{
var config = new LoggingConfiguration();
var memoryTarget = new MemoryTarget()
{
Layout = @"${message}${onexception:${exception:format=tostring}}"
};
config.AddTarget("logger", memoryTarget);
var consoleRule = new LoggingRule("*", LogLevel.Debug, memoryTarget);
config.LoggingRules.Add(consoleRule);
var args = cmd.Split(' ')
.Select(s => placeHolders?.ContainsKey(s) == true ? placeHolders[s] : s)
.ToArray();
using (var factory = new LogFactory(config))
{
var logger = factory.GetLogger("logger");
var succeed = await new Program(logger).Process(args);
Assert.True(succeed, string.Join(Environment.NewLine, memoryTarget.Logs));
}
return(memoryTarget.Logs);
}
public void UsingLoggingAspectWithNLogShouldUseNlogger()
{
// arrange - setup nlog
LoggingConfiguration config = new LoggingConfiguration();
MemoryTarget memoryTarget = new MemoryTarget {
Layout = @"${message}"
};
config.AddTarget("memory", memoryTarget);
LoggingRule rule = new LoggingRule("*", LogLevel.Debug, memoryTarget);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
Mock <IConfigurationProvider> mock = new Mock <IConfigurationProvider>();
mock.Setup(provider => provider.ShouldLog(It.IsAny <LogAttribute>())).Returns(true);
LogAttribute.ConfigurationProvider = mock.Object;
// arrange - setup logger
LogAttribute.Logger = new NLogLogger("memory");
// act
Person person = new Person {
Name = "test", Balance = 0.0d
};
person.Should().NotBeNull();
// assert
memoryTarget.Logs.Count.Should().Be(9, "because we called the logging 9 times");
}
public LogsModuleViewModel(ApplicationNavigationPartViewModel application_navigation_part,
ToolsNavigationPartViewModel tools_navigation_part)
{
ApplicationNavigationPart = application_navigation_part;
ToolsNavigationPart = tools_navigation_part;
log_target = LogManager.Configuration.AllTargets.OfType <MemoryTarget>().FirstOrDefault();
}
public LogTests()
{
_configuration = new LoggingConfiguration();
_memoryTarget = new MemoryTarget {
Name = "mem", Layout = "${message}"
};
_configuration.AddTarget(_memoryTarget);
}
public static void SetupLogging(string username)
{
Username = username;
var config = LogManager.Configuration;
if (config == null)
{
config = new LoggingConfiguration();
}
var loggername = "asyncslack";
if (config.FindTargetByName(loggername) != null)
{
config.RemoveTarget(loggername);
}
var slackTarget = new SlackTarget
{
Layout = "${message} ${exception:format=tostring}",
WebHookUrl = "https://hooks.slack.com/services/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",
Channel = "#sovnd-client-logs",
Username = username,
Compact = true
};
AsyncTargetWrapper asyncSlack = new AsyncTargetWrapper(slackTarget);
config.AddTarget(loggername, asyncSlack);
var slackTargetRules = new LoggingRule("*", LogLevel.Error, asyncSlack);
config.LoggingRules.Add(slackTargetRules);
loggername = "asyncmem";
if (memoryTarget == null)
{
memoryTarget = new MemoryTarget {
Layout = "${message} ${exception:format=tostring}"
};
config.AddTarget(loggername, memoryTarget);
var memTargetRules = new LoggingRule("*", LogLevel.Trace, memoryTarget);
config.LoggingRules.Add(memTargetRules);
if (config.FindTargetByName(loggername) != null)
{
config.RemoveTarget(loggername);
}
}
LogManager.Configuration = config;
BugSenseHandler.Instance.UserIdentifier = username;
var ver = Assembly.GetExecutingAssembly().GetName().Version.ToString();
LogTo.Error("SOVND Ver {0} running as {1}", ver, username);
}
static ProfilerEvent RunProfiler(Action <Profiler> thunk)
{
var target = new MemoryTarget(null);
var pro = Profiler.ForLogger(Logger.Create(target));
thunk(pro);
return((ProfilerEvent)target.Events[0]);
}
/// <summary>
/// Get a target to allow assertions to be made against the Nlog
/// </summary>
public static MemoryTarget GetMemoryTarget(this Logger log, string layout, LogLevel logLevel)
{
MemoryTarget memoryTarget = new MemoryTarget {
Layout = layout
};
SimpleConfigurator.ConfigureForTargetLogging(memoryTarget, logLevel);
return(memoryTarget);
}
public void Setup()
{
_target = new MemoryTarget {
Layout = "${message}"
};
SimpleConfigurator.ConfigureForTargetLogging(_target, LogLevel.Trace);
LogWriter.SetFactory(new NLogWriterFactory());
_target.Logs.Clear();
}
public void SetUp()
{
log = new MemoryTarget();
SimpleConfigurator.ConfigureForTargetLogging(log);
log.Layout = "${longdate} ${uppercase:${level}} ${message} ${exception:format=tostring}";
// Uncomment the next line if tests fails due to UnauthorizedAccessException
// Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
File.Delete("text.txt.out");
}
public void Should_preserve_correct_callsite_information()
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var target = new MemoryTarget();
var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper(target)
{
TimeToSleepBetweenBatches = 0
};
config.AddTarget("target", wrapper);
// Step 3. Set target properties
target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}";
// Step 4. Define rules
var rule = new LoggingRule("*", LogLevel.Debug, wrapper);
config.LoggingRules.Add(rule);
LogManager.Configuration = config;
var factory = new NLogFactory(config);
var logger = factory.Create("MyLoggerName");
WriteLogMessage(logger);
LogManager.Flush();
var logMessage = target.Logs[0];
Assert.Contains("MyLoggerName", logMessage);
// See that LogManager.ReconfigExistingLoggers() is able to upgrade the Logger
target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message}";
LogManager.ReconfigExistingLoggers();
WriteLogMessage(logger);
LogManager.Flush();
logMessage = target.Logs[1];
Assert.Contains("CallSiteTests.WriteLogMessage", logMessage);
// See that LogManager.ReconfigExistingLoggers() is able to upgrade the Logger
target.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${callsite} ${message} ThreadId=${threadid}";
LogManager.ReconfigExistingLoggers();
WriteLogMessage(logger);
LogManager.Flush();
logMessage = target.Logs[2];
Assert.Contains("ThreadId=" + Thread.CurrentThread.ManagedThreadId.ToString(), logMessage);
// See that interface logging also works (Improve support for Microsoft.Extension.Logging.ILogger replacement)
INLogLogger ilogger = logger;
WriteLogMessage(ilogger);
LogManager.Flush();
logMessage = target.Logs[3];
Assert.Contains("CallSiteTests.WriteLogMessage", logMessage);
}
private static LoggingConfiguration CreateConfigWithMemoryTarget(out MemoryTarget memoryTarget, string levelMessage = "${level}|${message}")
{
var config = new LoggingConfiguration();
memoryTarget = new MemoryTarget {
Layout = levelMessage
};
config.AddRuleForAllLevels(memoryTarget);
return(config);
}
public void SetupTests()
{
ConfigurationItemFactory.Default.Layouts.RegisterDefinition("flattenedjsonlayout", typeof(FlattenedJsonLayout));
_parameter1 = "With Extra String!!";
_parameter2 = null;
_target = new MemoryTarget();
_target.Layout = new FlattenedJsonLayout();
}
public void SetUp()
{
var cfg = new LoggingConfiguration();
_logTarget = new MemoryTarget("mem")
{
Layout = new SimpleLayout("${Logger}|${Level}|${Message}|${exception}|${all-event-properties}")
};
cfg.AddTarget(_logTarget);
cfg.AddRule(global::NLog.LogLevel.Trace, global::NLog.LogLevel.Error, _logTarget);
LogManager.Configuration = cfg;
}
