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

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

@@ -64,22 +64,35 @@ 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? method = context.Request?.HttpMethod;
 
-            tags[0] = new KeyValuePair<string, object?>("url.path", path);
-        }
-        else
+        // Determine the number of available tags and initialize the array accordingly
+        int tagCount = (path is not null ? 1 : 0) + (method is not null ? 1 : 0);
+        tags = tagCount > 0 ? cachedTagsStorage ??= new KeyValuePair<string, object?>[tagCount] : null;
+
+        int tagIndex = 0;
+        if (tags is not null)
         {
-            tags = null;
+            if (path is not null)
+            {
+                tags[tagIndex++] = new KeyValuePair<string, object?>("url.path", path);
+            }
+
+            if (method is not null)
+            {
+                tags[tagIndex] = new KeyValuePair<string, object?>("http.request.method", method);
+            }
         }
 
         Activity? activity = AspNetSource.StartActivity(TelemetryHttpModule.AspNetActivityName, ActivityKind.Server, propagationContext.ActivityContext, tags);
 
         if (tags is not null)
         {
-            tags[0] = default;
+            for (int i = 0; i < tags.Length; i++)
+            {
+                tags[i] = default(KeyValuePair<string, object?>);
+            }
         }
 
         if (activity != null)

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/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,7 @@ public void AspNetRequestsAreCollectedSuccessfully(
                     new TestSampler(SamplingDecision.RecordAndSample)
                     {
                         ExpectedUrlPath = expectedUrlPath,
+                        ExpectedHttpRequestMethod = expectedRequestMethod,
                     })
                 .Build())
             {
@@ -314,6 +315,8 @@ private class TestSampler(SamplingDecision samplingDecision) : Sampler
 
         public string? ExpectedUrlPath { get; set; }
 
+        public string? ExpectedHttpRequestMethod { get; set; }
+
         public override SamplingResult ShouldSample(in SamplingParameters samplingParameters)
         {
             if (!string.IsNullOrEmpty(this.ExpectedUrlPath))
@@ -322,6 +325,12 @@ public override SamplingResult ShouldSample(in SamplingParameters samplingParame
                 Assert.Contains(samplingParameters.Tags, t => t.Key == "url.path" && (t.Value as string) == this.ExpectedUrlPath);
             }
 
+            if (!string.IsNullOrEmpty(this.ExpectedHttpRequestMethod))
+            {
+                Assert.NotNull(samplingParameters.Tags);
+                Assert.Contains(samplingParameters.Tags, t => t.Key == "http.request.method" && (t.Value as string) == this.ExpectedHttpRequestMethod);
+            }
+
             return new SamplingResult(this.samplingDecision);
         }
     }