test: Map dataSystem.fdv1Fallback JSON field with explicit JsonPropertyName

The contract-test service uses System.Text.Json with PropertyNamingPolicy =
CamelCase. CamelCase converts the C# property name FDv1Fallback to
"fDv1Fallback" (only the first character lowercased), but the harness
sends the field as "fdv1Fallback" (lowercase 'd' too). The mismatch made
sdkParams.DataSystem.FDv1Fallback always null, which meant
dataSystemBuilder.FDv1FallbackSynchronizer(...) was never called, which
meant dataSystemConfiguration.FDv1FallbackSynchronizer was null, which
caused the OUTER composite's FDv1 fallback factory to throw NRE the moment
the action applier tried to invoke it.

Add an explicit [JsonPropertyName("fdv1Fallback")] attribute so the
deserializer accepts the harness's wire format. Also remove the temporary
debug logging from CompositeSource and SdkClientEntity that was used to
identify the bug.

Author: keelerm84

pkgs/sdk/server/contract-tests/Representations.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
 using LaunchDarkly.Sdk;
 
 // Note, in order for System.Text.Json serialization/deserialization to work correctly, the members of
@@ -155,7 +156,9 @@ public class SdkConfigDataSystemParams
         public SdkConfigDataSynchronizerParams[] Synchronizers { get; set; }
         // FDv1Fallback configures the SDK's FDv1 Fallback Synchronizer, which is engaged only when
         // the LaunchDarkly server returns the FDv1 fallback directive. It is distinct from the FDv2
-        // Primary/Fallback Synchronizers above.
+        // Primary/Fallback Synchronizers above. The harness sends this as "fdv1Fallback" (lowercase
+        // 'd'); we override the default CamelCase mapping (which would produce "fDv1Fallback").
+        [JsonPropertyName("fdv1Fallback")]
         public SdkConfigPollingParams FDv1Fallback { get; set; }
         public string PayloadFilter { get; set; }
     }

pkgs/sdk/server/contract-tests/SdkClientEntity.cs

