[FaultInjection] FaultInjection: Fixes critical bugs for release 2 (#5675)

## Summary

This PR addresses critical bug fixes in the FaultInjection library
identified during the pre-release analysis for Release 2.

### Changes

**1. Thread-safety fix in
`FaultInjectionApplicationContext.AddRuleExecution()` (#5653)**
- The `AddRuleExecution()` method was using `TryAdd` + direct
`List<T>.Add()` on values stored in `ConcurrentDictionary`, which is not
thread-safe. Replaced with `AddOrUpdate()` with `lock` synchronization
on the list instances.

**2. SendDelay validation in
`FaultInjectionServerErrorResultBuilder.Build()` (#5654)**
- `Build()` validated that a delay was set for `ResponseDelay` and
`ConnectionDelay` error types, but not for `SendDelay`. Users could
create a `SendDelay` rule without specifying a delay (defaulting to
`TimeSpan.Zero`). Added `SendDelay` to the validation check.

**3. Incorrect `OutputType` in `FaultInjection.csproj` (#5655)**
- The csproj had `<OutputType>Exe</OutputType>` and
`<TargetType>library</TargetType>` which is contradictory. Removed both
lines since the default for SDK-style projects is `Library`.

**4. Null validation in `FaultInjector` constructor (#5656)**
- The constructor accepted `null` for the `rules` parameter without
validation, leading to a deferred `NullReferenceException`. Added an
`ArgumentNullException` guard.

### Testing
- Build verified locally with `dotnet build`
- All changes are minimal and surgical

Parent tracking issue: #5652

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Kiran Kumar Kolli <kirankk@microsoft.com>

Author: 3 people

Microsoft.Azure.Cosmos/FaultInjection/src/FaultInjection.csproj

@@ -7,9 +7,7 @@
 		<Copyright>© Microsoft Corporation. All rights reserved.</Copyright>
 		<NeutralLanguage>en-US</NeutralLanguage>
 		<CurrentDate>$([System.DateTime]::Now.ToString(yyyyMMdd))</CurrentDate>
-		<OutputType>Exe</OutputType>
 		<TargetFramework>net6</TargetFramework>
-		<TargetType>library</TargetType>
 		<Authors>Microsoft</Authors>
 		<RootNamespace>Microsoft.Azure.Cosmos.FaultInjection</RootNamespace>
 		<AssemblyName>Microsoft.Azure.Cosmos.FaultInjection</AssemblyName>

Microsoft.Azure.Cosmos/FaultInjection/src/FaultInjectionServerErrorResultBuilder.cs

@@ -97,7 +97,8 @@ public FaultInjectionServerErrorResultBuilder WithInjectionRate(double injection
         public FaultInjectionServerErrorResult Build()
         {
             if ((this.serverErrorType == FaultInjectionServerErrorType.ResponseDelay
-                || this.serverErrorType == FaultInjectionServerErrorType.ConnectionDelay)
+                || this.serverErrorType == FaultInjectionServerErrorType.ConnectionDelay
+                || this.serverErrorType == FaultInjectionServerErrorType.SendDelay)
                 && !this.isDelaySet)
             {
                 throw new ArgumentNullException(nameof(this.delay), "Argument 'delay' required for server error type: " + this.serverErrorType);

Microsoft.Azure.Cosmos/FaultInjection/src/FaultInjector.cs

@@ -16,6 +16,11 @@ public class FaultInjector : IFaultInjector
 
         public FaultInjector(List<FaultInjectionRule> rules)
         {
+            if (rules == null)
+            {
+                throw new ArgumentNullException(nameof(rules));
+            }
+
             this.chaosInterceptorFactory = new ChaosInterceptorFactory(rules);
         }
 

Microsoft.Azure.Cosmos/FaultInjection/src/implementation/FaultInjectionApplicationContext.cs

@@ -26,15 +26,29 @@ public FaultInjectionApplicationContext()
 
         internal void AddRuleExecution(string ruleId, Guid activityId)
         {
-            if(!this.executionsByRuleId.TryAdd(ruleId, new List<(DateTime, Guid)>() { (DateTime.UtcNow, activityId) }))
-            {
-                this.executionsByRuleId[ruleId].Add((DateTime.UtcNow, activityId));
-            }
+            this.executionsByRuleId.AddOrUpdate(
+                ruleId,
+                _ => new List<(DateTime, Guid)>() { (DateTime.UtcNow, activityId) },
+                (_, existing) =>
+                {
+                    lock (existing)
+                    {
+                        existing.Add((DateTime.UtcNow, activityId));
+                    }
+                    return existing;
+                });
 
-            if (!this.executionsByActivityId.TryAdd(activityId, new List<(DateTime, string)>() { (DateTime.UtcNow, ruleId) }))
-            {
-                this.executionsByActivityId[activityId].Add((DateTime.UtcNow, ruleId));
-            }
+            this.executionsByActivityId.AddOrUpdate(
+                activityId,
+                _ => new List<(DateTime, string)>() { (DateTime.UtcNow, ruleId) },
+                (_, existing) =>
+                {
+                    lock (existing)
+                    {
+                        existing.Add((DateTime.UtcNow, ruleId));
+                    }
+                    return existing;
+                });
 
             this.values.Add((DateTime.UtcNow, ruleId, activityId));
         }