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

104-110: Good allocation win by returning cached boxed booleans

Using ConditionExpression.BoxedTrue/BoxedFalse via static lambdas avoids repeated boxing and the static captures nothing. Nice and targeted fix.

Optional cleanups for consistency/readability:

• Use the same namespace qualifier for both types (either NLog.Conditions.* or Conditions.*) to avoid mixed styles on the same line.
• If you prefer shorter lines, consider a using static import for ConditionExpression and then just return BoxedTrue/BoxedFalse.

Example diff to unify the qualifier (purely cosmetic):

- new ConsoleRowHighlightingRule(Conditions.ConditionMethodExpression.CreateMethodNoParameters("level == LogLevel.Fatal", static (evt) => evt.Level == LogLevel.Fatal ? NLog.Conditions.ConditionExpression.BoxedTrue : NLog.Conditions.ConditionExpression.BoxedFalse), ConsoleOutputColor.Red, ConsoleOutputColor.NoChange),
+ new ConsoleRowHighlightingRule(Conditions.ConditionMethodExpression.CreateMethodNoParameters("level == LogLevel.Fatal", static (evt) => evt.Level == LogLevel.Fatal ? Conditions.ConditionExpression.BoxedTrue : Conditions.ConditionExpression.BoxedFalse), ConsoleOutputColor.Red, ConsoleOutputColor.NoChange),

src/NLog.Benchmarks/Program.cs (1)

11-19: Remove unreachable code or guard it with conditional compilation

The explicit return makes the in-process debug runner unreachable, requiring pragma suppression. Wrap the two paths with #if DEBUG to keep both without disabling CS0162.

Suggested refactor:

-            BenchmarkSwitcher.FromAssembly(System.Reflection.Assembly.GetExecutingAssembly()).Run(
-                args,
-                DefaultConfig.Instance
-                    .AddJob(BenchmarkDotNet.Jobs.Job.Default.WithIterationCount(5).WithWarmupCount(1).WithEnvironmentVariables(Microsoft.VSDiagnostics.VSDiagnosticsConfigurations.GetDotNetObjectAllocEnvironmentVariables(1)).AsMutator())
-                    .AddDiagnoser(new Microsoft.VSDiagnostics.DotNetObjectAllocDiagnoser())
-            ); return;
-#pragma warning disable CS0162 // Unreachable code detected
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, new DebugInProcessConfig());
-#pragma warning restore CS0162 // Unreachable code detected
+#if DEBUG
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly)
+                .Run(args, new DebugInProcessConfig());
+#else
+            BenchmarkSwitcher.FromAssembly(System.Reflection.Assembly.GetExecutingAssembly()).Run(
+                args,
+                DefaultConfig.Instance
+                    .AddJob(BenchmarkDotNet.Jobs.Job.Default
+                        .WithIterationCount(5)
+                        .WithWarmupCount(1)
+                        .WithEnvironmentVariables(Microsoft.VSDiagnostics.VSDiagnosticsConfigurations.GetDotNetObjectAllocEnvironmentVariables(1))
+                        .AsMutator())
+                    .AddDiagnoser(new Microsoft.VSDiagnostics.DotNetObjectAllocDiagnoser())
+            );
+#endif

src/NLog.Benchmarks/ColoredConsoleTargetBenchmark.cs (2)

38-41: Ensure predictable writes to the redirected Console output

Set AutoFlush to true on the StreamWriter so Console writes are flushed promptly to the underlying memory stream. It reduces buffering variability across runs.

-            streamWriter = new StreamWriter(memoryStream);
+            streamWriter = new StreamWriter(memoryStream) { AutoFlush = true };

---

46-49: Tidy up global state after the benchmark

Consider resetting LogManager.Configuration to avoid leaking configuration to other benchmarks/processes. Flush before restoring Console.Out for a clean hand-off.

         public void Cleanup()
         {
-            Console.SetOut(oldConsoleOutWriter);
-            streamWriter.Dispose();
-            memoryStream.Dispose();
+            streamWriter.Flush();
+            Console.SetOut(oldConsoleOutWriter);
+            streamWriter.Dispose();
+            memoryStream.Dispose();
+            LogManager.Configuration = null;
         }

src/NLog.Benchmarks/NLog.Benchmarks.csproj (1)

13-15: Avoid depending on the UnitTests project; reference NLog directly

Referencing the test project drags test-only dependencies and increases build time. The benchmark only uses NLog types; depend directly on the NLog project instead.

-  <ItemGroup>
-    <ProjectReference Include="..\..\tests\NLog.UnitTests\NLog.UnitTests.csproj" />
-  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\NLog\NLog.csproj" />
+  </ItemGroup>

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

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

src/NLog.Benchmarks/NLog.Benchmarks.csproj (3)

