/// <summary>
/// Renders the layout for the specified logging event by invoking layout renderers
/// that make up the event.
/// </summary>
/// <param name="logEvent">The logging event.</param>
/// <returns>The rendered layout.</returns>
protected override string GetFormattedMessage(LogEventInfo logEvent)
{
if (IsFixedText)
{
return(this.fixedText);
}
string cachedValue;
if (logEvent.TryGetCachedLayoutValue(this, out cachedValue))
{
return(cachedValue);
}
int initialSize = this.maxRenderedLength;
if (initialSize > MaxInitialRenderBufferLength)
{
initialSize = MaxInitialRenderBufferLength;
}
var builder = new StringBuilder(initialSize);
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.Render(builder, logEvent);
}
catch (Exception exception)
{
if (exception.MustBeRethrown())
{
throw;
}
if (InternalLogger.IsWarnEnabled)
{
InternalLogger.Warn("Exception in {0}.Append(): {1}.", renderer.GetType().FullName, exception);
}
}
}
if (builder.Length > this.maxRenderedLength)
{
this.maxRenderedLength = builder.Length;
}
string value = builder.ToString();
logEvent.AddCachedLayoutValue(this, value);
return(value);
}
private static LayoutRenderer ApplyWrappers(ConfigurationItemFactory configurationItemFactory, LayoutRenderer lr, List <LayoutRenderer> orderedWrappers)
{
for (int i = orderedWrappers.Count - 1; i >= 0; --i)
{
var newRenderer = (WrapperLayoutRendererBase)orderedWrappers[i];
InternalLogger.Trace("Wrapping {0} with {1}", lr.GetType().Name, newRenderer.GetType().Name);
if (CanBeConvertedToLiteral(lr))
{
lr = ConvertToLiteral(lr);
}
newRenderer.Inner = new SimpleLayout(new[] { lr }, string.Empty, configurationItemFactory);
lr = newRenderer;
}
return(lr);
}
private static void SetDefaultPropertyValue(ConfigurationItemFactory configurationItemFactory, LayoutRenderer layoutRenderer, string value, bool?throwConfigExceptions)
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
if (PropertyHelper.TryGetPropertyInfo(layoutRenderer, string.Empty, out var propertyInfo))
{
PropertyHelper.SetPropertyFromString(layoutRenderer, propertyInfo.Name, value, configurationItemFactory);
}
else
{
var configException = new NLogConfigurationException($"{layoutRenderer.GetType()} has no default property to assign value {value}");
if (throwConfigExceptions ?? configException.MustBeRethrown())
{
throw configException;
}
}
}
private static void SetDefaultPropertyValue(ConfigurationItemFactory configurationItemFactory, LayoutRenderer layoutRenderer, string parameterName)
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo propertyInfo;
if (PropertyHelper.TryGetPropertyInfo(layoutRenderer, string.Empty, out propertyInfo))
{
if (typeof(SimpleLayout) == propertyInfo.PropertyType)
{
propertyInfo.SetValue(layoutRenderer, new SimpleLayout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(layoutRenderer, propertyInfo.Name, value, configurationItemFactory);
}
}
else
{
InternalLogger.Warn("{0} has no default property", layoutRenderer.GetType().FullName);
}
}
private static void SetDefaultPropertyValue(ConfigurationItemFactory configurationItemFactory, LayoutRenderer layoutRenderer, string value)
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
if (PropertyHelper.TryGetPropertyInfo(layoutRenderer, string.Empty, out var propertyInfo))
{
PropertyHelper.SetPropertyFromString(layoutRenderer, propertyInfo.Name, value, configurationItemFactory);
}
else
{
// TODO NLog 5.0 Should throw exception when invalid configuration (Check throwConfigExceptions)
InternalLogger.Warn("{0} has no default property to assign value {1}", layoutRenderer.GetType(), value);
}
}
/// <summary>
/// Initializes the layout.
/// </summary>
protected override void InitializeLayout()
{
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.Initialize(LoggingConfiguration);
}
catch (Exception exception)
{
//also check IsErrorEnabled, otherwise 'MustBeRethrown' writes it to Error
//check for performance
if (InternalLogger.IsWarnEnabled || InternalLogger.IsErrorEnabled)
{
InternalLogger.Warn(exception, "Exception in '{0}.InitializeLayout()'", renderer.GetType().FullName);
}
if (exception.MustBeRethrown())
{
throw;
}
}
}
base.InitializeLayout();
}
private void RenderAllRenderers(LogEventInfo logEvent, StringBuilder target)
{
//Memory profiling pointed out that using a foreach-loop was allocating
//an Enumerator. Switching to a for-loop avoids the memory allocation.
for (int i = 0; i < this.Renderers.Count; i++)
{
LayoutRenderer renderer = this.Renderers[i];
try
{
renderer.RenderAppendBuilder(logEvent, target);
}
catch (Exception exception)
{
//also check IsErrorEnabled, otherwise 'MustBeRethrown' writes it to Error
//check for performance
if (InternalLogger.IsWarnEnabled || InternalLogger.IsErrorEnabled)
{
InternalLogger.Warn(exception, "Exception in '{0}.Append()'", renderer.GetType().FullName);
}
if (exception.MustBeRethrown())
{
throw;
}
}
}
}
private static LayoutRenderer ParseLayoutRenderer(ConfigurationItemFactory configurationItemFactory, Tokenizer sr)
{
int ch = sr.Read();
Debug.Assert(ch == '{', "'{' expected in layout specification");
string name = ParseLayoutRendererName(sr);
LayoutRenderer lr = configurationItemFactory.LayoutRenderers.CreateInstance(name);
var wrappers = new Dictionary <Type, LayoutRenderer>();
var orderedWrappers = new List <LayoutRenderer>();
ch = sr.Read();
while (ch != -1 && ch != '}')
{
string parameterName = ParseParameterName(sr).Trim();
if (sr.Peek() == '=')
{
sr.Read(); // skip the '='
PropertyInfo pi;
LayoutRenderer parameterTarget = lr;
if (!PropertyHelper.TryGetPropertyInfo(lr, parameterName, out pi))
{
Type wrapperType;
if (configurationItemFactory.AmbientProperties.TryGetDefinition(parameterName, out wrapperType))
{
LayoutRenderer wrapperRenderer;
if (!wrappers.TryGetValue(wrapperType, out wrapperRenderer))
{
wrapperRenderer = configurationItemFactory.AmbientProperties.CreateInstance(parameterName);
wrappers[wrapperType] = wrapperRenderer;
orderedWrappers.Add(wrapperRenderer);
}
if (!PropertyHelper.TryGetPropertyInfo(wrapperRenderer, parameterName, out pi))
{
pi = null;
}
else
{
parameterTarget = wrapperRenderer;
}
}
}
if (pi == null)
{
ParseParameterValue(sr);
}
else
{
if (typeof(Layout).IsAssignableFrom(pi.PropertyType))
{
var nestedLayout = new SimpleLayout();
string txt;
LayoutRenderer[] renderers = CompileLayout(configurationItemFactory, sr, true, out txt);
nestedLayout.SetRenderers(renderers, txt);
pi.SetValue(parameterTarget, nestedLayout, null);
}
else
{
string value = ParseParameterValue(sr);
PropertyHelper.SetPropertyFromString(parameterTarget, parameterName, value);
}
}
}
else
{
// what we've just read is not a parameterName, but a value
// assign it to a default property (denoted by empty string)
PropertyInfo pi;
if (PropertyHelper.TryGetPropertyInfo(lr, string.Empty, out pi))
{
if (typeof(SimpleLayout) == pi.PropertyType)
{
pi.SetValue(lr, new SimpleLayout(parameterName), null);
}
else
{
string value = parameterName;
PropertyHelper.SetPropertyFromString(lr, pi.Name, value);
}
}
else
{
InternalLogger.Warn("{0} has no default property", lr.GetType().FullName);
}
}
ch = sr.Read();
}
lr = ApplyWrappers(configurationItemFactory, lr, orderedWrappers);
return(lr);
}
