Added more throttling to ingest and analysis

kristan66 · kristan66 · commit 3bd090144949 · 2026-02-23T13:47:29.000Z
diff --git a/src/KeeperData.Bridge/appsettings.json b/src/KeeperData.Bridge/appsettings.json
@@ -84,7 +84,7 @@
       {
         "JobType": "CleanseReportJob",
         "Enabled": true,
-        "CronSchedule": "0 0 8 * * ?"
+        "CronSchedule": "0 0 2 * * ?"
       }
     ]
   },
diff --git a/src/KeeperData.Core.Reports/Cleanse/Analysis/Command/Abstract/CleanseAnalysisEngineBase.cs b/src/KeeperData.Core.Reports/Cleanse/Analysis/Command/Abstract/CleanseAnalysisEngineBase.cs
@@ -8,7 +8,8 @@ namespace KeeperData.Core.Reports.Cleanse.Analysis.Command.Abstract;
 
 public abstract class CleanseAnalysisEngineBase(ICtsSamQueryService dataService, IIssueCommandService issueCommandService)
 {
-    private const int BatchSize = 100;
+    private const int ThrottlingPumpDelayMs = 400;
+    private const int BatchSize = 70;
     private const int ProgressUpdateInterval = 100;
     private const string DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
 
@@ -34,35 +35,11 @@ protected abstract Task ProcessCtsPrimaryRecordAsync(string id,
     protected abstract Task ProcessSamPrimaryRecordAsync(string id,
         string operationId, AnalysisMetrics metrics, CancellationToken ct);
 
-    public async Task<AnalysisMetrics> ExecuteAsync(string operationId, ProgressCallback progressCallback, CancellationToken ct)
-    {
-        var metrics = new AnalysisMetrics();
-
-        var ctsTotalRecords = await dataService.GetCtsCphHoldingsCountAsync(ct);
-        var samTotalRecords = await dataService.GetSamCphHoldingsCountAsync(ct);
-        var totalRecords = ctsTotalRecords + samTotalRecords;
-
-        await progressCallback(0, totalRecords, 0, 0);
-
-        // iterate CTS CPH records
-        await PumpAsync(new PumpContext(totalRecords, operationId, metrics, progressCallback,
-            dataService.ListCtsCphHoldingsAsync, ProcessCtsPrimaryRecordAsync,
-            DataFields.CtsCphHoldingFields.LidFullIdentifier), ct);
-
-        // iterate SAM CPH records
-        await PumpAsync(new PumpContext(totalRecords, operationId, metrics, progressCallback,
-            dataService.ListSamCphHoldingsAsync, ProcessSamPrimaryRecordAsync,
-            DataFields.SamCphHoldingFields.Cph), ct);
-
-        return metrics;
-    }
-
-
 
     protected async Task PumpAsync(PumpContext context, CancellationToken ct)
     {
         var skip = 0;
-        while (true && !ct.IsCancellationRequested)
+        while (!ct.IsCancellationRequested)
         {
             var batch = await context.Fetcher(skip, BatchSize, ct);
 
@@ -80,9 +57,34 @@ protected async Task PumpAsync(PumpContext context, CancellationToken ct)
             {
                 await context.ProgressCallback(context.Metrics.RecordsAnalyzed, context.TotalRecords, context.Metrics.IssuesFound, context.Metrics.IssuesResolved);
             }
+
+            await Task.Delay(ThrottlingPumpDelayMs, ct);
         }
     }
 
+    public async Task<AnalysisMetrics> ExecuteAsync(string operationId, ProgressCallback progressCallback, CancellationToken ct)
+    {
+        var metrics = new AnalysisMetrics();
+
+        var ctsTotalRecords = await dataService.GetCtsCphHoldingsCountAsync(ct);
+        var samTotalRecords = await dataService.GetSamCphHoldingsCountAsync(ct);
+        var totalRecords = ctsTotalRecords + samTotalRecords;
+
+        await progressCallback(0, totalRecords, 0, 0);
+
+        // iterate CTS CPH records
+        await PumpAsync(new PumpContext(totalRecords, operationId, metrics, progressCallback,
+            dataService.ListCtsCphHoldingsAsync, ProcessCtsPrimaryRecordAsync,
+            DataFields.CtsCphHoldingFields.LidFullIdentifier), ct);
+
+        // iterate SAM CPH records
+        await PumpAsync(new PumpContext(totalRecords, operationId, metrics, progressCallback,
+            dataService.ListSamCphHoldingsAsync, ProcessSamPrimaryRecordAsync,
+            DataFields.SamCphHoldingFields.Cph), ct);
+
+        return metrics;
+    }
+
     protected static async Task ProcessBatchAsync(QueryResult batch, PumpContext context, CancellationToken ct)
     {
         foreach (var record in batch.Data)
diff --git a/src/KeeperData.Core.Reports/Cleanse/Analysis/Command/Impl/CleanseAnalysisEngine.cs b/src/KeeperData.Core.Reports/Cleanse/Analysis/Command/Impl/CleanseAnalysisEngine.cs
@@ -15,6 +15,8 @@ public class CleanseAnalysisEngine(ICtsSamQueryService dataService, IIssueComman
     private readonly RecordIdGenerator _recordIdGenerator = new();
     private readonly ICtsSamQueryService _dataService = dataService;
 
+    private const int ThrottleDelayMs = 100;
+
     private async Task ProcessCtsPrimaryRecordInternalAsync(LidFullIdentifier lidFullIdentifier, string operationId, AnalysisMetrics metrics, CancellationToken ct)
     {
         var samCphHolding = await _dataService.GetSamCphHoldingAsync(lidFullIdentifier.Cph, ct);
@@ -38,13 +40,19 @@ private async Task ProcessCtsPrimaryRecordInternalAsync(LidFullIdentifier lidFul
     }
 
     private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)
+    {
+        EvaluateEmailRules(ctsHolding, samCphHolding, results);
+        EvaluatePhoneRules(ctsHolding, samCphHolding, results);
+        EvaluateCattleUnitRule(ctsHolding, samCphHolding, results);
+        EvaluateLocationConsistencyRule(ctsHolding, samCphHolding, results);
+    }
+
+    private static void EvaluateEmailRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)
     {
         var ctsEmails = ctsHolding.GetEmailAddresses();
         var samEmails = samCphHolding.GetEmailAddresses();
-        var ctsPhones = ctsHolding.GetPhoneNumbers();
-        var samPhones = samCphHolding.GetPhoneNumbers();
 
-        // PRIORITY 2:  RULE 4: CPH present in both CTS and SAM but no email addresses in either system
+        // PRIORITY 2: RULE 4 - CPH present in both CTS and SAM but no email addresses in either system
         if (ctsEmails.Length + samEmails.Length == 0)
         {
             results.Add(RuleResult.Issue(RuleDescriptors.CtsSamNoEmailAddresses, ctsHolding.Id, samCphHolding.Cph));
@@ -53,21 +61,28 @@ private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHol
         var missingEmails = ctsEmails.Except(samEmails).ToArray();
         if (missingEmails.Length > 0)
         {
-            if (samEmails.Length == 0) // PRIORITY 3:  RULE 12 - Email addresses in CTS missing from SAM
+            if (samEmails.Length == 0) // PRIORITY 3: RULE 12 - Email addresses in CTS missing from SAM
             {
-                results.Add(RuleResult.Issue(RuleDescriptors.SamMissingEmailAddresses, ctsHolding.Id, samCphHolding.Cph, x => x.EmailCTS = missingEmails)); }
+                results.Add(RuleResult.Issue(RuleDescriptors.SamMissingEmailAddresses, ctsHolding.Id, samCphHolding.Cph,
+                    x => x.EmailCTS = missingEmails));
+            }
         }
-        else // PRIORITY 7:  RULE 6 - Email addresses inconsistent between CTS and SAM
+        else // PRIORITY 7: RULE 6 - Email addresses inconsistent between CTS and SAM
         {
             results.Add(RuleResult.Issue(RuleDescriptors.CtsSamEmailAddressesInconsistent, ctsHolding.Id, samCphHolding.Cph, x =>
             {
                 x.EmailCTS = missingEmails;
-                x.EmailSAM = string.Join(";",samEmails);
+                x.EmailSAM = string.Join("; ", samEmails);
             }));
         }
-    
+    }
+
+    private static void EvaluatePhoneRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)
+    {
+        var ctsPhones = ctsHolding.GetPhoneNumbers();
+        var samPhones = samCphHolding.GetPhoneNumbers();
 
-        // PRIORITY 4:  RULE 5  - CPH present in both CTS and SAM but no phone numbers in either system
+        // PRIORITY 4: RULE 5 - CPH present in both CTS and SAM but no phone numbers in either system
         if (ctsPhones.Length + samPhones.Length == 0)
         {
             results.Add(RuleResult.Issue(RuleDescriptors.CtsSamNoPhoneNumbers, ctsHolding.Id, samCphHolding.Cph));
@@ -76,30 +91,37 @@ private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHol
         var missingPhones = ctsPhones.Except(samPhones).ToArray();
         if (missingPhones.Length > 0)
         {
-            if (samPhones.Length == 0) // // PRIORITY 5:  RULE 11 - CTS phone numbers missing from SAM
+            if (samPhones.Length == 0) // PRIORITY 5: RULE 11 - CTS phone numbers missing from SAM
             {
-                results.Add(RuleResult.Issue(RuleDescriptors.SamMissingPhoneNumbers, ctsHolding.Id, samCphHolding.Cph, x => x.TelCTS = missingPhones));
+                results.Add(RuleResult.Issue(RuleDescriptors.SamMissingPhoneNumbers, ctsHolding.Id, samCphHolding.Cph,
+                    x => x.TelCTS = missingPhones));
             }
             else
             {
-                // PRIORITY 8:  RULE 7 - Phone numbers inconsistent between CTS and SAM
+                // PRIORITY 8: RULE 7 - Phone numbers inconsistent between CTS and SAM
                 results.Add(RuleResult.Issue(RuleDescriptors.CtsSamPhoneNosInconsistent, ctsHolding.Id, samCphHolding.Cph, x =>
                 {
                     x.TelCTS = missingPhones;
-                    x.TelSAM = string.Join(";", samPhones);
+                    x.TelSAM = string.Join("; ", samPhones);
                 }));
             }
         }
+    }
 
-        // PRIORITY 6:  RULE 1  - No cattle unit defined in SAM
+    private static void EvaluateCattleUnitRule(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)
+    {
+        // PRIORITY 6: RULE 1 - No cattle unit defined in SAM
         var asc = samCphHolding.Holding[DataFields.SamCphHoldingFields.AnimalSpeciesCode]?.ToString();
         if (asc != "CTT")
         {
-            results.Add(RuleResult.Issue(RuleDescriptors.SamNoCattleUnit, ctsHolding.Id, samCphHolding.Cph, x => x.AnimalSpeciesCode = asc));
+            results.Add(RuleResult.Issue(RuleDescriptors.SamNoCattleUnit, ctsHolding.Id, samCphHolding.Cph,
+                x => x.AnimalSpeciesCode = asc));
         }
+    }
 
-        // PRIORITY 10: RULE 3 - Cattle-related CPHs in SAM (e.g. those with relevant animal species or purpose codes) that are not present in CTS
-        // aka: where ANIMAL_SPECIES_CODE=CTT - if SAM.FEATURE_NAME=['Unknown','Not known','Notknown','',null] OR CTS.ADR_NAME != SAM.FEATURE_NAME then raise issue
+    private static void EvaluateLocationConsistencyRule(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)
+    {
+        // PRIORITY 10: RULE 3 - Cattle-related CPHs in SAM with mismatched or unknown location names
         if (samCphHolding.AnimalSpeciesCode == "CTT" && IsLocationMismatch(ctsHolding, samCphHolding))
         {
             results.Add(RuleResult.Issue(RuleDescriptors.CtsSamLocationsDiffer, ctsHolding.Id, samCphHolding.Cph,
@@ -120,7 +142,6 @@ private static bool IsLocationMismatch(CtsCphHoldingModel ctsHolding, SamCphHold
             || !string.Equals(ctsHolding.LocationName, samCphHolding.LocationName, StringComparison.OrdinalIgnoreCase);
     }
 
-
     private async Task ProcessSamPrimaryRecordInternalAsync(Cph cph, string operationId, AnalysisMetrics metrics, CancellationToken ct)
     {
         var results = new List<RuleResult>();
@@ -135,8 +156,6 @@ private async Task ProcessSamPrimaryRecordInternalAsync(Cph cph, string operatio
         await RecordResultsAsync(cph.Value, cph, operationId, metrics, results, ct);
     }
 
-    #region Overrides 
-
     protected override async Task ProcessCtsPrimaryRecordAsync(string id, string operationId, AnalysisMetrics metrics, CancellationToken ct)
     {
         var lidFullIdentifier = LidFullIdentifier.TryParse(id);
@@ -157,10 +176,6 @@ protected override async Task ProcessSamPrimaryRecordAsync(string id, string ope
         }
     }
 
-    #endregion
-
-    #region Helpers
-
     private async Task RecordResultsAsync(string primaryRecordId, Cph cph, string operationId,
         AnalysisMetrics metrics, List<RuleResult> results, CancellationToken ct)
     {
@@ -182,6 +197,8 @@ private async Task RecordResultsAsync(string primaryRecordId, Cph cph, string op
             {
                 metrics.IssuesFound++;
             }
+
+            await Task.Delay(ThrottleDelayMs, ct);
         }
     }
 
@@ -193,8 +210,6 @@ protected static bool IsValidCountyCode(LidFullIdentifier lidFullIdentifier)
 
     protected string GenerateThumbprint(string primaryRecordId, string ruleId)
         => _recordIdGenerator.GenerateId($"{primaryRecordId}:{ruleId}");
-
-    #endregion
 }
 
 
diff --git a/src/KeeperData.Core/ETL/Impl/IngestionPipeline.cs b/src/KeeperData.Core/ETL/Impl/IngestionPipeline.cs

Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@`
`84`	`84`	`{`
`85`	`85`	`"JobType": "CleanseReportJob",`
`86`	`86`	`"Enabled": true,`
`87`		`- "CronSchedule": "0 0 8 * * ?"`
	`87`	`+ "CronSchedule": "0 0 2 * * ?"`
`88`	`88`	`}`
`89`	`89`	`]`
`90`	`90`	`},`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@ public class CleanseAnalysisEngine(ICtsSamQueryService dataService, IIssueComman`
`15`	`15`	`private readonly RecordIdGenerator _recordIdGenerator = new();`
`16`	`16`	`private readonly ICtsSamQueryService _dataService = dataService;`
`17`	`17`
	`18`	`+ private const int ThrottleDelayMs = 100;`
	`19`	`+`
`18`	`20`	`private async Task ProcessCtsPrimaryRecordInternalAsync(LidFullIdentifier lidFullIdentifier, string operationId, AnalysisMetrics metrics, CancellationToken ct)`
`19`	`21`	`{`
`20`	`22`	`var samCphHolding = await _dataService.GetSamCphHoldingAsync(lidFullIdentifier.Cph, ct);`
`@@ -38,13 +40,19 @@ private async Task ProcessCtsPrimaryRecordInternalAsync(LidFullIdentifier lidFul`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)`
	`43`	`+ {`
	`44`	`+ EvaluateEmailRules(ctsHolding, samCphHolding, results);`
	`45`	`+ EvaluatePhoneRules(ctsHolding, samCphHolding, results);`
	`46`	`+ EvaluateCattleUnitRule(ctsHolding, samCphHolding, results);`
	`47`	`+ EvaluateLocationConsistencyRule(ctsHolding, samCphHolding, results);`
	`48`	`+ }`
	`49`	`+`
	`50`	`+ private static void EvaluateEmailRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)`
`41`	`51`	`{`
`42`	`52`	`var ctsEmails = ctsHolding.GetEmailAddresses();`
`43`	`53`	`var samEmails = samCphHolding.GetEmailAddresses();`
`44`		`- var ctsPhones = ctsHolding.GetPhoneNumbers();`
`45`		`- var samPhones = samCphHolding.GetPhoneNumbers();`
`46`	`54`
`47`		`- // PRIORITY 2: RULE 4: CPH present in both CTS and SAM but no email addresses in either system`
	`55`	`+ // PRIORITY 2: RULE 4 - CPH present in both CTS and SAM but no email addresses in either system`
`48`	`56`	`if (ctsEmails.Length + samEmails.Length == 0)`
`49`	`57`	`{`
`50`	`58`	`results.Add(RuleResult.Issue(RuleDescriptors.CtsSamNoEmailAddresses, ctsHolding.Id, samCphHolding.Cph));`
`@@ -53,21 +61,28 @@ private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHol`
`53`	`61`	`var missingEmails = ctsEmails.Except(samEmails).ToArray();`
`54`	`62`	`if (missingEmails.Length > 0)`
`55`	`63`	`{`
`56`		`- if (samEmails.Length == 0) // PRIORITY 3: RULE 12 - Email addresses in CTS missing from SAM`
	`64`	`+ if (samEmails.Length == 0) // PRIORITY 3: RULE 12 - Email addresses in CTS missing from SAM`
`57`	`65`	`{`
`58`		`- results.Add(RuleResult.Issue(RuleDescriptors.SamMissingEmailAddresses, ctsHolding.Id, samCphHolding.Cph, x => x.EmailCTS = missingEmails)); }`
	`66`	`+ results.Add(RuleResult.Issue(RuleDescriptors.SamMissingEmailAddresses, ctsHolding.Id, samCphHolding.Cph,`
	`67`	`+ x => x.EmailCTS = missingEmails));`
	`68`	`+ }`
`59`	`69`	`}`
`60`		`- else // PRIORITY 7: RULE 6 - Email addresses inconsistent between CTS and SAM`
	`70`	`+ else // PRIORITY 7: RULE 6 - Email addresses inconsistent between CTS and SAM`
`61`	`71`	`{`
`62`	`72`	`results.Add(RuleResult.Issue(RuleDescriptors.CtsSamEmailAddressesInconsistent, ctsHolding.Id, samCphHolding.Cph, x =>`
`63`	`73`	`{`
`64`	`74`	`x.EmailCTS = missingEmails;`
`65`		`- x.EmailSAM = string.Join(";",samEmails);`
	`75`	`+ x.EmailSAM = string.Join("; ", samEmails);`
`66`	`76`	`}));`
`67`	`77`	`}`
`68`		`-`
	`78`	`+ }`
	`79`	`+`
	`80`	`+ private static void EvaluatePhoneRules(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)`
	`81`	`+ {`
	`82`	`+ var ctsPhones = ctsHolding.GetPhoneNumbers();`
	`83`	`+ var samPhones = samCphHolding.GetPhoneNumbers();`
`69`	`84`
`70`		`- // PRIORITY 4: RULE 5 - CPH present in both CTS and SAM but no phone numbers in either system`
	`85`	`+ // PRIORITY 4: RULE 5 - CPH present in both CTS and SAM but no phone numbers in either system`
`71`	`86`	`if (ctsPhones.Length + samPhones.Length == 0)`
`72`	`87`	`{`
`73`	`88`	`results.Add(RuleResult.Issue(RuleDescriptors.CtsSamNoPhoneNumbers, ctsHolding.Id, samCphHolding.Cph));`
`@@ -76,30 +91,37 @@ private static void EvaluateCtsSamRules(CtsCphHoldingModel ctsHolding, SamCphHol`
`76`	`91`	`var missingPhones = ctsPhones.Except(samPhones).ToArray();`
`77`	`92`	`if (missingPhones.Length > 0)`
`78`	`93`	`{`
`79`		`- if (samPhones.Length == 0) // // PRIORITY 5: RULE 11 - CTS phone numbers missing from SAM`
	`94`	`+ if (samPhones.Length == 0) // PRIORITY 5: RULE 11 - CTS phone numbers missing from SAM`
`80`	`95`	`{`
`81`		`- results.Add(RuleResult.Issue(RuleDescriptors.SamMissingPhoneNumbers, ctsHolding.Id, samCphHolding.Cph, x => x.TelCTS = missingPhones));`
	`96`	`+ results.Add(RuleResult.Issue(RuleDescriptors.SamMissingPhoneNumbers, ctsHolding.Id, samCphHolding.Cph,`
	`97`	`+ x => x.TelCTS = missingPhones));`
`82`	`98`	`}`
`83`	`99`	`else`
`84`	`100`	`{`
`85`		`- // PRIORITY 8: RULE 7 - Phone numbers inconsistent between CTS and SAM`
	`101`	`+ // PRIORITY 8: RULE 7 - Phone numbers inconsistent between CTS and SAM`
`86`	`102`	`results.Add(RuleResult.Issue(RuleDescriptors.CtsSamPhoneNosInconsistent, ctsHolding.Id, samCphHolding.Cph, x =>`
`87`	`103`	`{`
`88`	`104`	`x.TelCTS = missingPhones;`
`89`		`- x.TelSAM = string.Join(";", samPhones);`
	`105`	`+ x.TelSAM = string.Join("; ", samPhones);`
`90`	`106`	`}));`
`91`	`107`	`}`
`92`	`108`	`}`
	`109`	`+ }`
`93`	`110`
`94`		`- // PRIORITY 6: RULE 1 - No cattle unit defined in SAM`
	`111`	`+ private static void EvaluateCattleUnitRule(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)`
	`112`	`+ {`
	`113`	`+ // PRIORITY 6: RULE 1 - No cattle unit defined in SAM`
`95`	`114`	`var asc = samCphHolding.Holding[DataFields.SamCphHoldingFields.AnimalSpeciesCode]?.ToString();`
`96`	`115`	`if (asc != "CTT")`
`97`	`116`	`{`
`98`		`- results.Add(RuleResult.Issue(RuleDescriptors.SamNoCattleUnit, ctsHolding.Id, samCphHolding.Cph, x => x.AnimalSpeciesCode = asc));`
	`117`	`+ results.Add(RuleResult.Issue(RuleDescriptors.SamNoCattleUnit, ctsHolding.Id, samCphHolding.Cph,`
	`118`	`+ x => x.AnimalSpeciesCode = asc));`
`99`	`119`	`}`
	`120`	`+ }`
`100`	`121`
`101`		`- // PRIORITY 10: RULE 3 - Cattle-related CPHs in SAM (e.g. those with relevant animal species or purpose codes) that are not present in CTS`
`102`		`- // aka: where ANIMAL_SPECIES_CODE=CTT - if SAM.FEATURE_NAME=['Unknown','Not known','Notknown','',null] OR CTS.ADR_NAME != SAM.FEATURE_NAME then raise issue`
	`122`	`+ private static void EvaluateLocationConsistencyRule(CtsCphHoldingModel ctsHolding, SamCphHoldingModel samCphHolding, List<RuleResult> results)`
	`123`	`+ {`
	`124`	`+ // PRIORITY 10: RULE 3 - Cattle-related CPHs in SAM with mismatched or unknown location names`
`103`	`125`	`if (samCphHolding.AnimalSpeciesCode == "CTT" && IsLocationMismatch(ctsHolding, samCphHolding))`
`104`	`126`	`{`
`105`	`127`	`results.Add(RuleResult.Issue(RuleDescriptors.CtsSamLocationsDiffer, ctsHolding.Id, samCphHolding.Cph,`
`@@ -120,7 +142,6 @@ private static bool IsLocationMismatch(CtsCphHoldingModel ctsHolding, SamCphHold`
`120`	`142`	`\|\| !string.Equals(ctsHolding.LocationName, samCphHolding.LocationName, StringComparison.OrdinalIgnoreCase);`
`121`	`143`	`}`
`122`	`144`
`123`		`-`
`124`	`145`	`private async Task ProcessSamPrimaryRecordInternalAsync(Cph cph, string operationId, AnalysisMetrics metrics, CancellationToken ct)`
`125`	`146`	`{`
`126`	`147`	`var results = new List<RuleResult>();`
`@@ -135,8 +156,6 @@ private async Task ProcessSamPrimaryRecordInternalAsync(Cph cph, string operatio`
`135`	`156`	`await RecordResultsAsync(cph.Value, cph, operationId, metrics, results, ct);`
`136`	`157`	`}`
`137`	`158`
`138`		`- #region Overrides`
`139`		`-`
`140`	`159`	`protected override async Task ProcessCtsPrimaryRecordAsync(string id, string operationId, AnalysisMetrics metrics, CancellationToken ct)`
`141`	`160`	`{`
`142`	`161`	`var lidFullIdentifier = LidFullIdentifier.TryParse(id);`
`@@ -157,10 +176,6 @@ protected override async Task ProcessSamPrimaryRecordAsync(string id, string ope`
`157`	`176`	`}`
`158`	`177`	`}`
`159`	`178`
`160`		`- #endregion`
`161`		`-`
`162`		`- #region Helpers`
`163`		`-`
`164`	`179`	`private async Task RecordResultsAsync(string primaryRecordId, Cph cph, string operationId,`
`165`	`180`	`AnalysisMetrics metrics, List<RuleResult> results, CancellationToken ct)`
`166`	`181`	`{`
`@@ -182,6 +197,8 @@ private async Task RecordResultsAsync(string primaryRecordId, Cph cph, string op`
`182`	`197`	`{`
`183`	`198`	`metrics.IssuesFound++;`
`184`	`199`	`}`
	`200`	`+`
	`201`	`+ await Task.Delay(ThrottleDelayMs, ct);`
`185`	`202`	`}`
`186`	`203`	`}`
`187`	`204`
`@@ -193,8 +210,6 @@ protected static bool IsValidCountyCode(LidFullIdentifier lidFullIdentifier)`
`193`	`210`
`194`	`211`	`protected string GenerateThumbprint(string primaryRecordId, string ruleId)`
`195`	`212`	`=> _recordIdGenerator.GenerateId($"{primaryRecordId}:{ruleId}");`
`196`		`-`
`197`		`- #endregion`
`198`	`213`	`}`
`199`	`214`
`200`	`215`