[Instrumentation.AspNet] pass http.request.method to sampler

src/OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule/ActivityHelper.cs

@@ -7,6 +7,7 @@
 using OpenTelemetry.Context;
 using OpenTelemetry.Context.Propagation;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Instrumentation.AspNet;
 
@@ -20,6 +21,7 @@ internal static class ActivityHelper
     /// </summary>
     internal const string ContextKey = "__AspnetInstrumentationContext__";
     internal static readonly object StartedButNotSampledObj = new();
+    internal static readonly RequestDataHelper RequestDataHelper = new(configureByHttpKnownMethodsEnvironmentalVariable: true);
 
     private const string BaggageSlotName = "otel.baggage";
     private static readonly Func<HttpRequest, string, IEnumerable<string>> HttpRequestHeaderValuesGetter = (request, name) => request.Headers.GetValues(name);
@@ -28,7 +30,7 @@ internal static class ActivityHelper
         typeof(ActivityHelper).Assembly.GetPackageVersion());
 
     [ThreadStatic]
-    private static KeyValuePair<string, object?>[]? cachedTagsStorage;
+    private static List<KeyValuePair<string, object?>>? cachedTagsStorage;
 
     /// <summary>
     /// Try to get the started <see cref="Activity"/> for the running <see
@@ -63,25 +65,29 @@ public static bool HasStarted(HttpContext context, out Activity? aspNetActivity)
     {
         PropagationContext propagationContext = textMapPropagator.Extract(default, context.Request, HttpRequestHeaderValuesGetter);
 
-        KeyValuePair<string, object?>[]? tags;
-        if (context.Request?.Unvalidated?.Path is string path)
-        {
-            tags = cachedTagsStorage ??= new KeyValuePair<string, object?>[1];
+        string? path = context.Request?.Unvalidated?.Path;
+        string? originalHttpMethod = context.Request?.HttpMethod;
 
-            tags[0] = new KeyValuePair<string, object?>("url.path", path);
-        }
-        else
+        string normalizedHttpMethod = RequestDataHelper.GetNormalizedHttpMethod(originalHttpMethod ?? string.Empty);
+
+        List<KeyValuePair<string, object?>> tags = cachedTagsStorage ??= new List<KeyValuePair<string, object?>>(3); // use max capacity
+
+        if (path is not null)
         {
-            tags = null;
+            tags.Add(new KeyValuePair<string, object?>(SemanticConventions.AttributeUrlPath, path));
         }
 
-        Activity? activity = AspNetSource.StartActivity(TelemetryHttpModule.AspNetActivityName, ActivityKind.Server, propagationContext.ActivityContext, tags);
+        tags.Add(new KeyValuePair<string, object?>(SemanticConventions.AttributeHttpRequestMethod, normalizedHttpMethod));
 
-        if (tags is not null)
+        if (originalHttpMethod != null && originalHttpMethod != normalizedHttpMethod)
         {
-            tags[0] = default;
+            tags.Add(new KeyValuePair<string, object?>(SemanticConventions.AttributeHttpRequestMethodOriginal, originalHttpMethod));
         }
 
+        Activity? activity = AspNetSource.StartActivity(TelemetryHttpModule.AspNetActivityName, ActivityKind.Server, propagationContext.ActivityContext, tags);
+
+        tags.Clear();
+
         if (activity != null)
         {
             if (textMapPropagator is not TraceContextPropagator)

src/OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule/CHANGELOG.md

@@ -2,13 +2,14 @@
 
 ## Unreleased
 
-* `TelemetryHttpModule` will now pass the `url.path` tag (set to
-  [Request.Unvalidated.Path](https://learn.microsoft.com/dotnet/api/system.web.unvalidatedrequestvalues.path))
+* `TelemetryHttpModule` will now pass the `http.request.method`
+  and the `url.path` tags (set to [Request.Unvalidated.Path](https://learn.microsoft.com/dotnet/api/system.web.unvalidatedrequestvalues.path))
   when starting `Activity` instances for incoming requests so that it is
   available to samplers and may be used to influence the sampling decision made
   by [custom
   implementations](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/extending-the-sdk#sampler).
-  ([#1871](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/1871))
+  ([#1871](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/1871),
+   [#2023](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2023))
 
 ## 1.9.0-beta.1
 

src/OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule/OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule.csproj

@@ -18,6 +18,8 @@
     <Compile Include="$(RepoRoot)\src\Shared\AssemblyVersionExtensions.cs" Link="Includes\AssemblyVersionExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\ExceptionExtensions.cs" Link="Includes\ExceptionExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\Guard.cs" Link="Includes\Guard.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\RequestDataHelper.cs" Link="Includes\RequestDataHelper.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\SemanticConventions.cs" Link="Includes\SemanticConventions.cs" />
   </ItemGroup>
 
   <ItemGroup>

src/OpenTelemetry.Instrumentation.AspNet/README.md

@@ -146,8 +146,9 @@ below.
 > OpenTelemetry has the concept of a
 [Sampler](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#sampling).
 When using `OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule` the
-`url.path` tag is supplied automatically to samplers when telemetry is started
-for incoming requests. It is recommended to use a sampler which inspects
+`url.path` in addition to `http.request.method` tag are supplied automatically
+to samplers when telemetry is started for incoming requests.
+It is recommended to use a sampler which inspects
 `url.path` (as opposed to the `Filter` option described below) in order to
 perform filtering as it will prevent child spans from being created and bypass
 data collection for anything NOT recorded by the sampler. The sampler approach

test/OpenTelemetry.Instrumentation.AspNet.Tests/HttpInListenerTests.cs

@@ -146,6 +146,8 @@ public void AspNetRequestsAreCollectedSuccessfully(
                     new TestSampler(SamplingDecision.RecordAndSample)
                     {
                         ExpectedUrlPath = expectedUrlPath,
+                        ExpectedHttpRequestMethod = expectedRequestMethod,
+                        ExpectedOriginalRequestMethod = expectedOriginalRequestMethod,
                     })
                 .Build())
             {
@@ -256,7 +258,7 @@ public void ExtractContextIrrespectiveOfSamplingDecision(SamplingDecision sampli
         var activityProcessor = new TestActivityProcessor();
         Sdk.SetDefaultTextMapPropagator(propagator);
         using (var tracerProvider = Sdk.CreateTracerProviderBuilder()
-            .SetSampler(new TestSampler(samplingDecision))
+            .SetSampler(new TestSampler(samplingDecision) { ExpectedHttpRequestMethod = "GET", ExpectedUrlPath = "/" })
             .AddAspNetInstrumentation()
             .AddProcessor(activityProcessor).Build())
         {
@@ -314,13 +316,45 @@ private class TestSampler(SamplingDecision samplingDecision) : Sampler
 
         public string? ExpectedUrlPath { get; set; }
 
+        public string? ExpectedHttpRequestMethod { get; set; }
+
+        public string? ExpectedOriginalRequestMethod { get; set; }
+
         public override SamplingResult ShouldSample(in SamplingParameters samplingParameters)
         {
+            var expectedTagsCount = 0;
+            Assert.NotNull(samplingParameters.Tags);
             if (!string.IsNullOrEmpty(this.ExpectedUrlPath))
             {
-                Assert.NotNull(samplingParameters.Tags);
                 Assert.Contains(samplingParameters.Tags, t => t.Key == "url.path" && (t.Value as string) == this.ExpectedUrlPath);
+                expectedTagsCount++;
+            }
+            else
+            {
+                Assert.DoesNotContain(samplingParameters.Tags, t => t.Key == "url.path");
+            }
+
+            if (!string.IsNullOrEmpty(this.ExpectedHttpRequestMethod))
+            {
+                Assert.Contains(samplingParameters.Tags, t => t.Key == "http.request.method" && (t.Value as string) == this.ExpectedHttpRequestMethod);
+                expectedTagsCount++;
+            }
+            else
+            {
+                Assert.DoesNotContain(samplingParameters.Tags, t => t.Key == "http.request.method");
+            }
+
+            if (!string.IsNullOrEmpty(this.ExpectedOriginalRequestMethod))
+            {
+                Assert.Contains(samplingParameters.Tags, t => t.Key == "http.request.method_original" && (t.Value as string) == this.ExpectedOriginalRequestMethod);
+                expectedTagsCount++;
             }
+            else
+            {
+                Assert.DoesNotContain(samplingParameters.Tags, t => t.Key == "http.request.method_original");
+            }
+
+            Assert.Equal(expectedTagsCount, samplingParameters.Tags.Count());
 
             return new SamplingResult(this.samplingDecision);
         }