Ginger/GingerCoreNET/External/GingerPlay/GingerPlayEndPointManager.cs (2)

100-110: Critical: Logic error makes backward compatibility fallback unreachable.

Line 104 checks GingerPlayConfiguration.GingerPlayEnabled but this condition will always be false when reaching this branch (because line 100 already returned if it were true). The subsequent assignment at line 108 (GingerPlayEnabled = true) never executes, breaking the backward compatibility migration path.

Apply this diff to fix the condition:

-                else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()) && GingerPlayConfiguration.GingerPlayEnabled)
+                else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()))
                 {
                     // If the Central Logger URL is set, use it as the Account Report Service URL
                     GingerPlayConfiguration.CentralizedAccountReportURL = WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility();
                     GingerPlayConfiguration.GingerPlayEnabled = true;
                     GingerPlayConfiguration.GingerPlayReportServiceEnabled = true;
                     return GingerPlayConfiguration.CentralizedAccountReportURL;
                 }

---

189-203: Critical: Same logic error as GetAccountReportServiceUrl.

Line 197 has the same issue as line 104: it checks GingerPlayEnabled after already returning early if it were true (line 189), making the backward compatibility fallback unreachable.

Apply this diff to fix the condition:

-                else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetExecutionServiceURLBackwardCompatibility()))
+                else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetExecutionServiceURLBackwardCompatibility()))
                 {
                     // If the Central Logger URL is set, use it as the Execution Service URL
                     GingerPlayConfiguration.CentralizedExecutionHandlerURL = WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetExecutionServiceURLBackwardCompatibility();
                     GingerPlayConfiguration.GingerPlayEnabled = true;
                     GingerPlayConfiguration.GingerPlayExecutionServiceEnabled = true;
                     return GingerPlayConfiguration.CentralizedExecutionHandlerURL;
                 }

Wait, looking more carefully at line 197 - the condition already doesn't check GingerPlayEnabled. Let me re-examine...

Actually, reviewing the code snippet provided shows line 197 as:

else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetExecutionServiceURLBackwardCompatibility()))

This is CORRECT - it doesn't check GingerPlayEnabled, so the backward compat path works. Let me mark this as skip and only flag the issue at lines 100-110.

Ginger/GingerCoreNET/Run/GingerRemoteExecutionUtils.cs (2)

42-47: Add an HTTP timeout to avoid hangs on remote calls.

Blocking .Result without a timeout can hang the UI/worker on network issues. Set a conservative timeout.

 using (var httpClient = new HttpClient())
 {
+    httpClient.Timeout = TimeSpan.FromSeconds(30);
     var endpoint = baseURI + "api/AccountReport/GetRunsetsExecutionInfoBySolutionID/" + soluionGuid;
     var response = httpClient.GetAsync(endpoint).Result;

And similarly in GetRunsetExecutionInfo:

 using (var httpClient = new HttpClient())
 {
+    httpClient.Timeout = TimeSpan.FromSeconds(30);
     var endpoint = baseURI + "api/AccountReport/GetRunsetExecutionInfoByRunsetID/" + soluionGuid + "/" + runsetGuid;
     var response = httpClient.GetAsync(endpoint).Result;

Also applies to: 72-76

---

109-114: Guard against empty/invalid JSON responses.

Add early returns to avoid NullReference when deserialization yields null or input is empty.

-            var runsetHLInfoResponses = JsonConvert.DeserializeObject<List<RunsetHLInfoResponse>>(result);
-            List<RunSetReport> runSetReports = [];
+            List<RunSetReport> runSetReports = [];
+            if (string.IsNullOrWhiteSpace(result))
+            {
+                return runSetReports;
+            }
+            var runsetHLInfoResponses = JsonConvert.DeserializeObject<List<RunsetHLInfoResponse>>(result);
+            if (runsetHLInfoResponses == null)
+            {
+                return runSetReports;
+            }

Ginger/Ginger/Run/RunSetsExecutionsHistoryPage.xaml.cs (1)

150-160: Minor: simplify return and fix method name typo.

Return the condition directly; consider renaming to SetExecutionHistoryVisibility for clarity.

-private bool SetExectionHistoryVisibility(ExecutionLoggerConfiguration execLoggerConfig)
+private bool SetExecutionHistoryVisibility(ExecutionLoggerConfiguration execLoggerConfig)
 {
-    if (execLoggerConfig.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayConfigured())
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
+    return execLoggerConfig.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes
+        && GingerPlayUtils.IsGingerPlayConfigured();
 }

Note: update all call sites if you rename.

Ginger/GingerCoreNET/RunLib/CLILib/CLIHelper.cs (1)

391-394: Fix potential NullReference when no executions are returned.

FirstOrDefault() can be null; parsing then throws. Also guard invalid GUID.

-            List<RunSetReport> runsetsReport = [];
-            runsetsReport = new GingerRemoteExecutionUtils().GetRunsetExecutionInfo(soluionGuid, runsetGuid);
-            return runsetsReport != null ? Guid.Parse(runsetsReport.FirstOrDefault().GUID) : Guid.Empty;
+            List<RunSetReport> runsetsReport = [];
+            runsetsReport = new GingerRemoteExecutionUtils().GetRunsetExecutionInfo(soluionGuid, runsetGuid);
+            if (runsetsReport?.Count > 0 && Guid.TryParse(runsetsReport[0].GUID, out var lastId))
+            {
+                return lastId;
+            }
+            return Guid.Empty;

Ginger/GingerCoreNET/Run/GingerExecutionEngine.cs (1)

299-304: Remove stale AccountReportExecutionLogger when Ginger Play loses its configuration.

Once AccountReportExecutionLogger has been added while Ginger Play is configured, flipping any of the Ginger Play flags (e.g. disabling the gateway URL, toggling GingerPlayEnabled, etc.) leaves PublishLogToCentralDB at Yes, so this method re-runs with IsGingerPlayConfigured() returning false. Because we only guard the addition now, the existing listener stays in RunListeners and will keep attempting to publish to Ginger Play with invalid settings, causing the same integration failure we are trying to prevent.

Please remove the listener whenever the Ginger Play configuration is no longer valid:

-            if (mSelectedExecutionLoggerConfiguration != null
-                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayConfigured() &&
-                accountReportExecutionLogger == null)
-            {
-                RunListeners.Add(new AccountReportExecutionLogger(mContext));
-            }
-
-            else if (
-                mSelectedExecutionLoggerConfiguration != null
-                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.No &&
-                accountReportExecutionLogger != null
-                )
-            {
-                RunListeners.Remove(accountReportExecutionLogger);
-            }
+            if (mSelectedExecutionLoggerConfiguration != null
+                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes)
+            {
+                if (GingerPlayUtils.IsGingerPlayConfigured())
+                {
+                    if (accountReportExecutionLogger == null)
+                    {
+                        RunListeners.Add(new AccountReportExecutionLogger(mContext));
+                    }
+                }
+                else if (accountReportExecutionLogger != null)
+                {
+                    RunListeners.Remove(accountReportExecutionLogger);
+                }
+            }
+            else if (accountReportExecutionLogger != null)
+            {
+                RunListeners.Remove(accountReportExecutionLogger);
+            }

Ginger/Ginger/Run/RunSetActions/ExportResultsToALMConfigPage.xaml.cs (1)

95-115: Disable “Export report link” whenever Ginger Play is not configured.

We now require GingerPlayUtils.IsGingerPlayConfigured() to allow centralized publishing, but the page still enables ExportReportLinkChkbx on initial load when PublishLogToCentralDB is already Yes. In that scenario the checkbox stays interactive even though the backend will refuse to publish (the logger never gets added), leading to a confusing UX.

Please mirror the runtime guard in the UI by disabling the checkbox both during construction and whenever the property change fires with Ginger Play misconfigured:

-            if (_executionLogger.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.No)
+            if (_executionLogger.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.No
+                || !GingerPlayUtils.IsGingerPlayConfigured())
             {
                 ExportReportLinkChkbx.IsEnabled = false;
                 ExportReportLinkChkbx.IsChecked = false;
             }
@@
-                else if (_executionLogger.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayConfigured())
-                {
-                    ExportReportLinkChkbx.IsEnabled = true;
-                }
+                else if (_executionLogger.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes)
+                {
+                    ExportReportLinkChkbx.IsEnabled = GingerPlayUtils.IsGingerPlayConfigured();
+                    if (!ExportReportLinkChkbx.IsEnabled)
+                    {
+                        ExportReportLinkChkbx.IsChecked = false;
+                    }
+                }

Ginger/GingerCoreNET/WorkSpaceLib/SolutionOperations.cs (1)

106-118: Potential NullReferenceException when checking HTML report configs.

lastSavedSolution.HTMLReportsConfigurationSetList is dereferenced without a null check; if it’s null, this will throw. Also, the Count check likely should be on the current Solution list, not lastSavedSolution.

Apply this fix:

-                    if (Solution.HTMLReportsConfigurationSetList != null && lastSavedSolution.HTMLReportsConfigurationSetList.Count != 0)
+                    if (Solution.HTMLReportsConfigurationSetList != null && Solution.HTMLReportsConfigurationSetList.Count != 0)
                     {
                         foreach (HTMLReportsConfiguration config in Solution.HTMLReportsConfigurationSetList)
                         {
                             if (config.DirtyStatus is Amdocs.Ginger.Common.Enums.eDirtyStatus.Modified or Amdocs.Ginger.Common.Enums.eDirtyStatus.NoTracked)
                             {
 
                                 bldExtraChangedItems.Append("Report configuration");
                                 break;
                             }
                         }
                     }

Ginger/GingerCoreNET/External/GingerPlay/GingerPlayEndPointManager.cs (1)

93-99: Critical logic error: Backward compatibility path is unreachable.

Line 93 requires GingerPlayEnabled to be true before executing the backward-compatibility logic that sets GingerPlayEnabled to true (line 97). This circular condition makes the backward-compatibility path unreachable, breaking migrations from Central Logger configurations.

Apply this diff to fix the logic:

-else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()) && GingerPlayConfiguration.GingerPlayEnabled)
+else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()))
 {
     // If the Central Logger URL is set, use it as the Account Report Service URL
     GingerPlayConfiguration.CentralizedAccountReportURL = WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility();
     GingerPlayConfiguration.GingerPlayEnabled = true;
     GingerPlayConfiguration.GingerPlayReportServiceEnabled = true;
     return GingerPlayConfiguration.CentralizedAccountReportURL;
 }

Ginger/GingerCoreNET/External/GingerPlay/GingerPlayEndPointManager.cs (1)

93-100: Logic error: GingerPlayEnabled gating prevents backward compatibility migration.

Line 93 requires GingerPlayEnabled to be true before entering the block that sets GingerPlayEnabled = true (line 97). This is circular logic that defeats the purpose of automatic migration from legacy configuration.

Inconsistency with other methods:

• GetHTMLReportServiceUrl() (lines 129-135) and GetExecutionServiceUrl() (lines 186-193) do NOT gate their backward compatibility paths with GingerPlayEnabled.
• Those methods successfully enable GingerPlay when migrating legacy config.

Impact: Users with legacy CentralLogger URLs but GingerPlayEnabled=false will not be auto-migrated to GingerPlay configuration.

Apply this diff to fix the logic and align with other methods:

-else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()) && GingerPlayConfiguration.GingerPlayEnabled)
+else if (!string.IsNullOrEmpty(WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility()))
 {
     // If the Central Logger URL is set, use it as the Account Report Service URL
     GingerPlayConfiguration.CentralizedAccountReportURL = WorkSpace.Instance?.Solution?.LoggerConfigurations?.GetCentralLoggerEndPointURLBackwardCompatibility();
     GingerPlayConfiguration.GingerPlayEnabled = true;
     GingerPlayConfiguration.GingerPlayReportServiceEnabled = true;
     return GingerPlayConfiguration.CentralizedAccountReportURL;
 }

