src/NLog/Targets/Target.cs (1)

Line range hint 433-458: Consider consolidating error handling in catch blocks.

The error handling in both catch blocks is identical. Consider extracting the common error handling logic into a private method to improve maintainability and ensure consistent behavior.

 internal void Initialize(LoggingConfiguration configuration)
 {
     lock (SyncRoot)
     {
         LoggingConfiguration = configuration;

         if (!IsInitialized)
         {
             try
             {
                 _scannedForLayouts = false;

                 PropertyHelper.CheckRequiredParameters(ConfigurationItemFactory.Default, this);

                 InitializeTarget();
                 _initializeException = null;
                 if (!_scannedForLayouts)
                 {
                     InternalLogger.Debug("{0}: InitializeTarget is done but not scanned For Layouts", this);
                     //this is critical, as we need the layouts. So if base.InitializeTarget() isn't called, we fix the layouts here.
                     FindAllLayouts();
                 }
             }
+            catch (Exception exception) when (exception is NLogDependencyResolveException || true)
+            {
+                HandleInitializationError(exception);
+                if (ExceptionMustBeRethrown(exception))
+                    throw;
+
+                if (!(exception is NLogDependencyResolveException))
+                {
+                    var logFactory = LoggingConfiguration?.LogFactory ?? LogManager.LogFactory;
+                    if ((logFactory.ThrowConfigExceptions ?? logFactory.ThrowExceptions))
+                    {
+                        throw new NLogConfigurationException($"Error during initialization of target {this}", exception);
+                    }
+                }
+            }
-            catch (NLogDependencyResolveException exception)
-            {
-                // Target is now in disabled state, and cannot be used for writing LogEvents
-                _initializeException = exception;
-                _scannedForLayouts = false;
-                if (ExceptionMustBeRethrown(exception))
-                    throw;
-            }
-            catch (Exception exception)
-            {
-                // Target is now in disabled state, and cannot be used for writing LogEvents
-                _initializeException = exception;
-                _scannedForLayouts = false;
-                if (ExceptionMustBeRethrown(exception))
-                    throw;
-
-                var logFactory = LoggingConfiguration?.LogFactory ?? LogManager.LogFactory;
-                if ((logFactory.ThrowConfigExceptions ?? logFactory.ThrowExceptions))
-                {
-                    throw new NLogConfigurationException($"Error during initialization of target {this}", exception);
-                }
-            }
             finally
             {
                 _isInitialized = true;  // Only one attempt, must Close to retry
             }
         }
     }
 }

+private void HandleInitializationError(Exception exception)
+{
+    // Target is now in disabled state, and cannot be used for writing LogEvents
+    _initializeException = exception;
+    _scannedForLayouts = false;
+}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

tests/NLog.UnitTests/LayoutRenderers/ScopeNestedTests.cs (1)

398-398: LGTM! Consider improving test reliability.

The changes make the timing assertions more lenient by lowering the minimum bounds, which helps reduce test flakiness. However, using Thread.Sleep for timing-based tests can be unreliable.

Consider using a more precise timing mechanism:

1. Replace Thread.Sleep with a stopwatch-based approach
2. Use Task.Delay for more precise delays
3. Mock the timing system for deterministic tests

Example implementation:

- System.Threading.Thread.Sleep(10);
+ await Task.Delay(10);  // More precise than Thread.Sleep

Or better yet:

private class TestClock : ISystemClock
{
    private long _ticks;
    
    public void Advance(TimeSpan duration)
    {
        _ticks += duration.Ticks;
    }
    
    public DateTime UtcNow => new DateTime(_ticks);
}

[Fact]
public async Task ScopeNestedTimingTest()
{
    var clock = new TestClock();
    // ... test setup ...
    
    clock.Advance(TimeSpan.FromMilliseconds(10));  // Precise control over time
    // ... assertions ...
}

Also applies to: 406-406, 414-414, 422-422

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro