Avoid generating resource name that will be thrown away if it's not required (#7312)

## Summary of changes

- Add `HasResourceBasedSamplingRule` to `ITraceSampler` and
`ISpanSampler`
- If there are no resource-based sampling rule, we can avoid calculating
the resource name

## Reason for change

In #6936, we fixed an issue where resource-based sampling wasn't work.
This was because we can't calculate the "final" resource name for a span
until after the MVC framework has run. Previously, we were delaying the
resource name calculation to this point. For the fix, we calculate a
_provisional_ resource name, which we subsequently change. It's
sub-optimal in that

- The resource name changes
- If the customer _isn't_ using resource based sampling, we are
allocating for ultimately no benefit

This PR exposes a property which lets us check whether resource based
sampling is being used. If it is, then we _must_ calculate the resource
name up-front. If it's not, then we can delay creation for performance
reasons.

## Implementation details

- Expose `IsResourceBasedSamplingRule` on `ISamplingRule` and
`ISpanSamplingRule`
- Expose `HasResourceBasedSamplingRule` on `ISampler` and `ISpanSampler`
- Expose `HasResourceBasedSamplingRule` on `PerTraceSettings`
- Check this value prior to creating the initial resource name in
`TracingHttpModule`

## Test coverage

- Added unit tests for the new properties
- Existing integration tests cover the implementation in IIS

## Other details

This is mostly a setup for adding a fix to the ASP.NET Core provider to
give the same functionality.

In general, it feels a bit hacky, and it assumes that nothing _else_
(other than sampling) is dependent on the resource name. _Ideally_, we
would have a system like @dougqh has discussed previously to evaluate
properties lazily based on the available data in the span. But until
then, this is a a stop gap which means we can avoid the perf hit for the
majority of customers who _don't_ have resource-based sampling.

Part of a stack
- #7311
- #7312 👈
- #7316

---------

Co-authored-by: Steven Bouwkamp <[email protected]>

Author: andrewlock

tracer/src/Datadog.Trace/AspNet/TracingHttpModule.cs

@@ -192,7 +192,9 @@ private void OnBeginRequest(object sender, EventArgs eventArgs)
                 // Attempt to set Resource Name to something that will be close to what is expected
                 // Note: we will go and re-do it in OnEndRequest, but doing it here will allow for resource-based sampling
                 // this likely won't be perfect - but we need something to try and allow resource-based sampling to function
-                var resourceName = BuildResourceName(tracer, httpRequest);
+                var resourceName = tracer.TracerManager.PerTraceSettings.HasResourceBasedSamplingRule
+                                       ? BuildResourceName(tracer, httpRequest)
+                                       : null;
                 scope.Span.DecorateWebServerSpan(resourceName: resourceName, httpMethod, host, url, userAgent, tags);
                 tracer.TracerManager.SpanContextPropagator.AddHeadersToSpanAsTags(scope.Span, headers, tracer.Settings.HeaderTags, defaultTagPrefix: SpanContextPropagator.HttpRequestHeadersTagPrefix);
 

tracer/src/Datadog.Trace/Ci/Sampling/CISampler.cs