Ginger/GingerCoreNET/ActionsLib/ActPublishArtifacts.cs (1)

94-99: Add explicit error for missing GingerPlay config.

In ActPublishArtifacts.cs before the artifact‐upload check (lines 94–99), insert a branch:

if (WorkSpace.Instance.Solution.LoggerConfigurations.PublishLogToCentralDB == ePublishToCentralDB.Yes
    && !GingerPlayUtils.IsGingerPlayGatewayUrlConfigured())
{
    Error = "Please configure GingerPlay Gateway URL in \"CONFIGURATIONS ⇒ Reports ⇒ Execution Logger Configurations ⇒ Centralized Execution Logger Settings\" before publishing artifacts.";
    return;
}

This ensures users enabling centralized logging without a configured GingerPlay endpoint are properly informed.

Ginger/GingerCoreNET/Run/GingerRemoteExecutionUtils.cs (3)

42-61: Avoid blocking waits and add HTTP timeouts; reuse response body

Current code uses .Result and reads content multiple times. Add a timeout and reuse the body to reduce flakiness and hangs.

Apply this diff:

 using (var httpClient = new HttpClient())
 {
+    httpClient.Timeout = TimeSpan.FromSeconds(30);
     var endpoint = baseURI + "api/AccountReport/GetRunsetsExecutionInfoBySolutionID/" + soluionGuid;
     var response = httpClient.GetAsync(endpoint).Result;
     if (!response.IsSuccessStatusCode)
     {
+        var body = response.Content.ReadAsStringAsync().Result;
         if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
         {
-            Reporter.ToLog(eLogLevel.DEBUG, $"Not found Execution Info againts solutionGuid  : {soluionGuid} GetSolutionRunsetsExecutionInfo() :{response.Content.ReadAsStringAsync().Result}");
+            Reporter.ToLog(eLogLevel.DEBUG, $"Not found Execution Info againts solutionGuid  : {soluionGuid} GetSolutionRunsetsExecutionInfo() :{body}");
         }
         else
         {
-            Reporter.ToLog(eLogLevel.ERROR, $"Error occurred during GetSolutionRunsetsExecutionInfo() :{response.Content.ReadAsStringAsync().Result}");
+            Reporter.ToLog(eLogLevel.ERROR, $"Error occurred during GetSolutionRunsetsExecutionInfo() :{body}");
         }
     }
     else
     {
-        runSetReports = ConvertResponsInRunsetReport(response.Content.ReadAsStringAsync().Result);
+        var body = response.Content.ReadAsStringAsync().Result;
+        runSetReports = ConvertResponsInRunsetReport(body);
     }
 }

---

72-93: Mirror the HTTP hardening in the second call

Same timeout + body reuse recommended here as well.

Apply this diff:

 using (var httpClient = new HttpClient())
 {
+    httpClient.Timeout = TimeSpan.FromSeconds(30);
     var endpoint = baseURI + "api/AccountReport/GetRunsetExecutionInfoByRunsetID/" + soluionGuid + "/" + runsetGuid;
     var response = httpClient.GetAsync(endpoint).Result;
     if (!response.IsSuccessStatusCode)
     {
+        var body = response.Content.ReadAsStringAsync().Result;
         if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
         {
-            Reporter.ToLog(eLogLevel.DEBUG, $"Not found Execution Info againts runsetGuid  : {runsetGuid} GetSolutionRunsetsExecutionInfo() :{response.Content.ReadAsStringAsync().Result}");
+            Reporter.ToLog(eLogLevel.DEBUG, $"Not found Execution Info againts runsetGuid  : {runsetGuid} GetSolutionRunsetsExecutionInfo() :{body}");
         }
         else
         {
-            Reporter.ToLog(eLogLevel.ERROR, $"Error occurred during GetSolutionRunsetsExecutionInfo() :{response.Content.ReadAsStringAsync().Result}");
+            Reporter.ToLog(eLogLevel.ERROR, $"Error occurred during GetSolutionRunsetsExecutionInfo() :{body}");
         }
     }
     else
     {
-        runSetReports = ConvertResponsInRunsetReport(response.Content.ReadAsStringAsync().Result);
+        var body = response.Content.ReadAsStringAsync().Result;
+        runSetReports = ConvertResponsInRunsetReport(body);
     }
 }

