Cache response in order to avoid unnecessary deserializations (#7320)

## Summary of changes
Cache agent's response to avoid unnecessary deserializations in case
sample rates haven't changed from previous response.
## Reason for change
Reduce performance overhead.
## Implementation details

## Test coverage

## Other details
This PR implements part of the functionality of this
[one](#7251). As
commented the rates versioning payload will be handled internally in the
native exporter but until it is available the response will be cached in
the same way as in the managed exporter.
<!-- Fixes #{issue} -->

<!-- ⚠️ Note: where possible, please obtain 2 approvals prior to
merging. Unless CODEOWNERS specifies otherwise, for external teams it is
typically best to have one review from a team member, and one review
from apm-dotnet. Trivial changes do not require 2 reviews. -->

Author: hoolioh

tracer/src/Datadog.Trace/LibDatadog/TraceExporter.cs

@@ -22,6 +22,7 @@ internal class TraceExporter : SafeHandle, IApi
 {
     private readonly IDatadogLogger _log;
     private readonly Action<Dictionary<string, float>> _updateSampleRates;
+    private string _cachedResponse;
 
     public TraceExporter(
         TraceExporterConfiguration configuration,
@@ -32,6 +33,7 @@ public TraceExporter(
         _updateSampleRates = updateSampleRates;
         _log = log ?? DatadogLogging.GetLoggerFor<TraceExporter>();
         _log.Debug("Creating new TraceExporter");
+        _cachedResponse = string.Empty;
         using var errPtr = NativeInterop.Exporter.New(out var ptr, configuration);
         errPtr.ThrowIfError();
         SetHandle(ptr);
@@ -134,6 +136,11 @@ private unsafe void Send(ArraySegment<byte> traces, int numberOfTraces, ref IntP
 
     private unsafe void ProcessResponse(IntPtr response)
     {
+        if (_updateSampleRates is null)
+        {
+            return;
+        }
+
         if (response == IntPtr.Zero)
         {
             // If response is Null bail out immediately.
@@ -149,8 +156,11 @@ private unsafe void ProcessResponse(IntPtr response)
         }
 
         var json = System.Text.Encoding.UTF8.GetString((byte*)body, len);
-        var apiResponse = JsonConvert.DeserializeObject<ApiResponse>(json);
-
-        _updateSampleRates(apiResponse.RateByService);
+        if (json != _cachedResponse)
+        {
+            var apiResponse = JsonConvert.DeserializeObject<ApiResponse>(json);
+            _updateSampleRates(apiResponse.RateByService);
+            _cachedResponse = json;
+        }
     }
 }

tracer/test/Datadog.Trace.IntegrationTests/LibDatadog/TraceExporterTests.cs

@@ -93,20 +93,37 @@ public async Task SendsTracesUsingDataPipeline(TestTransports transport)
                 span.Type = "test";
                 span.SetMetaStruct("test-meta-struct", metaStructBytes);
             }
+
+            using (var span2 = tracer.StartSpan("operationName2"))
+            {
+                span2.ResourceName = "resourceName2";
+                span2.Type = "test";
+                span2.SetMetaStruct("test-meta-struct", metaStructBytes);
+            }
         }
 
-        var recordedSpans = await agent.WaitForSpansAsync(1);
-        recordedSpans.Should().ContainSingle();
+        var recordedSpans = await agent.WaitForSpansAsync(2);
+        recordedSpans.Should().HaveCount(2);
 
-        var recordedSpan = recordedSpans.Should().ContainSingle().Subject;
-        recordedSpan.Name.Should().Be("operationName");
-        recordedSpan.Resource.Should().Be("resourceName");
-        recordedSpan.Service.Should().Be("default-service");
+        var firstSpan = recordedSpans.Should()
+                                        .Contain(s => s.Name == "operationName")
+                                        .Subject;
+        firstSpan.Resource.Should().Be("resourceName");
+        firstSpan.Service.Should().Be("default-service");
 
-        recordedSpan.MetaStruct.Should().ContainSingle();
-        var recordedMetaStructBytes = recordedSpan.MetaStruct["test-meta-struct"];
+        firstSpan.MetaStruct.Should().ContainSingle();
+        var recordedMetaStructBytes = firstSpan.MetaStruct["test-meta-struct"];
         recordedMetaStructBytes.Should().BeEquivalentTo(metaStructBytes);
 
+        var secondSpan = recordedSpans.Should()
+                                      .Contain(s => s.Name == "operationName2")
+                                      .Subject;
+        secondSpan.Resource.Should().Be("resourceName2");
+        secondSpan.Service.Should().Be("default-service");
+
+        var recordedMetaStructBytes2 = secondSpan.MetaStruct["test-meta-struct"];
+        recordedMetaStructBytes2.Should().BeEquivalentTo(metaStructBytes);
+
         var expectedRates = new Dictionary<string, float>
         {
             { "service:default-service,env:test", 1.0f },
@@ -115,6 +132,7 @@ public async Task SendsTracesUsingDataPipeline(TestTransports transport)
         sampleRateResponses.Should()
                            .NotBeEmpty()
                            .And.AllSatisfy(rates => rates.Should().BeEquivalentTo(expectedRates));
+        sampleRateResponses.Should().HaveCount(1);
 
         Dictionary<string, object> GetSettings()
         {