feat: Add graphql query to get sampling config. (#181)

## Summary

Uses the sampling tace and log exporter with the sampling configuration.

The approach used for GraphQL is a bit different on this one. The types
are not tool generated, so they would require updating, but it does
remove any runtime dependency. I may consider back-porting this approach
to reduce dependencies in the other plugins.

## How did you test this change?

Unit tests.
Manual testing.

## Are there any deployment considerations?

<!--
 Backend - Do we need to consider migrations or backfilling data?
-->

Author: kinyoklion

sdk/@launchdarkly/observability-dotnet/AspSampleApp/Program.cs

@@ -52,6 +52,11 @@
     .WithName("GetWeatherForecast")
     .WithOpenApi();
 
+app.MapGet("/crash", () =>
+{
+    throw new NotImplementedException();
+}).WithName("Crash").WithOpenApi();
+
 app.Run();
 
 record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/LaunchDarkly.Observability.csproj

@@ -28,6 +28,8 @@
   <!-- Allow the testing project to access internals. -->
   <ItemGroup Condition="'$(Configuration)'!='Release'">
     <InternalsVisibleTo Include="LaunchDarkly.Observability.Tests" />
+    <!-- Dynamically generated assembly used by Moq. Required for mocking in unit tests. -->
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2"/>
   </ItemGroup>
 
   <PropertyGroup Condition="'$(Configuration)'=='Release' And '$(SKIP_SIGNING)'!='true'">

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Logging/DebugLogger.cs

@@ -0,0 +1,30 @@
+using System.Threading;
+using LaunchDarkly.Logging;
+
+namespace LaunchDarkly.Observability.Logging
+{
+    internal static class DebugLogger
+    {
+        private static Logger _logger;
+
+        /// <summary>
+        /// Set 
+        /// </summary>
+        /// <param name="logger"></param>
+        public static void SetLogger(Logger logger)
+        {
+            if (logger == null)
+            {
+                Volatile.Write(ref _logger, null);
+                return;
+            }
+
+            Volatile.Write(ref _logger, logger.SubLogger("LaunchDarklyObservability"));
+        }
+
+        public static void DebugLog(string message)
+        {
+            Volatile.Read(ref _logger)?.Debug(message);
+        }
+    }
+}

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityExtensions.cs

@@ -1,5 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using LaunchDarkly.Logging;
+using LaunchDarkly.Observability.Logging;
+using LaunchDarkly.Observability.Otel;
+using LaunchDarkly.Observability.Sampling;
 using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Resources;
 using OpenTelemetry.Trace;
@@ -21,11 +27,29 @@ public static class ObservabilityExtensions
         private const int FlushIntervalMs = 5 * 1000;
         private const int MaxExportBatchSize = 10000;
         private const int MaxQueueSize = 10000;
+        private const int ExportTimeoutMs = 30000;
 
         private const string TracesPath = "/v1/traces";
         private const string LogsPath = "/v1/logs";
         private const string MetricsPath = "/v1/metrics";
 
+        private static async Task GetSamplingConfigAsync(CustomSampler sampler, ObservabilityConfig config)
+        {
+            using (var samplingClient = new SamplingConfigClient(config.BackendUrl))
+            {
+                try
+                {
+                    var res = await samplingClient.GetSamplingConfigAsync(config.SdkKey).ConfigureAwait(false);
+                    if (res == null) return;
+                    sampler.SetConfig(res);
+                }
+                catch (Exception ex)
+                {
+                    DebugLogger.DebugLog($"Exception while getting sampling config: {ex}");
+                }
+            }
+        }
+
         private static IEnumerable<KeyValuePair<string, object>> GetResourceAttributes(ObservabilityConfig config)
         {
             var attrs = new List<KeyValuePair<string, object>>();
@@ -41,10 +65,16 @@ private static IEnumerable<KeyValuePair<string, object>> GetResourceAttributes(O
         }
 
         internal static void AddLaunchDarklyObservabilityWithConfig(this IServiceCollection services,
-            ObservabilityConfig config)
+            ObservabilityConfig config, Logger logger = null)
         {
+            DebugLogger.SetLogger(logger);
             var resourceAttributes = GetResourceAttributes(config);
 
+            var sampler = new CustomSampler();
+
+            // Asynchronously get sampling config.
+            _ = Task.Run(() => GetSamplingConfigAsync(sampler, config));
+
             var resourceBuilder = ResourceBuilder.CreateDefault();
             if (!string.IsNullOrWhiteSpace(config.ServiceName))
             {
@@ -60,18 +90,21 @@ internal static void AddLaunchDarklyObservabilityWithConfig(this IServiceCollect
                     .AddWcfInstrumentation()
                     .AddQuartzInstrumentation()
                     .AddAspNetCoreInstrumentation(options => { options.RecordException = true; })
-                    .AddSqlClientInstrumentation(options => { options.SetDbStatementForText = true; })
-                    .AddOtlpExporter(options =>
-                    {
-                        options.Endpoint = new Uri(config.OtlpEndpoint + TracesPath);
-                        options.Protocol = ExportProtocol;
-                        options.BatchExportProcessorOptions.MaxExportBatchSize = MaxExportBatchSize;
-                        options.BatchExportProcessorOptions.MaxQueueSize = MaxQueueSize;
-                        options.BatchExportProcessorOptions.ScheduledDelayMilliseconds = FlushIntervalMs;
-                    });
+                    .AddSqlClientInstrumentation(options => { options.SetDbStatementForText = true; });
+
+                // Always use sampling exporter for traces
+                var samplingTraceExporter = new SamplingTraceExporter(sampler, new OtlpExporterOptions
+                {
+                    Endpoint = new Uri(config.OtlpEndpoint + TracesPath),
+                    Protocol = OtlpExportProtocol.HttpProtobuf,
+                });
+
+                tracing.AddProcessor(new BatchActivityExportProcessor(samplingTraceExporter, MaxQueueSize,
+                    FlushIntervalMs, ExportTimeoutMs, MaxExportBatchSize));
             }).WithLogging(logging =>
             {
                 logging.SetResourceBuilder(resourceBuilder)
+                    .AddProcessor(new SamplingLogProcessor(sampler))
                     .AddOtlpExporter(options =>
                     {
                         options.Endpoint = new Uri(config.OtlpEndpoint + LogsPath);

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityPlugin.cs

@@ -73,7 +73,7 @@ public override void Register(ILdClient client, EnvironmentMetadata metadata)
         {
             if (_services == null || _config == null) return;
             var config = _config.BuildConfig(metadata.Credential);
-            _services.AddLaunchDarklyObservabilityWithConfig(config);
+            _services.AddLaunchDarklyObservabilityWithConfig(config, client.GetLogger());
         }
 
         /// <inheritdoc />

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Sampling/CustomSampler.cs

@@ -50,7 +50,7 @@ internal class CustomSampler : IExportSampler
         private readonly SamplerFunc _sampler;
         private readonly ThreadSafeConfig _config = new ThreadSafeConfig();
         private readonly ConcurrentDictionary<string, Regex> _regexCache = new ConcurrentDictionary<string, Regex>();
-        
+
         private const string SamplingRatioAttribute = "launchdarkly.sampling.ratio";
 
         /// <summary>
@@ -246,7 +246,7 @@ private bool MatchesSpanConfig(SamplingConfig.SpanSamplingConfig config, Activit
         public SamplingResult SampleSpan(Activity span)
         {
             var config = _config.GetSamplingConfig();
-            if (!(config?.Spans.Count > 0)) return new SamplingResult { Sample = true };
+            if (!(config?.Spans?.Count > 0)) return new SamplingResult { Sample = true };
             foreach (var spanConfig in config.Spans)
             {
                 if (MatchesSpanConfig(spanConfig, span))
@@ -297,7 +297,7 @@ private bool MatchesLogConfig(SamplingConfig.LogSamplingConfig config, LogRecord
         public SamplingResult SampleLog(LogRecord record)
         {
             var config = _config.GetSamplingConfig();
-            if (!(config?.Logs.Count > 0)) return new SamplingResult { Sample = true };
+            if (!(config?.Logs?.Count > 0)) return new SamplingResult { Sample = true };
             foreach (var logConfig in config.Logs)
             {
                 if (MatchesLogConfig(logConfig, record))

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Sampling/HttpClientWrapper.cs

@@ -0,0 +1,38 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LaunchDarkly.Observability.Sampling
+{
+    /// <summary>
+    /// Minimal wrapper around HttpClient that implements IHttpClient
+    /// </summary>
+    internal class HttpClientWrapper : IHttpClient, System.IDisposable
+    {
+        private readonly HttpClient _httpClient;
+
+        /// <summary>
+        /// Initializes a new instance of the HttpClientWrapper
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance to wrap</param>
+        public HttpClientWrapper(HttpClient httpClient)
+        {
+            _httpClient = httpClient ?? throw new System.ArgumentNullException(nameof(httpClient));
+        }
+
+        /// <inheritdoc />
+        public Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content,
+            CancellationToken cancellationToken = default)
+        {
+            return _httpClient.PostAsync(requestUri, content, cancellationToken);
+        }
+
+        /// <summary>
+        /// Releases all resources used by the HttpClientWrapper
+        /// </summary>
+        public void Dispose()
+        {
+            _httpClient?.Dispose();
+        }
+    }
+}

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Sampling/IHttpClient.cs

@@ -0,0 +1,22 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace LaunchDarkly.Observability.Sampling
+{
+    /// <summary>
+    /// Interface for HTTP client operations used by SamplingConfigClient
+    /// </summary>
+    internal interface IHttpClient
+    {
+        /// <summary>
+        /// Sends a POST request to the specified URI with the provided content
+        /// </summary>
+        /// <param name="requestUri">The URI to send the request to</param>
+        /// <param name="content">The HTTP content to send</param>
+        /// <param name="cancellationToken">Cancellation token for the operation</param>
+        /// <returns>The HTTP response message</returns>
+        Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content,
+            CancellationToken cancellationToken = default);
+    }
+}