---

107-133: Guard against null/empty JSON to avoid NRE

ConvertResponsInRunsetReport assumes deserialization is non-null. Add early returns/log.

Apply this diff:

 private List<RunSetReport> ConvertResponsInRunsetReport(string result)
 {
-    var runsetHLInfoResponses = JsonConvert.DeserializeObject<List<RunsetHLInfoResponse>>(result);
-    List<RunSetReport> runSetReports = [];
+    List<RunSetReport> runSetReports = [];
+    if (string.IsNullOrWhiteSpace(result))
+    {
+        Reporter.ToLog(eLogLevel.DEBUG, "GetRunset(s)ExecutionInfo returned empty response body.");
+        return runSetReports;
+    }
+    var runsetHLInfoResponses = JsonConvert.DeserializeObject<List<RunsetHLInfoResponse>>(result);
+    if (runsetHLInfoResponses == null || runsetHLInfoResponses.Count == 0)
+    {
+        Reporter.ToLog(eLogLevel.DEBUG, "GetRunset(s)ExecutionInfo returned no items.");
+        return runSetReports;
+    }

Ginger/Ginger/Run/RunSetActions/ExportResultsToALMConfigPage.xaml.cs (2)

86-100: Initialize Export report link state on load

Currently it stays disabled until a property change occurs. Initialize based on current config.

Apply this diff:

 _executionLogger = WorkSpace.Instance.Solution.LoggerConfigurations;
 _executionLogger.PropertyChanged += _executionLogger_PropertyChanged;
 
+// Initialize state
+if (_executionLogger.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes
+    && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured())
+{
+    ExportReportLinkChkbx.IsEnabled = true;
+}
+else
+{
+    ExportReportLinkChkbx.IsEnabled = false;
+    ExportReportLinkChkbx.IsChecked = false;
+}
 
 if (_executionLogger.SelectedDataRepositoryMethod == ExecutionLoggerConfiguration.DataRepositoryMethod.LiteDB)
 {

---

170-176: Avoid hard‑disabling in Init(); apply same gating there

Init() unconditionally disables the checkbox. Apply the same gating to keep UI consistent.

Apply this diff:

-                ExportReportLinkChkbx.IsEnabled = false;
+                if (WorkSpace.Instance.Solution.LoggerConfigurations.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes
+                    && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured())
+                {
+                    ExportReportLinkChkbx.IsEnabled = true;
+                }
+                else
+                {
+                    ExportReportLinkChkbx.IsEnabled = false;
+                    ExportReportLinkChkbx.IsChecked = false;
+                }

Ginger/GingerCoreNET/RunLib/CLILib/CLIHelper.cs (1)

391-394: Harden GUID parsing to avoid exceptions on empty results

Avoid NullReference/FormatException when no records returned.

Apply this diff:

-            return runsetsReport != null ? Guid.Parse(runsetsReport.FirstOrDefault().GUID) : Guid.Empty;
+            var first = runsetsReport?.FirstOrDefault();
+            return Guid.TryParse(first?.GUID, out var guid) ? guid : Guid.Empty;

Ginger/GingerCoreNET/ALMLib/Generic/ALMCore.cs (1)

229-236: Require valid HTML report URL and SPA-friendly wrapper

Validate GetReportHTMLServiceUrl() in the condition and assign via GingerRemoteExecutionUtils.GetReportHTMLServiceUrl() to ensure the URL ends with / and #/:

-                bool check =
-                    WorkSpace.Instance.Solution.ExecutionLoggerConfigurationSetList.Any(g => g.IsSelected && g.PublishLogToCentralDB == ePublishToCentralDB.Yes) && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured();
+                bool check =
+                    WorkSpace.Instance.Solution.ExecutionLoggerConfigurationSetList.Any(g => g.IsSelected && g.PublishLogToCentralDB == ePublishToCentralDB.Yes)
+                    && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured()
+                    && !string.IsNullOrEmpty(GingerRemoteExecutionUtils.GetReportHTMLServiceUrl());
@@
-                    publishToALMConfig.HtmlReportUrl = GingerPlayEndPointManager.GetHTMLReportServiceUrl();
+                    publishToALMConfig.HtmlReportUrl = GingerRemoteExecutionUtils.GetReportHTMLServiceUrl();

Ginger/GingerCoreNET/Run/GingerExecutionEngine.cs (2)

299-314: Remove stale AccountReportExecutionLogger when Ginger Play is not configured

Currently you add the logger only if Publish==Yes and GingerPlay is configured, but you only remove it when Publish==No. If Publish stays Yes but GingerPlay becomes misconfigured, the logger remains attached and will try to publish erroneously. Make removal symmetric with the enable condition.

Apply this diff:

-            if (mSelectedExecutionLoggerConfiguration != null
-                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured() &&
-                accountReportExecutionLogger == null)
+            bool shouldEnableCentralLogger =
+                mSelectedExecutionLoggerConfiguration != null
+                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes
+                && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured();
+
+            if (shouldEnableCentralLogger && accountReportExecutionLogger == null)
             {
                 RunListeners.Add(new AccountReportExecutionLogger(mContext));
             }
-
-            else if (
-                mSelectedExecutionLoggerConfiguration != null
-                && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.No &&
-                accountReportExecutionLogger != null
-                )
+            else if (!shouldEnableCentralLogger && accountReportExecutionLogger != null)
             {
                 RunListeners.Remove(accountReportExecutionLogger);
             }

---

338-356: Align AccountReportExecutionLogger additions with existing initializer

Replace the two direct RunListeners.Add(new AccountReportExecutionLogger(mContext)) calls (lines 303 and 350) with InitializeAccountReportExecutionLogger() so they respect the Publish flag and existing gating logic.
Would you like a patch to refactor these to use the initializer?

Ginger/GingerCoreNET/Run/RunsetExecutor.cs (2)

460-469: Avoid duplicate endpoint calls; keep the gating

Minor: GetAccountReportServiceUrl() is called twice. Cache it locally to avoid redundant work and inconsistent reads.

-                        if (mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured() && !string.IsNullOrEmpty(GingerPlayEndPointManager.GetAccountReportServiceUrl()))
+                        var accountReportUrl = GingerPlayEndPointManager.GetAccountReportServiceUrl();
+                        if (mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ExecutionLoggerConfiguration.ePublishToCentralDB.Yes
+                            && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured()
+                            && !string.IsNullOrEmpty(accountReportUrl))
                         {
-                            accountReportApiHandler = new AccountReportApiHandler(GingerPlayEndPointManager.GetAccountReportServiceUrl());
+                            accountReportApiHandler = new AccountReportApiHandler(accountReportUrl);

---

502-508: DRY: Extract a helper for “should publish to central”

The same composite condition appears multiple times. Extracting it will reduce drift.

Example:

+        private bool ShouldPublishToCentral() =>
+            mSelectedExecutionLoggerConfiguration != null
+            && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes
+            && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured()
+            && Runners.Count > 0;

Then:

-                if (mSelectedExecutionLoggerConfiguration != null && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured() && Runners.Count > 0)
+                if (ShouldPublishToCentral())
                 { ... }

-                if (mSelectedExecutionLoggerConfiguration != null && mSelectedExecutionLoggerConfiguration.PublishLogToCentralDB == ePublishToCentralDB.Yes && GingerPlayUtils.IsGingerPlayGatewayUrlConfigured() && Runners.Count > 0)
+                if (ShouldPublishToCentral())
                 { ... }

Also applies to: 619-626