add activities for some template creation pathways

baronfel · baronfel · commit 1a2426b904f4 · 2025-09-03T21:54:44.000-05:00
diff --git a/.editorconfig b/.editorconfig
@@ -280,6 +280,10 @@ dotnet_diagnostic.IDE0200.severity = none
 dotnet_diagnostic.IDE0240.severity = warning
 
 # Additional rules for template engine source code
+
+# Default severity for analyzer diagnostics with category 'StyleCop.CSharp.SpacingRules'
+dotnet_analyzer_diagnostic.category-StyleCop.CSharp.SpacingRules.severity = none
+
 [{src,test}/**{Microsoft.TemplateEngine.*,dotnet-new?*}/**.cs]
 # Default analyzed API surface = 'public' (public APIs)
 dotnet_code_quality.api_surface = public
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
@@ -51,13 +51,13 @@ internal InstantiateCommand(
             Arity = new ArgumentArity(0, 999)
         };
 
-        internal IReadOnlyList<Option> PassByOptions { get; } = new Option[]
-        {
+        internal IReadOnlyList<Option> PassByOptions { get; } =
+        [
             SharedOptions.ForceOption,
             SharedOptions.NameOption,
             SharedOptions.DryRunOption,
             SharedOptions.NoUpdateCheckOption
-        };
+        ];
 
         internal static Task<NewCommandStatus> ExecuteAsync(
             NewCommandArgs newCommandArgs,
@@ -74,6 +74,7 @@ internal static async Task<IEnumerable<TemplateGroup>> GetTemplateGroupsAsync(
             HostSpecificDataLoader hostSpecificDataLoader,
             CancellationToken cancellationToken)
         {
+            using var createTemplateGroupsActivity = Activities.Source.StartActivity("create-template-groups");
             IReadOnlyList<ITemplateInfo> templates = await templatePackageManager.GetTemplatesAsync(cancellationToken).ConfigureAwait(false);
             return TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templates, hostSpecificDataLoader));
         }
@@ -84,6 +85,7 @@ internal static HashSet<TemplateCommand> GetTemplateCommand(
                 TemplatePackageManager templatePackageManager,
                 TemplateGroup templateGroup)
         {
+            using var getTemplateActivity = Activities.Source.StartActivity("get-template-command");
             //groups templates in the group by precedence
             foreach (IGrouping<int, CliTemplateInfo> templateGrouping in templateGroup.Templates.GroupBy(g => g.Precedence).OrderByDescending(g => g.Key))
             {
@@ -114,7 +116,7 @@ internal static HashSet<TemplateCommand> GetTemplateCommand(
                     templateGroup,
                     candidates);
             }
-            return new HashSet<TemplateCommand>();
+            return [];
         }
 
         internal static void HandleNoMatchingTemplateGroup(InstantiateCommandArgs instantiateArgs, IEnumerable<TemplateGroup> templateGroups, IReporter reporter)
@@ -204,6 +206,8 @@ private static async Task<NewCommandStatus> ExecuteIntAsync(
 
                 return await templateListCoordinator.DisplayCommandDescriptionAsync(instantiateArgs, cancellationToken).ConfigureAwait(false);
             }
+            using var createActivity = Activities.Source.StartActivity("instantiate-command");
+            createActivity?.DisplayName = $"Invoke '{instantiateArgs.ShortName}'";
 
             IEnumerable<TemplateGroup> allTemplateGroups = await GetTemplateGroupsAsync(
                 templatePackageManager,
@@ -273,10 +277,11 @@ private static async Task<NewCommandStatus> HandleTemplateInstantiationAsync(
             {
                 TemplateCommand templateCommandToRun = candidates.Single();
                 args.Command.Subcommands.Add(templateCommandToRun);
-
+                var templateParseActivity = Activities.Source.StartActivity("reparse-for-template");
                 ParseResult updatedParseResult = args.ParseResult.RootCommandResult.Command.Parse(
                     args.ParseResult.Tokens.Select(t => t.Value).ToArray(),
                     args.ParseResult.Configuration);
+                templateParseActivity?.Stop();
                 return await candidates.Single().InvokeAsync(updatedParseResult, cancellationToken).ConfigureAwait(false);
             }
             else if (candidates.Any())
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
@@ -17,7 +17,7 @@ namespace Microsoft.TemplateEngine.Cli.Commands
     internal class TemplateCommand : Command
     {
         private static readonly TimeSpan ConstraintEvaluationTimeout = TimeSpan.FromMilliseconds(1000);
-        private static readonly string[] _helpAliases = new[] { "-h", "/h", "--help", "-?", "/?" };
+        private static readonly string[] _helpAliases = ["-h", "/h", "--help", "-?", "/?"];
         private readonly TemplatePackageManager _templatePackageManager;
         private readonly IEngineEnvironmentSettings _environmentSettings;
         private readonly BaseCommand _instantiateCommand;
@@ -146,19 +146,23 @@ internal static async Task<IReadOnlyList<TemplateConstraintResult>> ValidateCons
 
         internal async Task<NewCommandStatus> InvokeAsync(ParseResult parseResult, CancellationToken cancellationToken)
         {
+            using var templateInvocationActivity = Activities.Source.StartActivity("invoke-template");
             TemplateCommandArgs args = new(this, _instantiateCommand, parseResult);
             TemplateInvoker invoker = new(_environmentSettings, () => Console.ReadLine() ?? string.Empty);
             TemplatePackageCoordinator packageCoordinator = new(_environmentSettings, _templatePackageManager);
-            TemplateConstraintManager constraintManager = new(_environmentSettings);
+            using TemplateConstraintManager constraintManager = new(_environmentSettings);
             TemplatePackageDisplay templatePackageDisplay = new(Reporter.Output, Reporter.Error);
 
             CancellationTokenSource cancellationTokenSource = new();
             cancellationTokenSource.CancelAfter(ConstraintEvaluationTimeout);
 
+#pragma warning disable CA2025 // Do not pass 'IDisposable' instances into unawaited tasks
             Task<IReadOnlyList<TemplateConstraintResult>> constraintsEvaluation = ValidateConstraintsAsync(constraintManager, args.Template, args.IsForceFlagSpecified ? cancellationTokenSource.Token : cancellationToken);
+#pragma warning restore CA2025 // Do not pass 'IDisposable' instances into unawaited tasks
 
             if (!args.IsForceFlagSpecified)
             {
+                using var constraintResultsActivity = Activities.Source.StartActivity("validate-constraints");
                 var constraintResults = await constraintsEvaluation.ConfigureAwait(false);
                 if (constraintResults.Any())
                 {
@@ -173,7 +177,7 @@ internal async Task<NewCommandStatus> InvokeAsync(ParseResult parseResult, Cance
             Task<(string Id, string Version, string Provider)> builtInPackageCheck = packageCoordinator.ValidateBuiltInPackageAvailabilityAsync(args.Template, cancellationToken);
             Task<CheckUpdateResult?> checkForUpdateTask = packageCoordinator.CheckUpdateForTemplate(args, cancellationToken);
 
-            Task[] tasksToWait = new Task[] { instantiateTask, builtInPackageCheck, checkForUpdateTask };
+            Task[] tasksToWait = [instantiateTask, builtInPackageCheck, checkForUpdateTask];
 
             await Task.WhenAll(tasksToWait).ConfigureAwait(false);
             Reporter.Output.WriteLine();
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs
@@ -37,6 +37,7 @@ internal TemplateInvoker(
 
         internal async Task<NewCommandStatus> InvokeTemplateAsync(TemplateCommandArgs templateArgs, CancellationToken cancellationToken)
         {
+            using var invokerActivity = Activities.Source.StartActivity("invoker-invoking");
             cancellationToken.ThrowIfCancellationRequested();
 
             CliTemplateInfo templateToRun = templateArgs.Template;
@@ -158,6 +159,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem
 
             try
             {
+                using var templateCreationActivity = Activities.Source.StartActivity("actual-instantiate-template");
                 instantiateResult = await _templateCreator.InstantiateAsync(
                     templateArgs.Template,
                     templateArgs.Name,
@@ -306,6 +308,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem
 
         private NewCommandStatus HandlePostActions(ITemplateCreationResult creationResult, TemplateCommandArgs args)
         {
+            using var postActionActivity = Activities.Source.StartActivity("post-actions");
             PostActionExecutionStatus result = _postActionDispatcher.Process(creationResult, args.IsDryRun, args.AllowScripts ?? AllowRunScripts.Prompt);
 
             return result switch
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
@@ -24,12 +24,12 @@ internal TemplateListCoordinator(
             IEngineEnvironmentSettings engineEnvironmentSettings,
             TemplatePackageManager templatePackageManager,
             IHostSpecificDataLoader hostSpecificDataLoader)
-
         {
             _engineEnvironmentSettings = engineEnvironmentSettings ?? throw new ArgumentNullException(nameof(engineEnvironmentSettings));
             _templatePackageManager = templatePackageManager ?? throw new ArgumentNullException(nameof(templatePackageManager));
             _hostSpecificDataLoader = hostSpecificDataLoader ?? throw new ArgumentNullException(nameof(hostSpecificDataLoader));
             _defaultLanguage = engineEnvironmentSettings.GetDefaultLanguage();
+            using var constraintManagerActivity = Activities.Source.StartActivity("create-constraints");
             _constraintManager = new TemplateConstraintManager(_engineEnvironmentSettings);
         }
 
@@ -48,7 +48,6 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
             ListTemplateResolver resolver = new(_constraintManager, _templatePackageManager, _hostSpecificDataLoader);
             TemplateResolutionResult resolutionResult = await resolver.ResolveTemplatesAsync(args, _defaultLanguage, cancellationToken).ConfigureAwait(false);
 
-            //IReadOnlyDictionary<string, string?>? appliedParameterMatches = resolutionResult.GetAllMatchedParametersList();
             if (resolutionResult.TemplateGroupsWithMatchingTemplateInfoAndParameters.Any())
             {
                 Reporter.Output.WriteLine(LocalizableStrings.TemplatesFoundMatchingInputParameters, GetInputParametersString(args));
@@ -66,10 +65,10 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
             }
             else
             {
-                //if there is no criteria and filters it means that dotnet new list was run but there is no templates installed.
+                // If there is no criteria and filters, it means that dotnet new list was run but there are no templates installed.
                 if (args.ListNameCriteria == null && !args.AppliedFilters.Any())
                 {
-                    //No templates installed.
+                    // No templates installed.
                     Reporter.Output.WriteLine(LocalizableStrings.NoTemplatesFound);
                     Reporter.Output.WriteLine();
                     // To search for the templates on NuGet.org, run:
@@ -83,7 +82,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
                     return NewCommandStatus.Success;
                 }
 
-                // at least one criteria was specified.
+                // At least one criteria was specified.
                 // No templates found matching the following input parameter(s): {0}.
                 Reporter.Error.WriteLine(
                     string.Format(
@@ -195,33 +194,30 @@ internal async Task<NewCommandStatus> DisplayCommandDescriptionAsync(
             return NewCommandStatus.Success;
         }
 
-        private static string GetInputParametersString(ListCommandArgs args/*, IReadOnlyDictionary<string, string?>? templateParameters = null*/)
+        private static string GetInputParametersString(ListCommandArgs args)
         {
             string separator = ", ";
             IEnumerable<string> appliedFilters = args.AppliedFilters
                     .Select(filter => $"{args.GetFilterToken(filter)}='{args.GetFilterValue(filter)}'");
 
-            //IEnumerable<string> appliedTemplateParameters = templateParameters?
-            //       .Select(param => string.IsNullOrWhiteSpace(param.Value) ? param.Key : $"{param.Key}='{param.Value}'") ?? Array.Empty<string>();
-
             StringBuilder inputParameters = new();
             string? mainCriteria = args.ListNameCriteria;
             if (!string.IsNullOrWhiteSpace(mainCriteria))
             {
                 inputParameters.Append($"'{mainCriteria}'");
-                if (appliedFilters.Any()/* || appliedTemplateParameters.Any()*/)
+                if (appliedFilters.Any())
                 {
                     inputParameters.Append(separator);
                 }
             }
-            if (appliedFilters/*.Concat(appliedTemplateParameters)*/.Any())
+            if (appliedFilters.Any())
             {
-                inputParameters.Append(string.Join(separator, appliedFilters/*.Concat(appliedTemplateParameters)*/));
+                inputParameters.Append(string.Join(separator, appliedFilters));
             }
             return inputParameters.ToString();
         }
 
