/// <summary>
/// Gets the optional boolean attribute value.
/// </summary>
/// <param name="element"></param>
/// <param name="attributeName">Name of the attribute.</param>
/// <param name="defaultValue">Default value to return if the attribute is not found or if there is a parse error</param>
/// <returns>Boolean attribute value or default.</returns>
public static bool GetOptionalBooleanValue(this ILoggingConfigurationElement element, string attributeName,
bool defaultValue)
{
string value = element.GetOptionalValue(attributeName, null);
if (string.IsNullOrEmpty(value))
{
return(defaultValue);
}
try
{
return(Convert.ToBoolean(value.Trim(), CultureInfo.InvariantCulture));
}
catch (Exception exception)
{
var configException = new NLogConfigurationException(exception, $"'{attributeName}' hasn't a valid boolean value '{value}'. {defaultValue} will be used");
if (configException.MustBeRethrown())
{
throw configException;
}
InternalLogger.Error(exception, configException.Message);
return(defaultValue);
}
}
/// <summary>
/// Parse {NLog} xml element.
/// </summary>
/// <param name="nlogElement"></param>
/// <param name="filePath">path to config file.</param>
/// <param name="autoReloadDefault">The default value for the autoReload option.</param>
private void ParseNLogElement(ILoggingConfigurationElement nlogElement, [CanBeNull] string filePath, bool autoReloadDefault)
{
InternalLogger.Trace("ParseNLogElement");
nlogElement.AssertName("nlog");
bool autoReload = nlogElement.GetOptionalBooleanValue("autoReload", autoReloadDefault);
try
{
string baseDirectory = null;
if (!string.IsNullOrEmpty(filePath))
{
_fileMustAutoReloadLookup[GetFileLookupKey(filePath)] = autoReload;
_currentFilePath.Push(filePath);
baseDirectory = Path.GetDirectoryName(filePath);
}
base.LoadConfig(nlogElement, baseDirectory);
}
finally
{
if (!string.IsNullOrEmpty(filePath))
{
_currentFilePath.Pop();
}
}
}
private void ParseIncludeElement(ILoggingConfigurationElement includeElement, string baseDirectory, bool autoReloadDefault)
{
includeElement.AssertName("include");
string newFileName = includeElement.GetRequiredValue("file", "nlog");
var ignoreErrors = includeElement.GetOptionalBooleanValue("ignoreErrors", false);
try
{
newFileName = ExpandSimpleVariables(newFileName);
newFileName = SimpleLayout.Evaluate(newFileName);
var fullNewFileName = newFileName;
if (baseDirectory != null)
{
fullNewFileName = Path.Combine(baseDirectory, newFileName);
}
if (File.Exists(fullNewFileName))
{
InternalLogger.Debug("Including file '{0}'", fullNewFileName);
ConfigureFromFile(fullNewFileName, autoReloadDefault);
}
else
{
//is mask?
if (newFileName.Contains("*"))
{
ConfigureFromFilesByMask(baseDirectory, newFileName, autoReloadDefault);
}
else
{
if (ignoreErrors)
{
//quick stop for performances
InternalLogger.Debug("Skipping included file '{0}' as it can't be found", fullNewFileName);
return;
}
throw new FileNotFoundException("Included file not found: " + fullNewFileName);
}
}
}
catch (Exception exception)
{
if (exception.MustBeRethrownImmediately())
{
throw;
}
var configurationException = new NLogConfigurationException(exception, "Error when including '{0}'.", newFileName);
InternalLogger.Error(exception, configurationException.Message);
if (!ignoreErrors)
{
throw configurationException;
}
}
}
public static void AssertName(this ILoggingConfigurationElement section, params string[] allowedNames)
{
foreach (var en in allowedNames)
{
if (section.MatchesName(en))
{
return;
}
}
throw new InvalidOperationException(
$"Assertion failed. Expected element name '{string.Join("|", allowedNames)}', actual: '{section?.Name}'.");
}
/// <summary>
/// Parses a single config section within the NLog-config
/// </summary>
/// <param name="configSection"></param>
/// <returns>Section was recognized</returns>
protected override bool ParseNLogSection(ILoggingConfigurationElement configSection)
{
if (configSection.MatchesName("include"))
{
string filePath = _currentFilePath.Peek();
bool autoLoad = !string.IsNullOrEmpty(filePath) && _fileMustAutoReloadLookup[GetFileLookupKey(filePath)];
ParseIncludeElement(configSection, !string.IsNullOrEmpty(filePath) ? Path.GetDirectoryName(filePath) : null, autoLoad);
return(true);
}
else
{
return(base.ParseNLogSection(configSection));
}
}
public static string GetOptionalValue(this ILoggingConfigurationElement element, string attributeName,
string defaultValue)
{
string value = element.Values
.Where(configItem => string.Equals(configItem.Key, attributeName, StringComparison.OrdinalIgnoreCase))
.Select(configItem => configItem.Value).FirstOrDefault();
if (value == null)
{
return(defaultValue);
}
return(value);
}
public static string GetRequiredValue(this ILoggingConfigurationElement element, string attributeName, string section)
{
string value = element.GetOptionalValue(attributeName, null);
if (value == null)
{
throw new NLogConfigurationException($"Expected {attributeName} on {element.Name} in {section}");
}
if (StringHelpers.IsNullOrWhiteSpace(value))
{
throw new NLogConfigurationException(
$"Expected non-empty {attributeName} on {element.Name} in {section}");
}
return(value);
}
/// <summary>
/// Parse {NLog} xml element.
/// </summary>
/// <param name="nlogElement"></param>
/// <param name="filePath">path to config file.</param>
/// <param name="autoReloadDefault">The default value for the autoReload option.</param>
private void ParseNLogElement(ILoggingConfigurationElement nlogElement, string filePath, bool autoReloadDefault)
{
InternalLogger.Trace("ParseNLogElement");
nlogElement.AssertName("nlog");
bool autoReload = nlogElement.GetOptionalBooleanValue("autoReload", autoReloadDefault);
if (filePath != null)
{
_fileMustAutoReloadLookup[GetFileLookupKey(filePath)] = autoReload;
}
try
{
_currentFilePath.Push(filePath);
base.LoadConfig(nlogElement, Path.GetDirectoryName(filePath));
}
finally
{
_currentFilePath.Pop();
}
}
public static bool MatchesName(this ILoggingConfigurationElement section, string expectedName)
{
return(string.Equals(section?.Name?.Trim(), expectedName, StringComparison.OrdinalIgnoreCase));
}
public static string GetConfigItemTypeAttribute(this ILoggingConfigurationElement element, string sectionNameForRequiredValue = null)
{
var typeAttributeValue = sectionNameForRequiredValue != null?element.GetRequiredValue("type", sectionNameForRequiredValue) : element.GetOptionalValue("type", null);
return(StripOptionalNamespacePrefix(typeAttributeValue)?.Trim());
}
private void ParseIncludeElement(ILoggingConfigurationElement includeElement, string baseDirectory, bool autoReloadDefault)
{
includeElement.AssertName("include");
string newFileName = includeElement.GetRequiredValue("file", "nlog");
var ignoreErrors = includeElement.GetOptionalBooleanValue("ignoreErrors", false);
try
{
newFileName = ExpandSimpleVariables(newFileName);
newFileName = SimpleLayout.Evaluate(newFileName);
var fullNewFileName = newFileName;
if (baseDirectory != null)
{
fullNewFileName = Path.Combine(baseDirectory, newFileName);
}
#if SILVERLIGHT && !WINDOWS_PHONE
newFileName = newFileName.Replace("\\", "/");
if (Application.GetResourceStream(new Uri(fullNewFileName, UriKind.Relative)) != null)
#else
if (File.Exists(fullNewFileName))
#endif
{
InternalLogger.Debug("Including file '{0}'", fullNewFileName);
ConfigureFromFile(fullNewFileName, autoReloadDefault);
}
else
{
//is mask?
if (newFileName.Contains("*"))
{
ConfigureFromFilesByMask(baseDirectory, newFileName, autoReloadDefault);
}
else
{
if (ignoreErrors)
{
//quick stop for performances
InternalLogger.Debug("Skipping included file '{0}' as it can't be found", fullNewFileName);
return;
}
throw new FileNotFoundException("Included file not found: " + fullNewFileName);
}
}
}
catch (Exception exception)
{
InternalLogger.Error(exception, "Error when including '{0}'.", newFileName);
if (ignoreErrors)
{
return;
}
if (exception.MustBeRethrown())
{
throw;
}
throw new NLogConfigurationException("Error when including: " + newFileName, exception);
}
}
