COLDBOX-1400 #resolve

root appender could be called before initialization of logbox in loading

Author: lmajano

system/logging/LogBox.cfc

@@ -166,6 +166,19 @@ component accessors="true" {
 		variables.appenderRegistry = structNew();
 		variables.loggerRegistry   = structNew();
 
+		// Sentinel ROOT logger: prevents KeyNotFoundException when appender
+		// constructors (e.g. custom Sentry/ELK appenders) pull a logger via
+		// DI/interceptors during registerAppender() mid-configure.
+		// levelMax=5 (OFF) so any log calls during the configure window are silent.
+		var sentinelRoot = new coldbox.system.logging.Logger(
+			category           : "ROOT",
+			levelMin           : 0,
+			levelMax           : 5,
+			appenders          : {},
+			serializeExtraInfo : false
+		);
+		variables.loggerRegistry[ "ROOT" ] = sentinelRoot;
+
 		// Get appender definitions
 		var appenders = variables.config.getAllAppenders();
 
@@ -176,7 +189,7 @@ component accessors="true" {
 
 		// Get Root def
 		var rootConfig = variables.config.getRoot();
-		// Create Root Logger
+		// Create Root Logger replacing the sentinel, now that appenders are populated
 		var args       = {
 			category           : "ROOT",
 			levelMin           : rootConfig.levelMin,
@@ -185,8 +198,8 @@ component accessors="true" {
 			serializeExtraInfo : variables.config.getSerializeExtraInfo()
 		};
 
-		// Save in Registry
-		variables.loggerRegistry = { "ROOT" : new coldbox.system.logging.Logger( argumentCollection = args ) };
+		// Save in Registry, replacing the sentinel
+		variables.loggerRegistry[ "ROOT" ] = new coldbox.system.logging.Logger( argumentCollection = args );
 	}
 
 	/**
@@ -215,6 +228,18 @@ component accessors="true" {
 	 * @return coldbox.system.logging.Logger
 	 */
 	function getRootLogger(){
+		// Defensive fallback: if registry is transiently empty (edge-case),
+		// return a silent transient Logger so callers don't crash.
+		// Constructed directly via `new` to avoid DI/logBox recursion.
+		if ( !structKeyExists( variables.loggerRegistry, "ROOT" ) ) {
+			return new coldbox.system.logging.Logger(
+				category           : "ROOT",
+				levelMin           : 0,
+				levelMax           : 5,
+				appenders          : {},
+				serializeExtraInfo : false
+			);
+		}
 		return variables.loggerRegistry[ "ROOT" ];
 	}
 

tests/specs/logging/LogBoxEdgeCases.cfc

@@ -19,6 +19,83 @@ component extends="testbox.system.BaseSpec" {
 					} );
 				} );
 			} );
+
+			story( "I want to verify LogBox survives appender constructor triggering logger access during configure", function(){
+				given( "A custom appender whose onRegistration() calls getRootLogger()", function(){
+					then( "it should construct without KeyNotFoundException", function(){
+						var config = {
+							appenders : {
+								sentinelAppender : {
+									class    : "tests.specs.logging.appenders.SentinelTestAppender",
+									properties : {},
+									levelMin : 0,
+									levelMax : 4
+								}
+							},
+							root : { levelMax: "INFO", appenders : "sentinelAppender" }
+						};
+
+						// This constructor calls configure() which triggers registerAppender,
+						// which chains onRegistration() which calls getRootLogger().
+						// Without the sentinel fix, this throws KeyNotFoundException.
+						var logBox = new coldbox.system.logging.LogBox( config );
+
+						// Verify getRootLogger returns a real Logger after construction
+						var root = logBox.getRootLogger();
+						expect( root ).toBeComponent();
+						expect( root.getCategory() ).toBe( "ROOT" );
+
+						// Verify the sentinel appender captured a non-null root logger
+						var appender = logBox.getAppenderRegistry()[ "sentinelAppender" ];
+						expect( appender.getCapturedRootLogger() ).toBeComponent();
+					} );
+				} );
+			} );
+
+			story( "I want to re-configure LogBox and verify getRootLogger never returns empty", function(){
+				given( "An already-constructed LogBox", function(){
+					then( "calling configure() again should not break getRootLogger()", function(){
+						var config = {
+							appenders : {
+								consoleAppender : {
+									class    : "ConsoleAppender",
+									properties : {},
+									levelMin : 0,
+									levelMax : 4
+								}
+							},
+							root : { levelMax: "INFO", appenders : "consoleAppender" }
+						};
+
+						var logBox = new coldbox.system.logging.LogBox( config );
+						expect( logBox.getRootLogger() ).toBeComponent();
+
+						// Re-configure: this resets registries and re-runs the appender loop.
+						// The sentinel root must be in place during the entire re-configure.
+						logBox.configure( config );
+
+						expect( logBox.getRootLogger() ).toBeComponent();
+						expect( logBox.getRootLogger().getCategory() ).toBe( "ROOT" );
+					} );
+				} );
+			} );
+
+			story( "I want getRootLogger() to have a defensive fallback when registry is empty", function(){
+				given( "A LogBox with the ROOT key manually removed from its loggerRegistry", function(){
+					then( "it should return a transient Logger instead of throwing", function(){
+						var config = new coldbox.system.logging.config.LogBoxConfig();
+						var logBox = new coldbox.system.logging.LogBox( config );
+
+						// Simulate a corrupt/empty registry state (extreme edge case)
+						structDelete( logBox.getLoggerRegistry(), "ROOT" );
+
+						// Should return a Logger, not throw KeyNotFoundException
+						var root = logBox.getRootLogger();
+						expect( root ).toBeComponent();
+						expect( root.getCategory() ).toBe( "ROOT" );
+					} );
+				} );
+			} );
 		} );
 	}
 

tests/specs/logging/appenders/SentinelTestAppender.cfc

@@ -0,0 +1,33 @@
+/**
+ * Test appender for verifying the sentinel ROOT logger fix.
+ * Overrides onRegistration() to call getRootLogger() — this simulates
+ * the race condition where an appender triggers logger access during
+ * LogBox.configure()'s registerAppender loop, before ROOT has been
+ * fully re-inserted into the loggerRegistry.
+ *
+ * When the sentinel is in place, getRootLogger() returns the sentinel.
+ * Without the fix, this throws KeyNotFoundException: ROOT.
+ */
+component extends="coldbox.system.logging.AbstractAppender" {
+
+	/**
+	 * Override onRegistration to access the root logger mid-configure.
+	 * This reproduces the crash pattern: custom appenders (like Sentry)
+	 * that pull DI/interceptors in their constructor, which eventually
+	 * calls getRootLogger() while configure() is still mid-loop.
+	 */
+	function onRegistration(){
+		// Access the root logger via the LogBox reference (set by registerAppender chain)
+		// This would throw KeyNotFoundException without the sentinel fix
+		variables.rootLoggerCheck = getLogBox().getRootLogger();
+		return this;
+	}
+
+	/**
+	 * Expose the captured root logger for assertions.
+	 */
+	function getCapturedRootLogger(){
+		return variables.rootLoggerCheck;
+	}
+
+}