Skip to content

Improve performance of AspNetCoreResourceNameHelper.SimplifyRouteTemplate#8170

Merged
andrewlock merged 8 commits intomasterfrom
andrew/aspnetcore-perf/route-templates
Feb 18, 2026
Merged

Improve performance of AspNetCoreResourceNameHelper.SimplifyRouteTemplate#8170
andrewlock merged 8 commits intomasterfrom
andrew/aspnetcore-perf/route-templates

Conversation

@andrewlock
Copy link
Member

@andrewlock andrewlock commented Feb 6, 2026 •
edited
Loading

Summary of changes

Reduces the allocations produced in AspNetCoreResourceNameHelper.SimplifyRouteTemplate()

Reason for change

I'm working on perf for aspnetcore in general, and this was an easy target point, as we know it allocates a bunch of intermediate string currently.

Note that I believe this is generally only used in the pre-endpoint routing flows, so it will not be commonly used. It doesn't hurt though, and it was easier to work with, hence it's first up here 😄

Implementation details

This is mostly inspired/based on the work I did in the single-span optimized path, but accounts for the fact that

  1. We have to explicitly extract controller, action, and area for tags, so those params are already known
  2. Need to not have any breaking changes in this code (that's a subtle difference compared to the single-span version)

The high-level improvements are:

  • Use ValueStringBuilder for building up the span (.NET Core 3.1+). The main benefit that gives is the AppendAsLowerInvariant method
  • Remove boxing of the enumerator by directly casting to List<T> (it's always that type in all implementations, so this is an easy improvement)
  • Use the provided controller, action, and area values
    • This makes the code more complicated, so I toyed with ignoring them and just always doing the route value dictionary lookup, but this approach came out faster. Not massive though, so if there's objections, we could simplify it.
  • Add a check to IsIdentifierSegment() to check for common identifier types that are always going to be ommited. Removes the need for calling ToString() on int values (for example)

.NET Core 2.1/3.0 (where we can't use ValueStringBuilder) has the following differences

  • Use the StringBuilderCache instead of ValueStringBuilder
  • Add a "dummy" AppendAsLowerInvariant() and call ToString().ToLowerInvariant() at the end (as we do today)

Test coverage

We already have unit tests for the behaviour, so I focused on the benchmarks

For the first test, I tested against all the templates we test with here:

dd-trace-dotnet/tracer/test/Datadog.Trace.Tests/DiagnosticListeners/AspNetCoreResourceNameHelperTests.cs

Lines 104 to 122 in c0dad86

public static TheoryData<string, string, bool> ValidRouteTemplatesWithExternalDefaults { get; } = new()
{
{ "{controller}/{action}/{id}", "/home/index/{id}", false },
{ "{controller}/{action}/{id}", "/home/index/{id}", true },
{ "{controller}/{action}/{id:int}", "/home/index/{id}", false },
{ "{controller}/{action}/{id:int}", "/home/index/{id}", true },
{ "{controller}/{action}/{FormValue}", "/home/index/{formvalue}", false },
{ "{controller}/{action}/{FormValue}", "/home/index/view", true },
{ "{controller}/{action}/{FormValue:int}", "/home/index/{formvalue}", false },
{ "{controller}/{action}/{FormValue:int}", "/home/index/view", true },
{ "{controller}/{action}/{identity}", "/home/index/{identity}", false },
{ "{controller}/{action}/{identity}", "/home/index/{identity}", true },
{ "{controller}/{action}", "/home/index", false },
{ "{controller}/{action}", "/home/index", true },
{ "{controller}/{*action}", "/home/index", false },
{ "{controller}/{*action}", "/home/index", true },
{ "{controller}/{action:string}", "/home/index", false },
{ "{controller}/{action:string}", "/home/index", true },
};

and created "aggregated" results, testing against .NET Core 2.1, 3.1, 6, and 10:

Method Runtime Expand Param Mean Allocated Alloc Ratio
RouteTemplate_Original .NET 10.0 False 3.002 us 4.3 KB 1.00
RouteTemplate_Updated .NET 10.0 False 2.452 us 1.7 KB 0.40
RouteTemplate_Original .NET 6.0 False 3.781 us 4.3 KB 1.00
RouteTemplate_Updated .NET 6.0 False 3.425 us 1.7 KB 0.40
RouteTemplate_Original .NET Core 3.1 False 5.117 us 4.3 KB 1.00
RouteTemplate_Updated .NET Core 3.1 False 5.111 us 1.7 KB 0.40
RouteTemplate_Original .NET Core 2.1 False 8.571 us 4.48 KB 1.00
RouteTemplate_Updated .NET Core 2.1 False 7.712 us 3.58 KB 0.80
RouteTemplate_Original .NET 10.0 True 2.957 us 3.99 KB 0.99
RouteTemplate_Updated .NET 10.0 True 2.728 us 1.55 KB 0.38
RouteTemplate_Original .NET 6.0 True 4.135 us 4.02 KB 1.00
RouteTemplate_Updated .NET 6.0 True 3.663 us 1.55 KB 0.38
RouteTemplate_Original .NET Core 3.1 True 5.455 us 4.02 KB 1.00
RouteTemplate_Updated .NET Core 3.1 True 5.593 us 1.55 KB 0.38
RouteTemplate_Original .NET Core 2.1 True 9.361 us 4.29 KB 1.00
RouteTemplate_Updated .NET Core 2.1 True 8.878 us 3.36 KB 0.78

In all cases, we allocate less now, and for all .NET Core 3.1+, a lot less. There is one minor regression in .NET Core 3.1 in speed when we expand params, but I think the allocation savings are still worth it.

To ensure there were no single degenerate cases, I also ran .NET 6 only against each template independently.

Full single-template benchmark results

Version Expand Template Mean Allocated Alloc Ratio
Original False {controller}/{action}/{id} 152.24ns 152B 1.00
Updated False {controller}/{action}/{id} 329.65ns 168B 1.11
Original False {controller}/{action} 183.02ns 184B 1.21
Updated False {controller}/{action} 257.93ns 96B 0.63
Original False {area:exists}/{controller}/{action} 154.99ns 152B 1.00
Updated False {area:exists}/{controller}/{action} 298.77ns 120B 0.79
Original False prefix/{controller}/{action} 178.64ns 184B 1.21
Updated False prefix/{controller}/{action} 131.74ns 56B 0.37
Original False prefix-{controller}/{action}-suffix 153.31ns 136B 0.89
Updated False prefix-{controller}/{action}-suffix 117.38ns 72B 0.47
Original False prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix 175.44ns 184B 1.21
Updated False prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix 107.70ns 64B 0.42
Original False prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix 238.54ns 184B 1.21
Updated False prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix 119.70ns 64B 0.42
Original False prefix-{controller}-{action}-{id}-{FormValue}/{Area?} 172.45ns 184B 1.21
Updated False prefix-{controller}-{action}-{id}-{FormValue}/{Area?} 133.16ns 64B 0.42
Original False standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 172.03ns 184B 1.21
Updated False standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 248.15ns 128B 0.84
Original False {controller}/{action}/{nonid} 273.13ns 184B 1.21
Updated False {controller}/{action}/{nonid} 135.59ns 64B 0.42
Original False {controller}/{action}/{nonid?} 168.27ns 168B 1.11
Updated False {controller}/{action}/{nonid?} 130.99ns 72B 0.47
Original False {controller}/{action}/{nonid=2} 174.51ns 168B 1.11
Updated False {controller}/{action}/{nonid=2} 125.19ns 64B 0.42
Original False {controller}/{action}/{nonid:int} 161.26ns 168B 1.11
Updated False {controller}/{action}/{nonid:int} 136.26ns 72B 0.47
Original False {controller}/{action}/{FormValue} 160.54ns 168B 1.11
Updated False {controller}/{action}/{FormValue} 136.97ns 72B 0.47
Original False {controller}/{action}/{FormValue?} 300.78ns 376B 2.47
Updated False {controller}/{action}/{FormValue?} 137.28ns 72B 0.47
Original False {controller}/{action}/{FormValue=Edit} 219.27ns 232B 1.53
Updated False {controller}/{action}/{FormValue=Edit} 135.32ns 72B 0.47
Original False {controller}/{action}/{FormValue:int} 221.59ns 280B 1.84
Updated False {controller}/{action}/{FormValue:int} 121.39ns 48B 0.32
Original False {controller}/{action}/{nonidentity} 226.88ns 296B 1.95
Updated False {controller}/{action}/{nonidentity} 137.23ns 72B 0.47
Original False {controller}/{action}/{nonidentity?} 131.69ns 184B 1.21
Updated False {controller}/{action}/{nonidentity?} 130.84ns 72B 0.47
Original False {controller}/{action}/{nonidentity=2} 127.93ns 168B 1.11
Updated False {controller}/{action}/{nonidentity=2} 94.41ns 48B 0.32
Original False {controller}/{action}/{nonidentity:int} 132.35ns 168B 1.11
Updated False {controller}/{action}/{nonidentity:int} 127.66ns 64B 0.42
Original False {controller}/{action}/{idlike} 119.40ns 136B 0.89
Updated False {controller}/{action}/{idlike} 128.02ns 64B 0.42
Original False {controller}/{action}/{id:int} 155.92ns 168B 1.11
Updated False {controller}/{action}/{id:int} 119.59ns 56B 0.37
Original True {controller}/{action}/{id} 146.29ns 152B 1.00
Updated True {controller}/{action}/{id} 138.64ns 56B 0.37
Original True {controller}/{action} 144.60ns 152B 1.00
Updated True {controller}/{action} 133.27ns 56B 0.37
Original True {area:exists}/{controller}/{action} 108.50ns 136B 0.89
Updated True {area:exists}/{controller}/{action} 143.76ns 56B 0.37
Original True prefix/{controller}/{action} 129.71ns 168B 1.11
Updated True prefix/{controller}/{action} 126.89ns 72B 0.47
Original True prefix-{controller}/{action}-suffix 126.21ns 168B 1.11
Updated True prefix-{controller}/{action}-suffix 142.42ns 56B 0.37
Original True prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix 127.19ns 184B 1.21
Updated True prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix 124.55ns 72B 0.47
Original True prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix 232.61ns 248B 1.63
Updated True prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix 109.81ns 48B 0.32
Original True prefix-{controller}-{action}-{id}-{FormValue}/{Area?} 218.34ns 264B 1.74
Updated True prefix-{controller}-{action}-{id}-{FormValue}/{Area?} 136.71ns 56B 0.37
Original True standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 206.66ns 200B 1.32
Updated True standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 141.68ns 56B 0.37
Original True {controller}/{action}/{nonid} 268.18ns 344B 2.26
Updated True {controller}/{action}/{nonid} 138.87ns 56B 0.37
Original True {controller}/{action}/{nonid?} 150.72ns 152B 1.00
Updated True {controller}/{action}/{nonid?} 112.45ns 72B 0.47
Original True {controller}/{action}/{nonid=2} 149.30ns 152B 1.00
Updated True {controller}/{action}/{nonid=2} 283.82ns 152B 1.00
Original True {controller}/{action}/{nonid:int} 178.65ns 200B 1.32
Updated True {controller}/{action}/{nonid:int} 204.47ns 80B 0.53
Original True {controller}/{action}/{FormValue} 153.26ns 152B 1.00
Updated True {controller}/{action}/{FormValue} 233.21ns 112B 0.74
Original True {controller}/{action}/{FormValue?} 163.13ns 152B 1.00
Updated True {controller}/{action}/{FormValue?} 252.30ns 104B 0.68
Original True {controller}/{action}/{FormValue=Edit} 155.70ns 152B 1.00
Updated True {controller}/{action}/{FormValue=Edit} 102.94ns 64B 0.42
Original True {controller}/{action}/{FormValue:int} 163.94ns 152B 1.00
Updated True {controller}/{action}/{FormValue:int} 102.48ns 64B 0.42
Original True {controller}/{action}/{nonidentity} 158.25ns 152B 1.00
Updated True {controller}/{action}/{nonidentity} 84.14ns 48B 0.32
Original True {controller}/{action}/{nonidentity?} 150.04ns 184B 1.21
Updated True {controller}/{action}/{nonidentity?} 123.77ns 72B 0.47
Original True {controller}/{action}/{nonidentity=2} 135.92ns 136B 0.89
Updated True {controller}/{action}/{nonidentity=2} 120.00ns 56B 0.37
Original True {controller}/{action}/{nonidentity:int} 153.92ns 184B 1.21
Updated True {controller}/{action}/{nonidentity:int} 130.82ns 64B 0.42
Original True {controller}/{action}/{idlike} 152.99ns 184B 1.21
Updated True {controller}/{action}/{idlike} 128.73ns 56B 0.37
Original True {controller}/{action}/{id:int} 143.68ns 152B 1.00
Updated True {controller}/{action}/{id:int} 124.07ns 56B 0.37

In almost all cases there were improvements in both memory and cpu (see details collapsed above), but there were a few cases that stood out as getting worse. The problematic templates (and their results) were:

Route Template Expand Templates template Mean Allocated
Original False {controller}/{action}/{id} 152.24ns 152B
Updated False {controller}/{action}/{id} 329.65ns 168B
Original False standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 172.03ns 184B
Updated False standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone 248.15ns 128B
Original True {controller}/{action}/{nonid=2} 149.30ns 152B
Original True {controller}/{action}/{nonid=2} 149.30ns 152B

The first case is the most odd. I can't for the life of me see where the extra allocation is coming from 😕 The second case is similarly strange that there's no reduction in allocation. The latter one shows a degradation in time only, so is less concerning, but still strange! 😄

I am a bit concerned about the first case, but even putting dotmemmory on it, the only allocations I see are the final ToString() so 🤷‍♂️

Benchmark code 

#if !NETFRAMEWORK

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using Datadog.Trace;
using Datadog.Trace.Agent.DiscoveryService;
using Datadog.Trace.AppSec;
using Datadog.Trace.ClrProfiler.AutoInstrumentation.Http.HttpClient.HttpClientHandler;
using Datadog.Trace.Configuration;
using Datadog.Trace.Configuration.Telemetry;
using Datadog.Trace.Debugger;
using Datadog.Trace.Debugger.SpanCodeOrigin;
using Datadog.Trace.DiagnosticListeners;
using Datadog.Trace.DuckTyping;
using Datadog.Trace.Iast.Settings;
using Datadog.Trace.RemoteConfigurationManagement;
using Datadog.Trace.Security.Unit.Tests.Iast;
using Datadog.Trace.Util;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Routing;
using Microsoft.AspNetCore.Routing.Constraints;
using Microsoft.AspNetCore.Routing.Template;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
#if NETCOREAPP3_0_OR_GREATER
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Routing.Patterns;
#endif
namespace Benchmarks.Trace
{
    [MemoryDiagnoser, GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory), CategoriesColumn]
    public class AspNetCoreResourceNameBenchmark
    {
        private Datadog.Trace.DiagnosticListeners.RoutePattern[] _routePatterns;
        private Datadog.Trace.DiagnosticListeners.RoutePattern[] _routePatternsWithDefaults;
        private RouteValueDictionary _values;
        private RouteValueDictionary _defaults;
        private RouteValueDictionary _parameterPolicies;
        private string[] _results;
        private string[] _results2;
        private RouteTemplate[] _routeTemplates =
        [
            TemplateParser.Parse("{controller}/{action}/{id}"),
            TemplateParser.Parse("{controller}/{action}"),
            TemplateParser.Parse("{area:exists}/{controller}/{action}"),
            TemplateParser.Parse("prefix/{controller}/{action}"),
            TemplateParser.Parse("prefix-{controller}/{action}-suffix"),
            TemplateParser.Parse("prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix"),
            TemplateParser.Parse("prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix"),
            TemplateParser.Parse("prefix-{controller}-{action}-{id}-{FormValue}/{Area?}"),
            TemplateParser.Parse("standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone"),
            TemplateParser.Parse("{controller}/{action}/{nonid}"),
            TemplateParser.Parse("{controller}/{action}/{nonid?}"),
            TemplateParser.Parse("{controller}/{action}/{nonid=2}"),
            TemplateParser.Parse("{controller}/{action}/{nonid:int}"),
            TemplateParser.Parse("{controller}/{action}/{FormValue}"),
            TemplateParser.Parse("{controller}/{action}/{FormValue?}"),
            TemplateParser.Parse("{controller}/{action}/{FormValue=Edit}"),
            TemplateParser.Parse("{controller}/{action}/{FormValue:int}"),
            TemplateParser.Parse("{controller}/{action}/{nonidentity}"),
            TemplateParser.Parse("{controller}/{action}/{nonidentity?}"),
            TemplateParser.Parse("{controller}/{action}/{nonidentity=2}"),
            TemplateParser.Parse("{controller}/{action}/{nonidentity:int}"),
            TemplateParser.Parse("{controller}/{action}/{idlike}"),
            TemplateParser.Parse("{controller}/{action}/{id:int}"),
        ];

        [GlobalSetup]
        public void GlobalSetup()
        {
#if NETCOREAPP3_0_OR_GREATER
            _routePatterns =
            [
                RoutePatternFactory.Parse("{controller}/{action}/{id}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{area:exists}/{controller}/{action}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix/{controller}/{action}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}/{action}-suffix").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{id}-{FormValue}/{Area?}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid?}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid=2}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid:int}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue?}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue=Edit}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue:int}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity?}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity=2}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity:int}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{idlike}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{id:int}").DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
            ];
            _routePatternsWithDefaults =
            [
                RoutePatternFactory.Parse("{controller}/{action}/{id}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{area:exists}/{controller}/{action}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix/{controller}/{action}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}/{action}-suffix", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{Area}-{id}-{FormValue}-suffix", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("prefix-{controller}-{action}-{id}-{FormValue}/{Area?}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("standalone/prefix-{controller}-{action}-{nonid}-{id}-{FormValue}-suffix/standalone", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid?}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid=2}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonid:int}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue?}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue=Edit}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{FormValue:int}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity?}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity=2}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{nonidentity:int}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{idlike}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
                RoutePatternFactory.Parse("{controller}/{action}/{id:int}", _defaults, parameterPolicies: _parameterPolicies).DuckCast<Datadog.Trace.DiagnosticListeners.RoutePattern>(),
            ];
            _results = new string[_routePatterns.Length];