-        private static string GetPartialMatchReason(TemplateResolutionResult templateResolutionResult, ListCommandArgs args/*, IReadOnlyDictionary<string, string?>? templateParameters = null*/)
+        private static string GetPartialMatchReason(TemplateResolutionResult templateResolutionResult, ListCommandArgs args)
         {
             string separator = ", ";
 
@@ -230,15 +226,10 @@ private static string GetPartialMatchReason(TemplateResolutionResult templateRes
                     .Where(filter => filter.MismatchCriteria(templateResolutionResult))
                     .Select(filter => $"{args.GetFilterToken(filter)}='{args.GetFilterValue(filter)}'");
 
-            //IEnumerable<string> appliedTemplateParameters = templateParameters?
-            //       .Where(parameter =>
-            //            templateResolutionResult.IsParameterMismatchReason(parameter.Key))
-            //       .Select(param => string.IsNullOrWhiteSpace(param.Value) ? param.Key : $"{param.Key}='{param.Value}'") ?? Array.Empty<string>();
-
             StringBuilder inputParameters = new();
-            if (appliedFilters/*.Concat(appliedTemplateParameters)*/.Any())
+            if (appliedFilters.Any())
             {
-                inputParameters.Append(string.Join(separator, appliedFilters/*.Concat(appliedTemplateParameters)*/));
+                inputParameters.Append(string.Join(separator, appliedFilters));
             }
             return inputParameters.ToString();
         }

Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,7 @@ internal TemplateInvoker(`
`37`	`37`
`38`	`38`	`internal async Task<NewCommandStatus> InvokeTemplateAsync(TemplateCommandArgs templateArgs, CancellationToken cancellationToken)`
`39`	`39`	`{`
	`40`	`+ using var invokerActivity = Activities.Source.StartActivity("invoker-invoking");`
`40`	`41`	`cancellationToken.ThrowIfCancellationRequested();`
`41`	`42`
`42`	`43`	`CliTemplateInfo templateToRun = templateArgs.Template;`
`@@ -158,6 +159,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem`
`158`	`159`
`159`	`160`	`try`
`160`	`161`	`{`
	`162`	`+ using var templateCreationActivity = Activities.Source.StartActivity("actual-instantiate-template");`
`161`	`163`	`instantiateResult = await _templateCreator.InstantiateAsync(`
`162`	`164`	`templateArgs.Template,`
`163`	`165`	`templateArgs.Name,`
`@@ -306,6 +308,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem`
`306`	`308`
`307`	`309`	`private NewCommandStatus HandlePostActions(ITemplateCreationResult creationResult, TemplateCommandArgs args)`
`308`	`310`	`{`
	`311`	`+ using var postActionActivity = Activities.Source.StartActivity("post-actions");`
`309`	`312`	`PostActionExecutionStatus result = _postActionDispatcher.Process(creationResult, args.IsDryRun, args.AllowScripts ?? AllowRunScripts.Prompt);`
`310`	`313`
`311`	`314`	`return result switch`
Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ internal TemplateListCoordinator(`
`24`	`24`	`IEngineEnvironmentSettings engineEnvironmentSettings,`
`25`	`25`	`TemplatePackageManager templatePackageManager,`
`26`	`26`	`IHostSpecificDataLoader hostSpecificDataLoader)`
`27`		`-`
`28`	`27`	`{`
`29`	`28`	`_engineEnvironmentSettings = engineEnvironmentSettings ?? throw new ArgumentNullException(nameof(engineEnvironmentSettings));`
`30`	`29`	`_templatePackageManager = templatePackageManager ?? throw new ArgumentNullException(nameof(templatePackageManager));`
`31`	`30`	`_hostSpecificDataLoader = hostSpecificDataLoader ?? throw new ArgumentNullException(nameof(hostSpecificDataLoader));`
`32`	`31`	`_defaultLanguage = engineEnvironmentSettings.GetDefaultLanguage();`
	`32`	`+ using var constraintManagerActivity = Activities.Source.StartActivity("create-constraints");`
`33`	`33`	`_constraintManager = new TemplateConstraintManager(_engineEnvironmentSettings);`
`34`	`34`	`}`
`35`	`35`
`@@ -48,7 +48,6 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(`
`48`	`48`	`ListTemplateResolver resolver = new(_constraintManager, _templatePackageManager, _hostSpecificDataLoader);`
`49`	`49`	`TemplateResolutionResult resolutionResult = await resolver.ResolveTemplatesAsync(args, _defaultLanguage, cancellationToken).ConfigureAwait(false);`
`50`	`50`
`51`		`- //IReadOnlyDictionary<string, string?>? appliedParameterMatches = resolutionResult.GetAllMatchedParametersList();`
`52`	`51`	`if (resolutionResult.TemplateGroupsWithMatchingTemplateInfoAndParameters.Any())`
`53`	`52`	`{`
`54`	`53`	`Reporter.Output.WriteLine(LocalizableStrings.TemplatesFoundMatchingInputParameters, GetInputParametersString(args));`
`@@ -66,10 +65,10 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(`
`66`	`65`	`}`
`67`	`66`	`else`
`68`	`67`	`{`
`69`		`- //if there is no criteria and filters it means that dotnet new list was run but there is no templates installed.`
	`68`	`+ // If there is no criteria and filters, it means that dotnet new list was run but there are no templates installed.`
`70`	`69`	`if (args.ListNameCriteria == null && !args.AppliedFilters.Any())`
`71`	`70`	`{`
`72`		`- //No templates installed.`
	`71`	`+ // No templates installed.`
`73`	`72`	`Reporter.Output.WriteLine(LocalizableStrings.NoTemplatesFound);`
`74`	`73`	`Reporter.Output.WriteLine();`
`75`	`74`	`// To search for the templates on NuGet.org, run:`
`@@ -83,7 +82,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(`
`83`	`82`	`return NewCommandStatus.Success;`
`84`	`83`	`}`
`85`	`84`
`86`		`- // at least one criteria was specified.`
	`85`	`+ // At least one criteria was specified.`
`87`	`86`	`// No templates found matching the following input parameter(s): {0}.`
`88`	`87`	`Reporter.Error.WriteLine(`
`89`	`88`	`string.Format(`
`@@ -195,33 +194,30 @@ internal async Task<NewCommandStatus> DisplayCommandDescriptionAsync(`
`195`	`194`	`return NewCommandStatus.Success;`
`196`	`195`	`}`
`197`	`196`
`198`		`- private static string GetInputParametersString(ListCommandArgs args/, IReadOnlyDictionary<string, string?>? templateParameters = null/)`
	`197`	`+ private static string GetInputParametersString(ListCommandArgs args)`
`199`	`198`	`{`
`200`	`199`	`string separator = ", ";`
`201`	`200`	`IEnumerable<string> appliedFilters = args.AppliedFilters`
`202`	`201`	`.Select(filter => $"{args.GetFilterToken(filter)}='{args.GetFilterValue(filter)}'");`
`203`	`202`
`204`		`- //IEnumerable<string> appliedTemplateParameters = templateParameters?`
`205`		`- // .Select(param => string.IsNullOrWhiteSpace(param.Value) ? param.Key : $"{param.Key}='{param.Value}'") ?? Array.Empty<string>();`
`206`		`-`
`207`	`203`	`StringBuilder inputParameters = new();`
`208`	`204`	`string? mainCriteria = args.ListNameCriteria;`
`209`	`205`	`if (!string.IsNullOrWhiteSpace(mainCriteria))`
`210`	`206`	`{`
`211`	`207`	`inputParameters.Append($"'{mainCriteria}'");`
`212`		`- if (appliedFilters.Any()/* \|\| appliedTemplateParameters.Any()*/)`
	`208`	`+ if (appliedFilters.Any())`
`213`	`209`	`{`
`214`	`210`	`inputParameters.Append(separator);`
`215`	`211`	`}`
`216`	`212`	`}`
`217`		`- if (appliedFilters/.Concat(appliedTemplateParameters)/.Any())`
	`213`	`+ if (appliedFilters.Any())`
`218`	`214`	`{`
`219`		`- inputParameters.Append(string.Join(separator, appliedFilters/.Concat(appliedTemplateParameters)/));`
	`215`	`+ inputParameters.Append(string.Join(separator, appliedFilters));`
`220`	`216`	`}`
`221`	`217`	`return inputParameters.ToString();`
`222`	`218`	`}`
`223`	`219`
`224`		`- private static string GetPartialMatchReason(TemplateResolutionResult templateResolutionResult, ListCommandArgs args/, IReadOnlyDictionary<string, string?>? templateParameters = null/)`
	`220`	`+ private static string GetPartialMatchReason(TemplateResolutionResult templateResolutionResult, ListCommandArgs args)`
`225`	`221`	`{`
`226`	`222`	`string separator = ", ";`
`227`	`223`
`@@ -230,15 +226,10 @@ private static string GetPartialMatchReason(TemplateResolutionResult templateRes`
`230`	`226`	`.Where(filter => filter.MismatchCriteria(templateResolutionResult))`
`231`	`227`	`.Select(filter => $"{args.GetFilterToken(filter)}='{args.GetFilterValue(filter)}'");`
`232`	`228`
`233`		`- //IEnumerable<string> appliedTemplateParameters = templateParameters?`
`234`		`- // .Where(parameter =>`
`235`		`- // templateResolutionResult.IsParameterMismatchReason(parameter.Key))`
`236`		`- // .Select(param => string.IsNullOrWhiteSpace(param.Value) ? param.Key : $"{param.Key}='{param.Value}'") ?? Array.Empty<string>();`
`237`		`-`
`238`	`229`	`StringBuilder inputParameters = new();`
`239`		`- if (appliedFilters/.Concat(appliedTemplateParameters)/.Any())`
	`230`	`+ if (appliedFilters.Any())`
`240`	`231`	`{`
`241`		`- inputParameters.Append(string.Join(separator, appliedFilters/.Concat(appliedTemplateParameters)/));`
	`232`	`+ inputParameters.Append(string.Join(separator, appliedFilters));`
`242`	`233`	`}`
`243`	`234`	`return inputParameters.ToString();`
`244`	`235`	`}`