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); } }