#endif

            _results2 = new string[_routeTemplates.Length];

            _values = new()
            {
                { "controller", "Home" },
                { "action", "Index" },
                { "nonid", "oops" },
                { "idlike", 123 },
                { "FormValue", "View" },
            };

            _defaults = new()
            {
                { "controller", "Home" },
                { "action", "Index" },
                { "FormValue", "View" }
            };

            _parameterPolicies = new()
            {
                { "id", new OptionalRouteConstraint(new IntRouteConstraint()) }
            };
        }

        [Params(true, false)]
        public bool ExpandTemplates { get; set; }

        public IEnumerable<object> RouteTemplates => _routeTemplates.Select(x => (object)x);

        [GlobalCleanup]
        public void GlobalCleanup()
        {
        }

        [Benchmark(Baseline = true)]
        [BenchmarkCategory("RoutePattern")]
        public string[] RoutePattern_Original()
        {
            for (var i = 0; i < _routePatterns.Length; i++)
            {
                _results[i] = OriginalAspNetCoreResourceNameHelper.SimplifyRoutePattern(
                    routePattern: _routePatterns[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark(Baseline = true)]
        [BenchmarkCategory("RoutePatternWithDefaults")]
        public string[] RoutePatternWithDefaults_Original()
        {
            for (var i = 0; i < _routePatternsWithDefaults.Length; i++)
            {
                _results[i] = OriginalAspNetCoreResourceNameHelper.SimplifyRoutePattern(
                    routePattern: _routePatternsWithDefaults[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark(Baseline = true)]
        [BenchmarkCategory("RouteTemplate")]
        public string[] RouteTemplate_Original()
        {
            for (var i = 0; i < _routeTemplates.Length; i++)
            {
                _results2[i] = OriginalAspNetCoreResourceNameHelper.SimplifyRouteTemplate(
                    routePattern: _routeTemplates[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark(Baseline = true)]
        [BenchmarkCategory("RouteTemplateSingle")]
        [ArgumentsSource(nameof(RouteTemplates))]
        public string RouteTemplateSingle_Original(RouteTemplate template)
        {
            return OriginalAspNetCoreResourceNameHelper.SimplifyRouteTemplate(
                routePattern: template,
                routeValueDictionary: _values,
                areaName: null,
                controllerName: _values["controller"] as string,
                actionName: _values["action"] as string,
                ExpandTemplates);
        }

        [Benchmark]
        [BenchmarkCategory("RoutePattern")]
        public string[] RoutePattern_Updated()
        {
            for (var i = 0; i < _routePatterns.Length; i++)
            {
                _results[i] = AspNetCoreResourceNameHelper.SimplifyRoutePattern(
                    routePattern: _routePatterns[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark]
        [BenchmarkCategory("RoutePatternWithDefaults")]
        public string[] RoutePatternWithDefaults_Updated()
        {
            for (var i = 0; i < _routePatternsWithDefaults.Length; i++)
            {
                _results[i] = AspNetCoreResourceNameHelper.SimplifyRoutePattern(
                    routePattern: _routePatternsWithDefaults[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark]
        [BenchmarkCategory("RouteTemplate")]
        public string[] RouteTemplate_Updated()
        {
            for (var i = 0; i < _routeTemplates.Length; i++)
            {
                _results2[i] = AspNetCoreResourceNameHelper.SimplifyRouteTemplate(
                    routePattern: _routeTemplates[i],
                    routeValueDictionary: _values,
                    areaName: null,
                    controllerName: _values["controller"] as string,
                    actionName: _values["action"] as string,
                    ExpandTemplates);
            }

            return _results;
        }

        [Benchmark]
        [BenchmarkCategory("RouteTemplateSingle")]
        [ArgumentsSource(nameof(RouteTemplates))]
        public string RouteTemplateSingle_Updated(RouteTemplate template)
        {
            return AspNetCoreResourceNameHelper.SimplifyRouteTemplate(
                routePattern: template,
                routeValueDictionary: _values,
                areaName: null,
                controllerName: _values["controller"] as string,
                actionName: _values["action"] as string,
                ExpandTemplates);
        }

        private class Startup
        {
            public void ConfigureServices(IServiceCollection services)
            {
                services.AddMvc();
            }

            public void Configure(IApplicationBuilder builder)
            {
#if NETCOREAPP2_1
                builder.UseMvcWithDefaultRoute();
#else
                builder.UseRouting();
                builder.UseEndpoints(endpoints =>
                {
                    endpoints.MapControllerRoute(
                        name: "default",
                        pattern: "{controller=Home}/{action=Index}/{id?}");
                });
#endif
            }
        }
    }
}
#else

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Web.Routing;
using BenchmarkDotNet.Attributes;
using Datadog.Trace.DuckTyping;
using Datadog.Trace.Util;

namespace Benchmarks.Trace
{
    [MemoryDiagnoser]
    public class AspNetCoreResourceNameBenchmark
    {
        [GlobalSetup]
        public void GlobalSetup()
        {
        }

        [GlobalCleanup]
        public void GlobalCleanup()
        {
        }

        [Benchmark]
        public string SendRequest()
        {
            return null;
        }
    }
}

#endif

#if !NETFRAMEWORK
internal static class OriginalAspNetCoreResourceNameHelper
{
    internal static string SimplifyRoutePattern(
        Datadog.Trace.DiagnosticListeners.RoutePattern routePattern,
        IReadOnlyDictionary<string, object> routeValueDictionary,
        string? areaName,
        string? controllerName,
        string? actionName,
        bool expandRouteParameters)
    {
        var maxSize = (routePattern.RawText?.Length ?? 0)
                    + (string.IsNullOrEmpty(areaName) ? 0 : Math.Max(areaName!.Length - 4, 0)) // "area".Length
                    + (string.IsNullOrEmpty(controllerName) ? 0 : Math.Max(controllerName!.Length - 10, 0)) // "controller".Length
                    + (string.IsNullOrEmpty(actionName) ? 0 : Math.Max(actionName!.Length - 6, 0)) // "action".Length
                    + 1; // '/' prefix

        var sb = StringBuilderCache.Acquire(maxSize);

        foreach (var pathSegment in routePattern.PathSegments)
        {
            var parts = 0;
            foreach (var part in pathSegment.DuckCast<AspNetCoreDiagnosticObserver.RoutePatternPathSegmentStruct>().Parts)
            {
                parts++;
                if (part.TryDuckCast(out AspNetCoreDiagnosticObserver.RoutePatternContentPartStruct contentPart))
                {
                    if (parts == 1)
                    {
                        sb.Append('/');
                    }

                    sb.Append(contentPart.Content);
                }
                else if (part.TryDuckCast(out AspNetCoreDiagnosticObserver.RoutePatternParameterPartStruct parameter))
                {
                    var parameterName = parameter.Name;
                    if (parameterName.Equals("area", StringComparison.OrdinalIgnoreCase))
                    {
                        if (areaName is null && parameter.IsOptional)
                        {
                            // don't append optional suffixes when no value is provided
                            continue;
                        }

                        if (parts == 1)
                        {
                            sb.Append('/');
                        }

                        sb.Append(areaName ?? "{area}");
                    }
                    else if (parameterName.Equals("controller", StringComparison.OrdinalIgnoreCase))
                    {
                        if (controllerName is null && parameter.IsOptional)
                        {
                            // don't append optional suffixes when no value is provided
                            continue;
                        }

                        if (parts == 1)
                        {
                            sb.Append('/');
                        }

                        sb.Append(controllerName ?? "{controller}");
                    }
                    else if (parameterName.Equals("action", StringComparison.OrdinalIgnoreCase))
                    {
                        if (actionName is null && parameter.IsOptional)
                        {
                            // don't append optional suffixes when no value is provided
                            continue;
                        }

                        if (parts == 1)
                        {
                            sb.Append('/');
                        }

                        sb.Append(actionName ?? "{action}");
                    }
                    else
                    {
                        var haveParameter = routeValueDictionary.TryGetValue(parameterName, out var value);
                        if (!parameter.IsOptional || haveParameter)
                        {
                            if (parts == 1)
                            {
                                sb.Append('/');
                            }

                            if (expandRouteParameters && haveParameter && !IsIdentifierSegment(value, out var valueAsString))
                            {
                                // write the expanded parameter value
                                sb.Append(valueAsString);
                            }
                            else
                            {
                                // write the route template value
                                sb.Append('{');
                                if (parameter.IsCatchAll)
                                {
                                    if (parameter.EncodeSlashes)
                                    {
                                        sb.Append("**");
                                    }
                                    else
                                    {
                                        sb.Append('*');
                                    }
                                }

                                sb.Append(parameterName);
                                if (parameter.IsOptional)
                                {
                                    sb.Append('?');
                                }

                                sb.Append('}');
                            }
                        }
                    }
                }
            }
        }

        var simplifiedRoute = StringBuilderCache.GetStringAndRelease(sb);

        return string.IsNullOrEmpty(simplifiedRoute) ? "/" : simplifiedRoute.ToLowerInvariant();
    }

    internal static string SimplifyRouteTemplate(
        RouteTemplate routePattern,
        RouteValueDictionary routeValueDictionary,
        string? areaName,
        string? controllerName,
        string? actionName,
        bool expandRouteParameters)
    {
        var maxSize = (routePattern.TemplateText?.Length ?? 0)
                    + (string.IsNullOrEmpty(areaName) ? 0 : Math.Max(areaName!.Length - 4, 0)) // "area".Length
                    + (string.IsNullOrEmpty(controllerName) ? 0 : Math.Max(controllerName!.Length - 10, 0)) // "controller".Length
                    + (string.IsNullOrEmpty(actionName) ? 0 : Math.Max(actionName!.Length - 6, 0)) // "action".Length
                    + 1; // '/' prefix

        var sb = StringBuilderCache.Acquire(maxSize);

        foreach (var pathSegment in routePattern.Segments)
        {
            var parts = 0;
            foreach (var part in pathSegment.Parts)
            {
                parts++;
                var partName = part.Name;

                if (!part.IsParameter)
                {
                    if (parts == 1)
                    {
                        sb.Append('/');
                    }

                    sb.Append(part.Text);
                }
                else if (partName.Equals("area", StringComparison.OrdinalIgnoreCase))
                {
                    if (areaName is null && part.IsOptional)
                    {
                        // don't append optional suffixes when no value is provided
                        continue;
                    }

                    if (parts == 1)
                    {
                        sb.Append('/');
                    }

                    sb.Append(areaName ?? "{area}");
                }
                else if (partName.Equals("controller", StringComparison.OrdinalIgnoreCase))
                {
                    if (controllerName is null && part.IsOptional)
                    {
                        // don't append optional suffixes when no value is provided
                        continue;
                    }

                    if (parts == 1)
                    {
                        sb.Append('/');
                    }

                    sb.Append(controllerName ?? "{controller}");
                }
                else if (partName.Equals("action", StringComparison.OrdinalIgnoreCase))
                {
                    if (actionName is null && part.IsOptional)
                    {
                        // don't append optional suffixes when no value is provided
                        continue;
                    }

                    if (parts == 1)
                    {
                        sb.Append('/');
                    }

                    sb.Append(actionName ?? "{action}");
                }
                else
                {
                    var haveParameter = routeValueDictionary.TryGetValue(partName, out var value);
                    if (!part.IsOptional || haveParameter)
                    {
                        if (parts == 1)
                        {
                            sb.Append('/');
                        }

                        if (expandRouteParameters && haveParameter && !IsIdentifierSegment(value, out var valueAsString))
                        {
                            // write the expanded parameter value
                            sb.Append(valueAsString);
                        }
                        else
                        {
                            // write the route template value
                            sb.Append('{');
                            if (part.IsCatchAll)
                            {
                                sb.Append('*');
                            }

                            sb.Append(partName);
                            if (part.IsOptional)
                            {
                                sb.Append('?');
                            }

                            sb.Append('}');
                        }
                    }
                }
            }
        }

        var simplifiedRoute = StringBuilderCache.GetStringAndRelease(sb);

        return string.IsNullOrEmpty(simplifiedRoute) ? "/" : simplifiedRoute.ToLowerInvariant();
    }

    private static bool IsIdentifierSegment(object value, out string valueAsString)
    {
        valueAsString = value as string ?? value?.ToString();
        if (valueAsString is null)
        {
            return false;
        }

        return UriHelpers.IsIdentifierSegment(valueAsString, 0, valueAsString.Length);
    }
}
#endif

Other details

Part of a stack
https://datadoghq.atlassian.net/browse/LANGPLAT-842

@andrewlock andrewlock requested a review from a team as a code owner February 6, 2026 16:43
@andrewlock andrewlock added area:tracer The core tracer library (Datadog.Trace, does not include OpenTracing, native code, or integrations) type:performance Performance, speed, latency, resource usage (CPU, memory) area:integrations labels Feb 6, 2026
@andrewlock andrewlock mentioned this pull request Feb 6, 2026
Merged
chatgpt-codex-connector[bot]
chatgpt-codex-connector bot reviewed Feb 6, 2026
View reviewed changes
Copy link

@chatgpt-codex-connector chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 93f80eede0

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

lucaspimentel
lucaspimentel reviewed Feb 6, 2026
View reviewed changes
Copy link
Member

@lucaspimentel lucaspimentel left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM aside from the build errors:

tracer\src\Datadog.Trace\DiagnosticListeners\AspNetCoreResourceNameHelper.cs(262,28):
error CS0246: The type or namespace name 'ValueStringBuilder' could not be found (are you missing a using directive or an assembly reference?)

@andrewlock andrewlock force-pushed the andrew/aspnetcore-perf/route-templates branch from 93f80ee to c886897 Compare February 9, 2026 11:54
@andrewlock
Copy link
Member Author

andrewlock commented Feb 9, 2026

LGTM aside from the build errors:

tracer\src\Datadog.Trace\DiagnosticListeners\AspNetCoreResourceNameHelper.cs(262,28):
error CS0246: The type or namespace name 'ValueStringBuilder' could not be found (are you missing a using directive or an assembly reference?)

Oops, messed up my rebasing! 🤦‍♂️ Fixed now.

Also added some extra unit tests for IsIdentifierSegment to catch the examples codex flagged. The issues it flags are legitimate changes in behavior, which I'm not sure if we want or not, but I've erred on the safe side to assume not. They should be edge cases anyway (decimals in URL segments)

@pr-commenter
Copy link

pr-commenter bot commented Feb 9, 2026 •
edited
Loading

Benchmarks

Benchmark execution time: 2026-02-18 10:25:15

Comparing candidate commit bca39bf in PR branch andrew/aspnetcore-perf/route-templates with baseline commit 0b48278 in branch master.

Found 8 performance improvements and 3 performance regressions! Performance is the same for 171 metrics, 10 unstable metrics.

scenario:Benchmarks.Trace.AgentWriterBenchmark.WriteAndFlushEnrichedTraces net6.0

  • 🟩 execution_time [-101.695ms; -101.521ms] or [-50.216%; -50.130%]

scenario:Benchmarks.Trace.Asm.AppSecBodyBenchmark.AllCycleMoreComplexBody net6.0

  • 🟩 execution_time [-19.766ms; -14.019ms] or [-9.187%; -6.516%]

scenario:Benchmarks.Trace.Asm.AppSecBodyBenchmark.AllCycleSimpleBody net6.0

  • 🟥 execution_time [+21.952ms; +27.054ms] or [+11.110%; +13.692%]

scenario:Benchmarks.Trace.Asm.AppSecBodyBenchmark.ObjectExtractorSimpleBody netcoreapp3.1

  • 🟩 execution_time [-17.230ms; -11.173ms] or [-8.184%; -5.307%]

scenario:Benchmarks.Trace.AspNetCoreBenchmark.SendRequest net6.0

  • 🟥 execution_time [+99.508ms; +101.180ms] or [+105.435%; +107.206%]

scenario:Benchmarks.Trace.AspNetCoreBenchmark.SendRequest netcoreapp3.1

  • 🟥 execution_time [+10.917ms; +13.148ms] or [+11.152%; +13.430%]

scenario:Benchmarks.Trace.CIVisibilityProtocolWriterBenchmark.WriteAndFlushEnrichedTraces net472

  • 🟩 throughput [+106.354op/s; +136.430op/s] or [+10.277%; +13.184%]

scenario:Benchmarks.Trace.ElasticsearchBenchmark.CallElasticsearchAsync net472

  • 🟩 throughput [+15257.696op/s; +16877.556op/s] or [+5.675%; +6.278%]

scenario:Benchmarks.Trace.Log4netBenchmark.EnrichedLog netcoreapp3.1

  • 🟩 execution_time [-42.876ms; -39.939ms] or [-21.324%; -19.863%]

scenario:Benchmarks.Trace.SingleSpanAspNetCoreBenchmark.SingleSpanAspNetCore net6.0

  • 🟩 execution_time [-68.569ms; -66.684ms] or [-43.396%; -42.203%]

scenario:Benchmarks.Trace.SpanBenchmark.StartFinishSpan netcoreapp3.1

  • 🟩 execution_time [-15.902ms; -10.776ms] or [-7.504%; -5.085%]

@dd-trace-dotnet-ci-bot
Copy link

dd-trace-dotnet-ci-bot bot commented Feb 9, 2026 •
edited
Loading

Execution-Time Benchmarks Report ⏱️

Execution-time results for samples comparing This PR (8170) and master.

✅ No regressions detected - check the details below

Full Metrics Comparison

FakeDbCommand

Metric Master (Mean ± 95% CI) Current (Mean ± 95% CI) Change Status
.NET Framework 4.8 - Baseline
duration74.32 ± (74.27 - 74.56) ms73.01 ± (72.99 - 73.30) ms-1.8%✅
.NET Framework 4.8 - Bailout
duration78.78 ± (78.70 - 79.11) ms77.32 ± (77.21 - 77.55) ms-1.9%✅
.NET Framework 4.8 - CallTarget+Inlining+NGEN
duration1074.25 ± (1074.39 - 1080.13) ms1060.05 ± (1060.77 - 1067.18) ms-1.3%✅
.NET Core 3.1 - Baseline
process.internal_duration_ms22.84 ± (22.79 - 22.89) ms22.33 ± (22.29 - 22.38) ms-2.2%✅
process.time_to_main_ms86.29 ± (86.12 - 86.46) ms84.34 ± (84.16 - 84.52) ms-2.3%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed10.93 ± (10.93 - 10.93) MB10.93 ± (10.93 - 10.93) MB+0.0%✅⬆️
runtime.dotnet.threads.count12 ± (12 - 12)12 ± (12 - 12)+0.0%✅
.NET Core 3.1 - Bailout
process.internal_duration_ms22.77 ± (22.72 - 22.83) ms22.12 ± (22.08 - 22.15) ms-2.9%✅
process.time_to_main_ms87.20 ± (87.01 - 87.39) ms84.94 ± (84.80 - 85.09) ms-2.6%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed10.96 ± (10.95 - 10.96) MB10.96 ± (10.95 - 10.96) MB-0.0%✅
runtime.dotnet.threads.count13 ± (13 - 13)13 ± (13 - 13)+0.0%✅
.NET Core 3.1 - CallTarget+Inlining+NGEN
process.internal_duration_ms238.86 ± (234.81 - 242.90) ms243.78 ± (239.76 - 247.81) ms+2.1%✅⬆️
process.time_to_main_ms489.47 ± (488.77 - 490.16) ms483.46 ± (482.78 - 484.13) ms-1.2%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed47.62 ± (47.60 - 47.65) MB47.56 ± (47.54 - 47.58) MB-0.1%✅
runtime.dotnet.threads.count28 ± (28 - 28)28 ± (28 - 28)+0.0%✅
.NET 6 - Baseline
process.internal_duration_ms21.48 ± (21.43 - 21.52) ms21.21 ± (21.17 - 21.25) ms-1.2%✅
process.time_to_main_ms75.08 ± (74.93 - 75.23) ms73.95 ± (73.77 - 74.12) ms-1.5%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed10.62 ± (10.62 - 10.63) MB10.65 ± (10.65 - 10.66) MB+0.3%✅⬆️
runtime.dotnet.threads.count10 ± (10 - 10)10 ± (10 - 10)+0.0%✅
.NET 6 - Bailout
process.internal_duration_ms21.42 ± (21.38 - 21.46) ms21.27 ± (21.24 - 21.30) ms-0.7%✅
process.time_to_main_ms76.19 ± (76.03 - 76.34) ms75.16 ± (75.02 - 75.31) ms-1.3%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed10.68 ± (10.68 - 10.69) MB10.76 ± (10.76 - 10.76) MB+0.7%✅⬆️
runtime.dotnet.threads.count11 ± (11 - 11)11 ± (11 - 11)+0.0%✅
.NET 6 - CallTarget+Inlining+NGEN
process.internal_duration_ms253.95 ± (250.50 - 257.40) ms251.52 ± (247.54 - 255.50) ms-1.0%✅
process.time_to_main_ms470.97 ± (470.37 - 471.57) ms464.05 ± (463.33 - 464.76) ms-1.5%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed48.39 ± (48.37 - 48.42) MB48.30 ± (48.27 - 48.33) MB-0.2%✅
runtime.dotnet.threads.count28 ± (28 - 28)28 ± (28 - 28)-0.1%✅
.NET 8 - Baseline
process.internal_duration_ms19.66 ± (19.63 - 19.69) ms19.57 ± (19.53 - 19.60) ms-0.5%✅
process.time_to_main_ms73.95 ± (73.78 - 74.11) ms72.86 ± (72.71 - 73.01) ms-1.5%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed7.66 ± (7.66 - 7.67) MB7.67 ± (7.66 - 7.67) MB+0.1%✅⬆️
runtime.dotnet.threads.count10 ± (10 - 10)10 ± (10 - 10)+0.0%✅
.NET 8 - Bailout
process.internal_duration_ms19.62 ± (19.57 - 19.67) ms19.63 ± (19.58 - 19.67) ms+0.0%✅⬆️
process.time_to_main_ms75.48 ± (75.31 - 75.65) ms74.23 ± (74.07 - 74.39) ms-1.7%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed7.73 ± (7.72 - 7.74) MB7.74 ± (7.73 - 7.75) MB+0.1%✅⬆️
runtime.dotnet.threads.count11 ± (11 - 11)11 ± (11 - 11)+0.0%✅
.NET 8 - CallTarget+Inlining+NGEN
process.internal_duration_ms188.93 ± (188.27 - 189.59) ms188.17 ± (187.41 - 188.93) ms-0.4%✅
process.time_to_main_ms452.96 ± (452.26 - 453.66) ms446.76 ± (446.16 - 447.36) ms-1.4%✅
runtime.dotnet.exceptions.count0 ± (0 - 0)0 ± (0 - 0)+0.0%✅
runtime.dotnet.mem.committed36.01 ± (35.98 - 36.04) MB36.06 ± (36.02 - 36.09) MB+0.1%✅⬆️
runtime.dotnet.threads.count27 ± (27 - 27)27 ± (27 - 27)+0.1%✅⬆️

HttpMessageHandler

Metric Master (Mean ± 95% CI) Current (Mean ± 95% CI) Change Status
.NET Framework 4.8 - Baseline
duration193.90 ± (194.02 - 194.83) ms192.20 ± (192.14 - 192.84) ms-0.9%✅
.NET Framework 4.8 - Bailout
duration197.51 ± (197.25 - 197.82) ms196.06 ± (195.85 - 196.40) ms-0.7%✅
.NET Framework 4.8 - CallTarget+Inlining+NGEN
duration1140.79 ± (1139.77 - 1148.76) ms1135.34 ± (1136.57 - 1144.51) ms-0.5%✅
.NET Core 3.1 - Baseline
process.internal_duration_ms187.66 ± (187.30 - 188.02) ms187.54 ± (187.13 - 187.94) ms-0.1%✅
process.time_to_main_ms81.48 ± (81.29 - 81.67) ms81.26 ± (81.02 - 81.50) ms-0.3%✅
runtime.dotnet.exceptions.count3 ± (3 - 3)3 ± (3 - 3)+0.0%✅
runtime.dotnet.mem.committed16.14 ± (16.11 - 16.16) MB16.11 ± (16.08 - 16.14) MB-0.2%✅
runtime.dotnet.threads.count20 ± (19 - 20)20 ± (20 - 20)+0.1%✅⬆️
.NET Core 3.1 - Bailout
process.internal_duration_ms187.30 ± (187.05 - 187.55) ms186.52 ± (186.23 - 186.81) ms-0.4%✅
process.time_to_main_ms82.62 ± (82.45 - 82.78) ms82.35 ± (82.22 - 82.48) ms-0.3%✅
runtime.dotnet.exceptions.count3 ± (3 - 3)3 ± (3 - 3)+0.0%✅
runtime.dotnet.mem.committed16.15 ± (16.12 - 16.17) MB16.15 ± (16.13 - 16.17) MB+0.0%✅⬆️
runtime.dotnet.threads.count21 ± (21 - 21)21 ± (21 - 21)+0.7%✅⬆️
.NET Core 3.1 - CallTarget+Inlining+NGEN
process.internal_duration_ms426.92 ± (423.45 - 430.38) ms429.65 ± (426.49 - 432.81) ms+0.6%✅⬆️
process.time_to_main_ms472.12 ± (471.55 - 472.70) ms471.42 ± (470.88 - 471.96) ms-0.1%✅
runtime.dotnet.exceptions.count3 ± (3 - 3)3 ± (3 - 3)+0.0%✅
runtime.dotnet.mem.committed58.03 ± (57.92 - 58.13) MB58.03 ± (57.90 - 58.17) MB+0.0%✅⬆️
runtime.dotnet.threads.count29 ± (29 - 29)29 ± (29 - 29)-0.1%✅
.NET 6 - Baseline
process.internal_duration_ms192.08 ± (191.70 - 192.47) ms191.71 ± (191.27 - 192.14) ms-0.2%✅
process.time_to_main_ms70.49 ± (70.25 - 70.74) ms70.36 ± (70.15 - 70.56) ms-0.2%✅
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed16.35 ± (16.32 - 16.38) MB16.14 ± (16.00 - 16.27) MB-1.3%✅
runtime.dotnet.threads.count19 ± (19 - 19)18 ± (18 - 19)-3.3%✅
.NET 6 - Bailout
process.internal_duration_ms191.08 ± (190.71 - 191.45) ms191.00 ± (190.56 - 191.43) ms-0.0%✅
process.time_to_main_ms71.36 ± (71.20 - 71.52) ms71.46 ± (71.32 - 71.60) ms+0.1%✅⬆️
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed15.91 ± (15.75 - 16.06) MB16.20 ± (16.06 - 16.33) MB+1.8%✅⬆️
runtime.dotnet.threads.count19 ± (19 - 19)20 ± (20 - 20)+3.3%✅⬆️
.NET 6 - CallTarget+Inlining+NGEN
process.internal_duration_ms448.39 ± (445.80 - 450.97) ms446.97 ± (445.03 - 448.92) ms-0.3%✅
process.time_to_main_ms452.98 ± (452.22 - 453.75) ms447.26 ± (446.77 - 447.75) ms-1.3%✅
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed58.15 ± (58.04 - 58.27) MB58.07 ± (57.97 - 58.17) MB-0.1%✅
runtime.dotnet.threads.count29 ± (29 - 29)29 ± (29 - 29)-0.1%✅
.NET 8 - Baseline
process.internal_duration_ms192.36 ± (191.92 - 192.81) ms188.50 ± (188.22 - 188.78) ms-2.0%✅
process.time_to_main_ms70.68 ± (70.46 - 70.91) ms69.50 ± (69.32 - 69.68) ms-1.7%✅
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed11.72 ± (11.70 - 11.74) MB11.74 ± (11.68 - 11.79) MB+0.1%✅⬆️
runtime.dotnet.threads.count18 ± (18 - 18)18 ± (18 - 18)-0.7%✅
.NET 8 - Bailout
process.internal_duration_ms191.24 ± (190.75 - 191.74) ms187.69 ± (187.48 - 187.90) ms-1.9%✅
process.time_to_main_ms71.75 ± (71.57 - 71.93) ms70.38 ± (70.29 - 70.48) ms-1.9%✅
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed11.79 ± (11.76 - 11.82) MB11.78 ± (11.72 - 11.84) MB-0.1%✅
runtime.dotnet.threads.count19 ± (19 - 19)19 ± (18 - 19)-3.0%✅
.NET 8 - CallTarget+Inlining+NGEN
process.internal_duration_ms364.98 ± (363.68 - 366.28) ms365.72 ± (364.32 - 367.12) ms+0.2%✅⬆️
process.time_to_main_ms433.50 ± (432.87 - 434.13) ms434.40 ± (433.68 - 435.12) ms+0.2%✅⬆️
runtime.dotnet.exceptions.count4 ± (4 - 4)4 ± (4 - 4)+0.0%✅
runtime.dotnet.mem.committed47.78 ± (47.75 - 47.81) MB47.70 ± (47.66 - 47.74) MB-0.2%✅
runtime.dotnet.threads.count29 ± (29 - 29)29 ± (29 - 29)+0.3%✅⬆️
Comparison explanation

Execution-time benchmarks measure the whole time it takes to execute a program, and are intended to measure the one-off costs. Cases where the execution time results for the PR are worse than latest master results are highlighted in **red**. The following thresholds were used for comparing the execution times:

  • Welch test with statistical test for significance of 5%
  • Only results indicating a difference greater than 5% and 5 ms are considered.

Note that these results are based on a single point-in-time result for each branch. For full results, see the dashboard.

Graphs show the p99 interval based on the mean and StdDev of the test run, as well as the mean value of the run (shown as a diamond below the graph).

Duration charts
FakeDbCommand (.NET Framework 4.8) 
gantt
    title Execution time (ms) FakeDbCommand (.NET Framework 4.8)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (73ms)  : 71, 75
    master - mean (74ms)  : 72, 76

    section Bailout
    This PR (8170) - mean (77ms)  : 76, 79
    master - mean (79ms)  : 76, 82

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (1,064ms)  : 1018, 1110
    master - mean (1,077ms)  : 1036, 1119
Loading
FakeDbCommand (.NET Core 3.1) 
gantt
    title Execution time (ms) FakeDbCommand (.NET Core 3.1)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (114ms)  : 110, 117
    master - mean (116ms)  : 113, 120

    section Bailout
    This PR (8170) - mean (114ms)  : 112, 115
    master - mean (117ms)  : 114, 120

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (755ms)  : 693, 817
    master - mean (766ms)  : 704, 827
Loading
FakeDbCommand (.NET 6) 
gantt
    title Execution time (ms) FakeDbCommand (.NET 6)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (102ms)  : 98, 105
    master - mean (103ms)  : 100, 106

    section Bailout
    This PR (8170) - mean (103ms)  : 101, 104
    master - mean (104ms)  : 102, 107

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (744ms)  : 684, 805
    master - mean (759ms)  : 697, 822
Loading
FakeDbCommand (.NET 8) 
gantt
    title Execution time (ms) FakeDbCommand (.NET 8)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (100ms)  : 97, 103
    master - mean (102ms)  : 99, 104

    section Bailout
    This PR (8170) - mean (102ms)  : 99, 104
    master - mean (103ms)  : 100, 105

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (669ms)  : 651, 687
    master - mean (677ms)  : 648, 706
Loading
HttpMessageHandler (.NET Framework 4.8) 
gantt
    title Execution time (ms) HttpMessageHandler (.NET Framework 4.8)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (192ms)  : 189, 196
    master - mean (194ms)  : 190, 199

    section Bailout
    This PR (8170) - mean (196ms)  : 193, 199
    master - mean (198ms)  : 195, 200

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (1,141ms)  : 1083, 1198
    master - mean (1,144ms)  : 1081, 1208
Loading
HttpMessageHandler (.NET Core 3.1) 
gantt
    title Execution time (ms) HttpMessageHandler (.NET Core 3.1)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (277ms)  : 272, 283
    master - mean (278ms)  : 272, 284

    section Bailout
    This PR (8170) - mean (277ms)  : 274, 280
    master - mean (278ms)  : 275, 282

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (929ms)  : 884, 974
    master - mean (932ms)  : 879, 984
Loading
HttpMessageHandler (.NET 6) 
gantt
    title Execution time (ms) HttpMessageHandler (.NET 6)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (270ms)  : 264, 277
    master - mean (271ms)  : 266, 276

    section Bailout
    This PR (8170) - mean (270ms)  : 265, 275
    master - mean (270ms)  : 266, 275

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (923ms)  : 882, 963
    master - mean (930ms)  : 890, 970
Loading
HttpMessageHandler (.NET 8) 
gantt
    title Execution time (ms) HttpMessageHandler (.NET 8)
    dateFormat  x
    axisFormat %Q
    todayMarker off
    section Baseline
    This PR (8170) - mean (268ms)  : 262, 273
    master - mean (273ms)  : 264, 282

    section Bailout
    This PR (8170) - mean (267ms)  : 265, 270
    master - mean (273ms)  : 267, 279

    section CallTarget+Inlining+NGEN
    This PR (8170) - mean (832ms)  : 808, 855
    master - mean (831ms)  : 814, 848
Loading

@andrewlock andrewlock mentioned this pull request Feb 9, 2026
Merged
andrewlock added a commit that referenced this pull request Feb 11, 2026
@andrewlock
Make ValueStringBuilder available in .NET Core 3.1 (#8167)
53ab69a 
## Summary of changes

Makes `ValueStringBuilder` usable in .NET Core 3.1+, instead of just
.NET 6

## Reason for change

I want to use it in some aspnetcore improvements, but currently it's
only exposed in .NET 6

## Implementation details

Update the `#if`. Note that I originally made this available in _all_
TFMs, using our vendored spans, but benchmarking showed that this was
actively harmful compared to just using `StringBuilderCache`, so to
avoid incorrect use, just restricting it for now.

## Test coverage

Updated the tests to cover .NET Core 3.1 too.

## Other details

Part of a stack
https://datadoghq.atlassian.net/browse/LANGPLAT-842


- #8167 👈
- #8170
Base automatically changed from andrew/aspnetcore-perf/valuestringbuilder to master February 11, 2026 10:42
@andrewlock andrewlock force-pushed the andrew/aspnetcore-perf/route-templates branch 2 times, most recently from 4172b5b to 6cc2185 Compare February 12, 2026 08:57
@andrewlock andrewlock mentioned this pull request Feb 17, 2026
Merged
@andrewlock andrewlock requested a review from Copilot February 18, 2026 09:01
Copilot AI reviewed Feb 18, 2026
View reviewed changes
Copy link
Contributor

Copilot AI left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Pull request overview

This pull request optimizes the performance of AspNetCoreResourceNameHelper.SimplifyRouteTemplate() to reduce memory allocations and improve execution speed for ASP.NET Core route template processing. The method is used primarily in pre-endpoint routing flows to generate resource names from route templates.

Changes:

  • Introduced ValueStringBuilder for stack-allocated string building on .NET Core 3.1+ to reduce heap allocations
  • Optimized IsIdentifierSegment() to fast-track common numeric and GUID types, avoiding unnecessary ToString() calls
  • Removed enumerator boxing by explicitly casting routePattern.Segments to List<TemplateSegment>

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 5 comments.

File Description
tracer/src/Datadog.Trace/DiagnosticListeners/AspNetCoreResourceNameHelper.cs Refactored SimplifyRouteTemplate() to use ValueStringBuilder on .NET Core 3.1+ and optimized IsIdentifierSegment() with type-based fast paths
tracer/test/Datadog.Trace.Tests/DiagnosticListeners/AspNetCoreResourceNameHelperTests.cs Added comprehensive test coverage for IsIdentifierSegment() behavior with various input types
tracer/test/Datadog.Trace.Tests/Util/UriHelpersTests.cs Added extensive test cases for UriHelpers.IsIdentifierSegment() covering edge cases like GUIDs, hex strings, and numeric patterns

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

andrewlock added a commit that referenced this pull request Feb 18, 2026
@andrewlock
Minor aspnetcore perf improvements (#8210)
6ee224f 
## Summary of changes

A few minor improvements to the standard `AspNetCoreDiagnosticObserver`

## Reason for change

Looking into obvious perf improvements for ASP.NET Core, but only a few
minor things stood out (apart from related PRs like #8199 and #8203).

## Implementation details

- Reduce size of MVC tags object by not deriving from `WebTags` (we
never set those tags anyway)
- Delay creating spanlinks collection if we don't need it
- HttpRoute always matches AspNetCoreRoute, so can make it readonly

## Test coverage

Covered by existing tests, benchmarks show (tiny) allocation gains

## Other details


Relates to https://datadoghq.atlassian.net/browse/LANGPLAT-842

Related PRs:
- #8167
- #8170
- #8180
- #8196
- #8199
- #8203
@andrewlock andrewlock force-pushed the andrew/aspnetcore-perf/route-templates branch from 6cc2185 to b02265c Compare February 18, 2026 09:39
@andrewlock andrewlock merged commit 9882e7c into master Feb 18, 2026
142 checks passed
@andrewlock andrewlock deleted the andrew/aspnetcore-perf/route-templates branch February 18, 2026 11:53
@github-actions github-actions bot added this to the vNext-v3 milestone Feb 18, 2026
andrewlock added a commit that referenced this pull request Feb 18, 2026
@andrewlock
Improve performance of `AspNetCoreResourceNameHelper.SimplifyRoutePat…
c446bb5 
…tern` (#8180)

## Summary of changes

Switches to using `ValueStringBuilder` and other minor perf improvements

## Reason for change

Same as #8170, we want to improve performance where we can.
Unfortunately, we can't easily avoid the enumeration allocation like we
did in that PR, so most of the benefits here are simply from using
`ValueStringBuilder` and other minor changes.

## Implementation details

Incorporated various changes based on the `SimplifyRoutePattern` that we
use in the single-span aspnetcore observer and the changes made in
#8170. The gains aren't as high here, because we can't reduce
enumeration allocation.

## Test coverage

Covered by existing tests.

Ran benchmarks using the values. In general, there's a slight regression
in duration for an improvement in Alloc Ratio. It's not very consistent
though, particularly in <.NET Core 3.1. I think it's probably still
worth the change, but open to thoughts


| Method | Runtime | Has Defaults | Expand Templates | Mean | Allocated
| Alloc Ratio |
| -------- | ------------- | ------------ | ---------------- | --------:
| --------: | ----------: |
| Original | .NET 10.0 | False | False | 6.605 us | 6.51 KB | 1.00 |
| Updated | .NET 10.0 | False | False | 8.559 us | 4.8 KB | 0.74 |
| Original | .NET 6.0 | False | False | 11.466 us | 6.51 KB | 1.00 |
| Updated | .NET 6.0 | False | False | 11.654 us | 4.8 KB | 0.74 |
| Original | .NET Core 3.1 | False | False | 13.808 us | 6.51 KB | 1.00
|
| Updated | .NET Core 3.1 | False | False | 15.266 us | 4.8 KB | 0.74 |
| Original | .NET Core 3.0 | False | False | 13.962 us | 6.51 KB | 1.00
|
| Updated | .NET Core 3.0 | False | False | 19.757 us | 6.51 KB | 1.00 |
| | | | | | | |
| Original | .NET 10.0 | False | True | 6.453 us | 6.2 KB | 0.99 |
| Updated | .NET 10.0 | False | True | 8.116 us | 4.65 KB | 0.75 |
| Original | .NET 6.0 | False | True | 11.121 us | 6.23 KB | 1.00 |
| Updated | .NET 6.0 | False | True | 11.375 us | 4.65 KB | 0.75 |
| Original | .NET Core 3.1 | False | True | 14.075 us | 6.23 KB | 1.00 |
| Updated | .NET Core 3.1 | False | True | 15.000 us | 4.65 KB | 0.75 |
| Original | .NET Core 3.0 | False | True | 14.027 us | 6.23 KB | 1.00 |
| Updated | .NET Core 3.0 | False | True | 13.687 us | 6.2 KB | 0.99 |
| | | | | | | |
| Original | .NET 10.0 | True | False | 6.348 us | 6.51 KB | 1.00 |
| Updated | .NET 10.0 | True | False | 8.310 us | 4.8 KB | 0.74 |
| Original | .NET 6.0 | True | False | 11.082 us | 6.51 KB | 1.00 |
| Updated | .NET 6.0 | True | False | 11.406 us | 4.8 KB | 0.74 |
| Original | .NET Core 3.1 | True | False | 9.853 us | 6.51 KB | 1.00 |
| Updated | .NET Core 3.1 | True | False | 10.865 us | 4.8 KB | 0.74 |
| Original | .NET Core 3.0 | True | False | 14.879 us | 6.51 KB | 1.00 |
| Updated | .NET Core 3.0 | True | False | 10.221 us | 6.51 KB | 1.00 |
| | | | | | | |
| Original | .NET 10.0 | True | True | 4.002 us | 6.2 KB | 0.99 |
| Updated | .NET 10.0 | True | True | 5.685 us | 4.65 KB | 0.75 |
| Original | .NET 6.0 | True | True | 7.964 us | 6.23 KB | 1.00 |
| Updated | .NET 6.0 | True | True | 8.385 us | 4.65 KB | 0.75 |
| Original | .NET Core 3.1 | True | True | 13.949 us | 6.23 KB | 1.00 |
| Updated | .NET Core 3.1 | True | True | 15.370 us | 4.65 KB | 0.75 |
| Original | .NET Core 3.0 | True | True | 10.116 us | 6.23 KB | 1.00 |
| Updated | .NET Core 3.0 | True | True | 10.241 us | 6.2 KB | 0.99 |


## Other details
Part of a stack
https://datadoghq.atlassian.net/browse/LANGPLAT-842

- #8167
- #8170
- #8180 👈
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

Copilot code review Copilot Copilot left review comments

@chatgpt-codex-connector chatgpt-codex-connector[bot] chatgpt-codex-connector[bot] left review comments

@lucaspimentel lucaspimentel lucaspimentel approved these changes

Assignees

No one assigned

Labels

area:integrations area:tracer The core tracer library (Datadog.Trace, does not include OpenTracing, native code, or integrations) type:performance Performance, speed, latency, resource usage (CPU, memory)

Projects

None yet

Milestone

3.38.0

Development

Successfully merging this pull request may close these issues.

3 participants

@andrewlock @lucaspimentel