@@ -11,6 +11,9 @@ namespace Datadog.Trace.Ci.Sampling
 {
     internal class CISampler : ITraceSampler
     {
+        // The Ci Sampler keeps all spans, so it doesn't depend on the resource name
+        public bool HasResourceBasedSamplingRule => false;
+
         public SamplingDecision MakeSamplingDecision(Span span)
         {
             return new SamplingDecision(SamplingPriorityValues.UserKeep, mechanism: null, rate: null, limiterRate: null);

tracer/src/Datadog.Trace/Configuration/PerTraceSettings.cs

@@ -22,6 +22,7 @@ public PerTraceSettings(ITraceSampler? traceSampler, ISpanSampler? spanSampler,
             SpanSampler = spanSampler;
             ServiceNames = serviceNames;
             Schema = schema;
+            HasResourceBasedSamplingRule = (traceSampler?.HasResourceBasedSamplingRule ?? false) || (spanSampler?.HasResourceBasedSamplingRule ?? false);
         }
 
         public ITraceSampler? TraceSampler { get; }
@@ -32,6 +33,8 @@ public PerTraceSettings(ITraceSampler? traceSampler, ISpanSampler? spanSampler,
 
         public NamingSchema Schema { get; }
 
+        public bool HasResourceBasedSamplingRule { get; }
+
         internal string GetServiceName(Tracer tracer, string serviceName)
         {
             if (ServiceNames.TryGetValue(serviceName, out var name))

tracer/src/Datadog.Trace/Sampling/AgentSamplingRule.cs

@@ -28,6 +28,9 @@ internal class AgentSamplingRule : ISamplingRule
                                             Datadog.Trace.Sampling.SamplingMechanism.Default :
                                             Datadog.Trace.Sampling.SamplingMechanism.AgentRate;
 
+        // Agent sampling rules do not depend on span resource names, only service and environment names.
+        public bool IsResourceBasedSamplingRule => false;
+
         public bool IsMatch(Span span) => true;
 
         public float GetSamplingRate(Span span)

tracer/src/Datadog.Trace/Sampling/CustomSamplingRule.cs

@@ -50,6 +50,8 @@ _resourceNameRegex is null &&
             }
         }
 
+        public bool IsResourceBasedSamplingRule => _resourceNameRegex is not null;
+
         public abstract string Provenance { get; }
 
         public abstract string SamplingMechanism { get; }

tracer/src/Datadog.Trace/Sampling/GlobalSamplingRateRule.cs

@@ -18,6 +18,9 @@ public GlobalSamplingRateRule(float rate)
 
         public string SamplingMechanism => Datadog.Trace.Sampling.SamplingMechanism.LocalTraceSamplingRule;
 
+        // Doesn't depend on span at all
+        public bool IsResourceBasedSamplingRule => false;
+
         public bool IsMatch(Span span) => true;
 
         public float GetSamplingRate(Span span)

tracer/src/Datadog.Trace/Sampling/ISamplingRule.cs

@@ -11,6 +11,8 @@ internal interface ISamplingRule
     {
         string SamplingMechanism { get; }
 
+        bool IsResourceBasedSamplingRule { get; }
+
         bool IsMatch(Span span);
 
         float GetSamplingRate(Span span);

tracer/src/Datadog.Trace/Sampling/ISpanSampler.cs

@@ -12,6 +12,14 @@ namespace Datadog.Trace.Sampling
     /// </summary>
     internal interface ISpanSampler
     {
+        /// <summary>
+        /// Gets a value indicating whether the sampler contains a sampling rule that depends on span resource names.
+        /// </summary>
+        /// <remarks>Can be used to perform optimizations, such as delaying the creation of a resource name for spans
+        /// which are subsequently going to be sampled, or for which a resource name can't be accurately calculated</remarks>
+        /// <returns><c>true</c> if one of the registered rules depends on span resource names, <c>false</c> otherwise</returns>
+        bool HasResourceBasedSamplingRule { get; }
+
         /// <summary>
         ///     Makes a sampling decision on the given <paramref name="span"/> and adds necessary tags to the span.
         /// </summary>

tracer/src/Datadog.Trace/Sampling/ISpanSamplingRule.cs

@@ -28,6 +28,12 @@ internal interface ISpanSamplingRule
         /// </value>
         float? MaxPerSecond { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether the rule depends on span resource names.
+        /// </summary>
+        /// <returns><c>true</c> if the rule depends on span resource names, <c>false</c> otherwise</returns>
+        bool IsResourceBasedSamplingRule { get; }
+
         /// <summary>
         ///     Checks whether or not the <paramref name="span"/> matches the glob patterns defined by this rule.
         /// </summary>

tracer/src/Datadog.Trace/Sampling/ITraceSampler.cs

@@ -11,6 +11,14 @@ namespace Datadog.Trace.Sampling
 {
     internal interface ITraceSampler
     {
+        /// <summary>
+        /// Gets a value indicating whether the sampler contains a sampling rule that depends on span resource names.
+        /// </summary>
+        /// <remarks>Can be used to perform optimizations, such as delaying the creation of a resource name for spans
+        /// which are subsequently going to be sampled, or for which a resource name can't be accurately calculated</remarks>
+        /// <returns><c>true</c> if one of the registered rules depends on span resource names, <c>false</c> otherwise</returns>
+        bool HasResourceBasedSamplingRule { get; }
+
         void SetDefaultSampleRates(IReadOnlyDictionary<string, float> sampleRates);
 
         SamplingDecision MakeSamplingDecision(Span span);