4-6: Benchmark project: consider multi-targeting, mark as non-packable, and force x64 for stable results

• Benchmarks are often run on multiple runtimes. Recommend multi-targeting to include a modern .NET runtime (e.g., net8.0) alongside net462.
• Mark the project as non-packable to avoid accidental packaging.
• Force x64 for more stable/realistic BDN runs and to avoid 32-bit JIT noise on some dev machines.

Apply this diff:

-  <PropertyGroup>
-    <TargetFramework>net462</TargetFramework>
-    <OutputType>Exe</OutputType>
-  </PropertyGroup>
+  <PropertyGroup>
+    <!-- Keep net462, but also allow running on a modern runtime -->
+    <TargetFrameworks>net462;net8.0</TargetFrameworks>
+    <OutputType>Exe</OutputType>
+    <IsPackable>false</IsPackable>
+    <PlatformTarget>x64</PlatformTarget>
+    <!-- Optional: keep source simple and modern -->
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>

---

9-11: Diagnostics package choice: prefer BDN’s platform-specific diagnosers and gate them by OS

The Visual Studio DiagnosticsHub diagnoser package tends to be Windows/VS-specific and heavy. For cross-platform CI and fewer restore issues, prefer BenchmarkDotNet.Diagnostics.Windows (Windows ETW) or keep diagnosers optional/conditional.

Option A (Windows-only diagnoser):

   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
-    <PackageReference Include="Microsoft.VisualStudio.DiagnosticsHub.BenchmarkDotNetDiagnosers" Version="18.0.36422.2" />
   </ItemGroup>
+  <ItemGroup Condition="'$(OS)' == 'Windows_NT'">
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.15.2" />
+  </ItemGroup>

Please verify:

• Whether you actually need DiagnosticsHub-specific features over BDN’s built-in/Windows diagnosers.
• That 0.15.2 is the intended BDN version across the repo (pinning a newer/older patch may be preferable for consistency).

---

14-15: ProjectReference is fine as-is; consider excluding this project from default CI builds

The ProjectReference is appropriate for local benchmarking. To keep CI lean and avoid failing pipelines due to benchmarks, consider excluding the benchmarks project from the default solution build in CI (solution-level config) rather than changing this csproj.

If helpful, I can provide a separate PR to:

• Add a solution configuration where NLog.Benchmarks is not built by default on CI.
• Document how to run benchmarks locally (dotnet run -c Release -f net8.0).

src/NLog/Conditions/ConditionMethodExpression.cs (2)

90-93: Document the non-boxing behavior for discoverability

Add an XML summary to call out that this overload returns cached boxed booleans to avoid allocations. It helps future contributors choose this overload for boolean predicates.

Proposed doc (add above the method):

/// <summary>
/// Creates a condition method (no parameters) backed by a boolean predicate.
/// The result is converted to a cached boxed boolean (BoxedTrue/BoxedFalse) to avoid per-evaluation boxing.
/// </summary>

---

85-99: Ensure the parser actually invokes the bool-overload to avoid boxing

Verification shows that ConditionParser (at src/NLog/Conditions/ConditionParser.cs:151–154) only calls

var method = _configurationItemFactory.ConditionMethodFactory.TryCreateInstanceWithNoParameters(functionName);
if (method != null)
    return ConditionMethodExpression.CreateMethodNoParameters(functionName, method);

and has no path for Func<LogEventInfo,bool>, so all parser-resolved methods still box their bool result. Meanwhile, the new bool overload is only used by hand-written callers (e.g. in SetupLoadConfigurationExtensions.cs and ColoredConsolePrinter*).

To make the zero-parameter bool overload effective for parser-created conditions, pick one integration approach:

• Factory-first
  Extend the MethodFactory API to preferentially return a Func<LogEventInfo,bool> when available:

  // In MethodFactory
  public Func<LogEventInfo,bool>? TryCreateInstanceWithNoParametersBool(string methodName) { … }
  
  // In ConditionParser.CreateMethodExpression:
  var methodBool = _configurationItemFactory.ConditionMethodFactory.TryCreateInstanceWithNoParametersBool(functionName);
  if (methodBool != null)
      return ConditionMethodExpression.CreateMethodNoParameters(functionName, methodBool);
  
  // Fallback to object-returning:
  var methodObj  = _configurationItemFactory.ConditionMethodFactory.TryCreateInstanceWithNoParameters(functionName);
  if (methodObj != null)
      return ConditionMethodExpression.CreateMethodNoParameters(functionName, methodObj);

• Parser adapter
  If the existing factory can indicate the target method’s return type (e.g. via metadata on the delegate), detect boolean-returning methods in ConditionParser and call the new bool overload directly.

Please adjust ConditionParser (around line 151) to route boolean delegates into CreateMethodNoParameters(string, Func<LogEventInfo,bool>).

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.