feat: add http.route attribute to open telemetry on requests

src/http/httpClient/HttpClientRequestAdapter.cs

@@ -114,8 +114,87 @@
             var telemetryPathValue = string.IsNullOrEmpty(decodedUriTemplate) ? string.Empty : queryParametersCleanupRegex.Replace(decodedUriTemplate, string.Empty);
             var span = activitySource?.StartActivity($"{methodName} - {telemetryPathValue}");
             span?.SetTag("url.uri_template", decodedUriTemplate);
+            if(!string.IsNullOrEmpty(telemetryPathValue))
+            {
+                var httpRoute = GetNormalizedHttpRoute(telemetryPathValue);
+                span?.SetTag("http.route", httpRoute);
+            }
             return span;
         }
+
+        /// <summary>
+        /// Normalizes the URI template into an HTTP route for observability by removing
+        /// the base URL placeholder and prefix, ensuring the route starts with "/".
+        /// </summary>
+        /// <param name="telemetryPathValue">The URI template path to normalize.</param>
+        /// <returns>The normalized HTTP route.</returns>
+        internal string GetNormalizedHttpRoute(string telemetryPathValue)
+        {
+#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_0_OR_GREATER
+            // Optimized path using spans to reduce string allocations
+            const string baseUrlPlaceholder = "{+baseurl}";
+            var span = telemetryPathValue.AsSpan();
+
+            // Remove the base URL placeholder if present
+            var placeholderIndex = span.IndexOf(baseUrlPlaceholder.AsSpan(), StringComparison.OrdinalIgnoreCase);
+            if(placeholderIndex >= 0)
+            {
+                // Concatenate parts around the placeholder - reduces allocations by using spans
+                var withoutPlaceholder = string.Concat(
+                    new string(span[..placeholderIndex]),
+                    new string(span[(placeholderIndex + baseUrlPlaceholder.Length)..])
+                );
+                span = withoutPlaceholder.AsSpan();
+            }
+
+            // Remove the base URL prefix if present (zero-allocation slice)
+            if(!string.IsNullOrEmpty(BaseUrl) && span.StartsWith(BaseUrl.AsSpan(), StringComparison.OrdinalIgnoreCase))
+            {
+                span = span[BaseUrl.Length..];
+            }
+
+            // Trim whitespace (zero-allocation)
+            span = span.Trim();
+
+            // If empty, return "/"
+            if(span.IsEmpty)
+            {
+                return "/";
+            }
+
+            // Trim leading slashes (zero-allocation slice)
+            span = span.TrimStart('/');
+
+            // Final allocation - create string with "/" prefix
+            return "/" + new string(span);
+#else
+            // Fallback for older frameworks
+            var httpRoute = telemetryPathValue;
+            const string baseUrlPlaceholder = "{+baseurl}";
+
+            // Remove the base URL placeholder if present
+            var baseUrlPlaceholderIndex = httpRoute.IndexOf(baseUrlPlaceholder, StringComparison.OrdinalIgnoreCase);
+            if(baseUrlPlaceholderIndex >= 0)
+            {
+                httpRoute = httpRoute.Remove(baseUrlPlaceholderIndex, baseUrlPlaceholder.Length);
+            }
+
+            // Remove the base URL prefix if the route starts with it
+            if(!string.IsNullOrEmpty(BaseUrl) && httpRoute.StartsWith(BaseUrl, StringComparison.OrdinalIgnoreCase))
+            {
+                httpRoute = httpRoute.Substring(BaseUrl!.Length);
+            }
+
+            // Normalize whitespace and ensure the route starts with "/"
+            httpRoute = httpRoute.Trim();
+            if(string.IsNullOrEmpty(httpRoute))
+            {
+                return "/";
+            }
+
+            return "/" + httpRoute.TrimStart('/');
+#endif
+        }
         /// <summary>
         /// Send a <see cref="RequestInformation"/> instance with a collection instance of <typeparam name="ModelType"></typeparam>
         /// </summary>
@@ -262,7 +341,7 @@
 #if NET5_0_OR_GREATER
         public async Task<ModelType?> SendPrimitiveAsync<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] ModelType>(RequestInformation requestInfo, Dictionary<string, ParsableFactory<IParsable>>? errorMapping = default, CancellationToken cancellationToken = default)
 #else
         public async Task<ModelType?> SendPrimitiveAsync<ModelType>(RequestInformation requestInfo, Dictionary<string, ParsableFactory<IParsable>>? errorMapping = default, CancellationToken cancellationToken = default)
 #endif
         {
             using var span = startTracingSpan(requestInfo, nameof(SendPrimitiveAsync));
@@ -427,7 +506,7 @@
                 activity?.SetTag("com.microsoft.kiota.response.type", result.GetType().FullName);
             }
         }
         private static async Task DrainAsync(HttpResponseMessage response, CancellationToken cancellationToken)
         {
             if(response.Content != null)
             {
@@ -522,13 +601,13 @@
             if(contentStream == Stream.Null || (contentStream.CanSeek && contentStream.Length == 0))
                 return null;// ensure a useful stream is passed to the factory
 #pragma warning disable CS0618 // Type or member is obsolete
             //TODO remove with v2
             var rootNode = pNodeFactory is IAsyncParseNodeFactory asyncParseNodeFactory ? await asyncParseNodeFactory.GetRootParseNodeAsync(responseContentType!, contentStream, cancellationToken).ConfigureAwait(false) : pNodeFactory.GetRootParseNode(responseContentType!, contentStream);
 #pragma warning restore CS0618 // Type or member is obsolete
             return rootNode;
         }
         private const string ClaimsKey = "claims";
         private const string BearerAuthenticationScheme = "Bearer";
         private async Task<HttpResponseMessage> GetHttpResponseMessageAsync(RequestInformation requestInfo, CancellationToken cancellationToken, Activity? activityForAttributes, string? claims = default, bool isStreamResponse = false)
         {
             using var span = activitySource?.StartActivity(nameof(GetHttpResponseMessageAsync));
@@ -612,7 +691,7 @@
             else throw new InvalidOperationException($"Could not convert the request information to a {typeof(T).Name}");
         }
 
         private HttpRequestMessage GetRequestMessageFromRequestInformation(RequestInformation requestInfo, Activity? activityForAttributes)
         {
             using var span = activitySource?.StartActivity(nameof(GetRequestMessageFromRequestInformation));
             SetBaseUrlForRequestInformation(requestInfo);// this method can also be called from a different context so ensure the baseUrl is added.