@@ -509,10 +509,8 @@ private static Configuration BuildSdkConfig(SdkConfigParams sdkParams, ILogAdapt
                 // Configure the FDv1 Fallback Synchronizer directly from dataSystem.fdv1Fallback,
                 // separate from the FDv2 Primary/Fallback synchronizer chain. This is engaged only
                 // in response to a server-directed FDv1 Fallback Directive.
-                Console.WriteLine($"DEBUG: tag={tag} FDv1Fallback null? {sdkParams.DataSystem.FDv1Fallback == null}");
                 if (sdkParams.DataSystem.FDv1Fallback != null)
                 {
-                    Console.WriteLine($"DEBUG: tag={tag} FDv1Fallback.BaseUri={sdkParams.DataSystem.FDv1Fallback.BaseUri}");
                     if (sdkParams.DataSystem.FDv1Fallback.BaseUri != null)
                     {
                         endpoints.Polling(sdkParams.DataSystem.FDv1Fallback.BaseUri);
@@ -526,7 +524,6 @@ private static Configuration BuildSdkConfig(SdkConfigParams sdkParams, ILogAdapt
                     }
 
                     dataSystemBuilder.FDv1FallbackSynchronizer(fdv1FallbackBuilder);
-                    Console.WriteLine($"DEBUG: tag={tag} dataSystemBuilder.FDv1FallbackSynchronizer set to {fdv1FallbackBuilder}");
                 }
 
                 builder.DataSystem(dataSystemBuilder);

pkgs/sdk/server/src/Internal/DataSources/CompositeDataSource/CompositeSource.cs

@@ -152,7 +152,6 @@ private void EnqueueAction(Action action)
             {
                 if (_actionQueueShutdown)
                 {
-                    _log.Debug("{0} EnqueueAction skipped: action queue is shutdown.", _compositeDescription);
                     return;
                 }
                 _pendingActions.Enqueue(action);
@@ -165,7 +164,6 @@ private void EnqueueAction(Action action)
 
             if (shouldProcess)
             {
-                _log.Debug("{0} EnqueueAction starting Task.Run for ProcessQueuedActions.", _compositeDescription);
                 // Process actions on a background thread to prevent blocking the caller
                 // and allow Start() to return even when actions are continuously enqueued
                 _ = Task.Run(() => ProcessQueuedActions());
@@ -177,7 +175,6 @@ private void EnqueueAction(Action action)
         /// </summary>
         private void ProcessQueuedActions()
         {
-            _log.Debug("{0} ProcessQueuedActions started.", _compositeDescription);
             while (true)
             {
                 Action action;
@@ -186,8 +183,6 @@ private void ProcessQueuedActions()
                     // Check if disposed to allow disposal to interrupt action processing
                     if (_actionQueueShutdown || _pendingActions.Count == 0)
                     {
-                        _log.Debug("{0} ProcessQueuedActions exiting: shutdown={1}, count={2}.",
-                            _compositeDescription, _actionQueueShutdown, _pendingActions.Count);
                         _isProcessingActions = false;
                         return;
                     }
@@ -204,27 +199,23 @@ private void ProcessQueuedActions()
                 {
                     action();
                 }
-                catch (Exception ex)
+                catch
                 {
-                    _log.Debug("{0} ProcessQueuedActions: action threw {1}.", _compositeDescription, ex);
                     // Continue processing remaining actions even if one fails
+                    // TODO: need to add logging, will add in next PR
                 }
             }
         }
 
         // This method must only be called while holding _lock.
         private void TryFindNextUnderLock()
         {
-            _log.Debug("{0} TryFindNextUnderLock entered. _currentDataSource null? {1}",
-                _compositeDescription, _currentDataSource == null);
             if (_currentDataSource != null)
             {
                 return;
             }
 
             var entry = _sourcesList.Next();
-            _log.Debug("{0} TryFindNextUnderLock: entry.Factory null? {1}",
-                _compositeDescription, entry.Factory == null);
 
             if (entry.Factory == null)
             {
@@ -253,26 +244,13 @@ private void TryFindNextUnderLock()
                 observers = Array.Empty<IDataSourceObserver>();
             }
 
-            _log.Debug("{0} TryFindNextUnderLock: observers built, invoking factory", _compositeDescription);
-
             // here we wrap the sink in observability so that we can trigger actions, the sanitized sink is
             // invoked before the observers to ensure actions don't trigger before data can propagate
             var observableUpdates = new ObservableDataSourceUpdates(_sanitizedUpdateSink, observers);
             var disableableUpdates = _disableableTracker.WrapAndTrack(observableUpdates);
 
             _currentEntry = entry;
-            try
-            {
-                _currentDataSource = entry.Factory(disableableUpdates);
-                _log.Debug("{0} TryFindNextUnderLock: factory returned {1}",
-                    _compositeDescription, _currentDataSource?.ToString() ?? "null");
-            }
-            catch (Exception ex)
-            {
-                _log.Debug("{0} TryFindNextUnderLock: factory threw {1}",
-                    _compositeDescription, ex);
-                throw;
-            }
+            _currentDataSource = entry.Factory(disableableUpdates);
         }
 
         #region ICompositeSourceActionable
@@ -281,16 +259,13 @@ public Task<bool> StartCurrent()
         {
             if (_disposed)
             {
-                _log.Debug("{0} StartCurrent skipped: composite disposed.", _compositeDescription);
                 return Task.FromResult(false);
             }
 
-            _log.Debug("{0} StartCurrent enqueuing action.", _compositeDescription);
             var tcs = new TaskCompletionSource<bool>();
 
             EnqueueAction(() =>
             {
-                _log.Debug("{0} StartCurrent action running.", _compositeDescription);
                 try
                 {
                     IDataSource dataSourceToStart;
@@ -301,8 +276,6 @@ public Task<bool> StartCurrent()
                         dataSourceToStart = _currentDataSource;
                         disposed = _disposed;
                     }
-                    _log.Debug("{0} StartCurrent action: dataSourceToStart={1}, disposed={2}.",
-                        _compositeDescription, dataSourceToStart?.ToString() ?? "null", disposed);
 
                     if (disposed)
                     {