internal bool CreateChild(
ILogger root,
IReloadableLogger parent,
ILogger cachedParent,
Func <ILogger, ILogger> configureChild,
out ILogger child,
out ILogger newRoot,
out ILogger newCached,
out bool frozen)
{
if (_frozen)
{
var(logger, _) = UpdateForCaller(root, cachedParent, parent, out newRoot, out newCached, out frozen);
child = configureChild(logger);
return(true); // Always an update, since the caller has not observed that the reloadable logger is frozen.
}
// No synchronization, here - a lot of loggers are created and thrown away again without ever being used,
// so we just return a lazy wrapper.
child = new CachingReloadableLogger(this, root, parent, configureChild);
newRoot = default;
newCached = default;
frozen = default;
return(false);
}
public CachingReloadableLogger(ReloadableLogger reloadableLogger, ILogger root, IReloadableLogger parent, Func <ILogger, ILogger> configure)
{
_reloadableLogger = reloadableLogger;
_parent = parent;
_configure = configure;
_root = root;
_cached = null;
_frozen = false;
}
(ILogger, bool) UpdateForCaller(ILogger root, ILogger cached, IReloadableLogger caller, out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (cached != null && root == _logger)
{
newRoot = default;
newCached = default;
frozen = _frozen;
return(cached, frozen); // If we're frozen, then the caller hasn't observed this yet and should update.
}
newRoot = _logger;
newCached = caller.ReloadLogger();
frozen = false;
return(newCached, true);
}
internal bool InvokeWrite(ILogger root, ILogger cached, IReloadableLogger caller, LogEvent logEvent, out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(logEvent);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(logEvent);
return(update);
}
}
internal bool InvokeIsEnabled(ILogger root, ILogger cached, IReloadableLogger caller, LogEventLevel level, out bool isEnabled, out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
isEnabled = logger.IsEnabled(level);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
isEnabled = logger.IsEnabled(level);
return(update);
}
}
internal bool InvokeWrite(ILogger root, ILogger cached, IReloadableLogger caller, LogEventLevel level, Exception exception, string messageTemplate,
out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(level, exception, messageTemplate);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(level, exception, messageTemplate);
return(update);
}
}
internal bool InvokeWrite <T0, T1, T2>(ILogger root, ILogger cached, IReloadableLogger caller, LogEventLevel level, string messageTemplate,
T0 propertyValue0, T1 propertyValue1, T2 propertyValue2,
out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(level, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
logger.Write(level, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
return(update);
}
}
internal bool InvokeBindProperty(ILogger root, ILogger cached, IReloadableLogger caller, string propertyName,
object propertyValue, bool destructureObjects, out LogEventProperty property,
out bool canBind, out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
canBind = logger.BindProperty(propertyName, propertyValue, destructureObjects, out property);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
canBind = logger.BindProperty(propertyName, propertyValue, destructureObjects, out property);
return(update);
}
}
internal bool InvokeBindMessageTemplate(ILogger root, ILogger cached, IReloadableLogger caller, string messageTemplate,
object[] propertyValues, out MessageTemplate parsedTemplate, out IEnumerable <LogEventProperty> boundProperties,
out bool canBind, out ILogger newRoot, out ILogger newCached, out bool frozen)
{
if (_frozen)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
canBind = logger.BindMessageTemplate(messageTemplate, propertyValues, out parsedTemplate, out boundProperties);
return(update);
}
lock (_sync)
{
var(logger, update) = UpdateForCaller(root, cached, caller, out newRoot, out newCached, out frozen);
canBind = logger.BindMessageTemplate(messageTemplate, propertyValues, out parsedTemplate, out boundProperties);
return(update);
}
}
