Add artifact naming service with template support for consistent naming across extensions

.config/dotnet-tools.json

@@ -10,4 +10,4 @@
       "rollForward": false
     }
   }
-}
+}

docs/microsoft.testing.platform/ArtifactNamingHelper.md

@@ -0,0 +1,54 @@
+# Artifact Naming Helper
+
+The `ArtifactNamingHelper` is a shared static helper that provides a standardized way to generate consistent names and paths for test artifacts. It is compiled into each extension that needs it via file linking (no service registration or IVT required).
+
+## Template-Based Naming
+
+Use placeholders in curly braces to create dynamic file names. Placeholder matching is **case-sensitive** — use lowercase placeholder names (e.g., `{pname}`, not `{PName}`).
+
+```text
+{pname}_{pid}_{time}_hang.dmp
+```
+
+Resolves to: `MyTests_12345_2025-09-22_13-49-34.0000000_hang.dmp`
+
+## Available Placeholders
+
+| Placeholder | Description | Example |
+|-------------|-------------|---------|
+| `{pname}` | Name of the process | `MyTests` |
+| `{pid}` | Process ID | `12345` |
+| `{asm}` | Assembly name (entry assembly, or `unknown` if unavailable) | `MyTests` |
+| `{tfm}` | Target framework moniker (best-effort, detected at runtime — may differ from the build-time TFM, e.g. a `net462` assembly running on .NET Framework 4.8 reports `net481`) | `net9.0`, `net8.0` |
+| `{time}` | Timestamp (high precision) | `2025-09-22_13-49-34.0000000` |
+
+## Backward Compatibility
+
+Legacy patterns like `%p` continue to work in the hang dump extension.
+
+## Custom Replacements
+
+Override default values for specific scenarios:
+
+```csharp
+var replacements = new Dictionary<string, string>
+{
+    ["pname"] = "Notepad",
+    ["pid"] = "1111"
+};
+
+string result = ArtifactNamingHelper.ResolveTemplate("{pname}_{pid}.dmp", replacements);
+// Result: "Notepad_1111.dmp"
+```
+
+## Hang Dump Integration
+
+The hang dump extension uses the artifact naming helper and supports both legacy and modern patterns:
+
+```text
+# Legacy pattern (still works)
+--hangdump-filename "mydump_%p.dmp"
+
+# New template pattern
+--hangdump-filename "{pname}_{pid}_{time}_hang.dmp"
+```

src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs

@@ -16,6 +16,7 @@
 using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.Messages;
 using Microsoft.Testing.Platform.OutputDevice;
+using Microsoft.Testing.Platform.Services;
 
 #if NETCOREAPP
 using Microsoft.Diagnostics.NETCore.Client;
@@ -118,10 +119,10 @@ public async Task BeforeTestHostProcessStartAsync(CancellationToken cancellation
 
         _waitConnectionTask = _task.Run(
             async () =>
-        {
-            await _logger.LogDebugAsync($"Waiting for connection to {_singleConnectionNamedPipeServer.PipeName.Name}").ConfigureAwait(false);
-            await _singleConnectionNamedPipeServer.WaitConnectionAsync(cancellationToken).TimeoutAfterAsync(TimeoutHelper.DefaultHangTimeSpanTimeout, cancellationToken).ConfigureAwait(false);
-        }, cancellationToken);
+            {
+                await _logger.LogDebugAsync($"Waiting for connection to {_singleConnectionNamedPipeServer.PipeName.Name}").ConfigureAwait(false);
+                await _singleConnectionNamedPipeServer.WaitConnectionAsync(cancellationToken).TimeoutAfterAsync(TimeoutHelper.DefaultHangTimeSpanTimeout, cancellationToken).ConfigureAwait(false);
+            }, cancellationToken);
     }
 
     private async Task<IResponse> CallbackAsync(IRequest request)
@@ -307,14 +308,40 @@ private async Task TakeDumpAsync(IProcess process, CancellationToken cancellatio
         ApplicationStateGuard.Ensure(_testHostProcessInformation is not null);
         ApplicationStateGuard.Ensure(_dumpType is not null);
 
-        string finalDumpFileName = (_dumpFileNamePattern ?? $"{process.Name}_%p_hang.dmp").Replace("%p", process.Id.ToString(CultureInfo.InvariantCulture));
-        finalDumpFileName = Path.Combine(_configuration.GetTestResultDirectory(), finalDumpFileName);
+        string processId = process.Id.ToString(CultureInfo.InvariantCulture);
+        Dictionary<string, string> replacements = ArtifactNamingHelper.GetStandardReplacements(process.Name, processId, _clock.UtcNow);
+
+        string pattern = _dumpFileNamePattern ?? $"{process.Name}_%p_hang.dmp";
+
+        // First resolve {placeholder} templates, then handle legacy %p pattern for backward compatibility.
+        string finalDumpFileName = ArtifactNamingHelper.ResolveTemplate(pattern, replacements)
+            .Replace("%p", processId);
+        string resultsDirectory = Path.GetFullPath(_configuration.GetTestResultDirectory());
+        finalDumpFileName = Path.GetFullPath(Path.Combine(resultsDirectory, finalDumpFileName));
+
+        // Reject resolved paths that escape the results directory (e.g. rooted paths or ".." segments).
+        // Append a trailing separator to prevent sibling-directory bypass (e.g. "/tmp/results" vs "/tmp/results-evil").
+        // Use case-insensitive comparison on Windows where paths are case-insensitive.
+        StringComparison pathComparison = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? StringComparison.OrdinalIgnoreCase
+            : StringComparison.Ordinal;
+        string separatorStr = Path.DirectorySeparatorChar.ToString();
+        string resultsDirectoryGuard = resultsDirectory.EndsWith(separatorStr, StringComparison.Ordinal)
+            ? resultsDirectory
+            : resultsDirectory + separatorStr;
+        if (!finalDumpFileName.StartsWith(resultsDirectoryGuard, pathComparison))
+        {
+            throw new InvalidOperationException($"The resolved dump file path '{finalDumpFileName}' is outside the results directory '{resultsDirectory}'. Ensure --hangdump-filename is a relative path without '..' segments.");
+        }
+
+        // Ensure the destination directory exists (templates may include directory separators, e.g. {asm}/{pname}).
+        Directory.CreateDirectory(Path.GetDirectoryName(finalDumpFileName)!);
 
         ApplicationStateGuard.Ensure(_namedPipeClient is not null);
         GetInProgressTestsResponse tests = await _namedPipeClient.RequestReplyAsync<GetInProgressTestsRequest, GetInProgressTestsResponse>(new GetInProgressTestsRequest(), cancellationToken).ConfigureAwait(false);
         if (tests.Tests.Length > 0)
         {
-            string hangTestsFileName = Path.Combine(_configuration.GetTestResultDirectory(), Path.ChangeExtension(Path.GetFileName(finalDumpFileName), ".log"));
+            string hangTestsFileName = Path.ChangeExtension(finalDumpFileName, ".log");
             using (FileStream fs = File.OpenWrite(hangTestsFileName))
             using (StreamWriter sw = new(fs))
             {

src/Platform/Microsoft.Testing.Extensions.HangDump/Microsoft.Testing.Extensions.HangDump.csproj

@@ -40,6 +40,8 @@ This package extends Microsoft Testing Platform to provide an implementation of
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Helpers\ExitCodes.cs" Link="Helpers\ExitCodes.cs" />
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Helpers\TimeoutHelper.cs" Link="Helpers\TimeoutHelper.cs" />
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Helpers\TimeSpanParser.cs" Link="Helpers\TimeSpanParser.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Services\ArtifactNamingHelper.cs" Link="Services\ArtifactNamingHelper.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\OutputDevice\TargetFrameworkParser.cs" Link="Helpers\TargetFrameworkParser.cs" />
   </ItemGroup>
 
   <!-- NuGet package layout -->

src/Platform/Microsoft.Testing.Platform/Services/ArtifactNamingHelper.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.CodeAnalysis;
+using Microsoft.Testing.Platform.OutputDevice;
+
+namespace Microsoft.Testing.Platform.Services;
+
+[Embedded]
+internal static partial class ArtifactNamingHelper
+{
+#if NET
+    private static readonly Regex TemplateFieldRegex = GetTemplateFieldRegex();
+
+    [GeneratedRegex(@"\{([^}]+)\}")]
+    private static partial Regex GetTemplateFieldRegex();
+#else
+    private static readonly Regex TemplateFieldRegex = new(@"\{([^}]+)\}", RegexOptions.Compiled);
+#endif
+
+    /// <summary>
+    /// Builds the standard set of placeholder replacements for artifact naming.
+    /// Consumers pass process-specific values; the helper resolves the rest (asm, tfm).
+    /// </summary>
+    /// <param name="processName">The name of the process (resolves <c>{pname}</c>).</param>
+    /// <param name="processId">The process ID (resolves <c>{pid}</c>).</param>
+    /// <param name="timestamp">The timestamp to use (resolves <c>{time}</c>).</param>
+    public static Dictionary<string, string> GetStandardReplacements(string processName, string processId, DateTimeOffset timestamp)
+    {
+        var replacements = new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["pname"] = processName,
+            ["pid"] = processId,
+            ["time"] = timestamp.ToString("yyyy-MM-dd_HH-mm-ss.fffffff", CultureInfo.InvariantCulture),
+        };
+
+        string? asmName = Assembly.GetEntryAssembly()?.GetName().Name;
+        replacements["asm"] = asmName ?? "unknown";
+
+        string? tfm = TargetFrameworkParser.GetShortTargetFramework(Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkDisplayName)
+            ?? TargetFrameworkParser.GetShortTargetFramework(RuntimeInformation.FrameworkDescription);
+        replacements["tfm"] = tfm ?? "unknown";
+
+        return replacements;
+    }
+
+    /// <summary>
+    /// Resolves a template pattern by replacing {placeholder} tokens with values from the provided dictionary.
+    /// Unknown placeholders are preserved as-is. Placeholder matching is always case-sensitive (ordinal).
+    /// </summary>
+    public static string ResolveTemplate(string template, IDictionary<string, string>? replacements = null)
+    {
+        if (RoslynString.IsNullOrWhiteSpace(template))
+        {
+            throw new ArgumentException("Template cannot be null, empty, or whitespace.", nameof(template));
+        }
+
+        if (replacements is null || replacements.Count == 0)
+        {
+            return template;
+        }
+
+        // Ensure ordinal (case-sensitive) comparison regardless of the caller-provided dictionary comparer.
+        Dictionary<string, string> ordinalReplacements = replacements is Dictionary<string, string> dict && dict.Comparer == StringComparer.Ordinal
+            ? dict
+            : new Dictionary<string, string>(replacements, StringComparer.Ordinal);
+
+        return TemplateFieldRegex.Replace(template, match =>
+        {
+            string fieldName = match.Groups[1].Value;
+            return ordinalReplacements.TryGetValue(fieldName, out string? value) ? value : match.Value;
+        });
+    }
+}

test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HangDumpTests.cs

@@ -16,8 +16,8 @@ public async Task HangDump_DefaultSetting_CreateDump(string tfm)
             $"--hangdump --hangdump-timeout 8s --results-directory {resultDirectory}",
             new Dictionary<string, string?>
             {
-                        { "SLEEPTIMEMS1", "4000" },
-                        { "SLEEPTIMEMS2", "600000" },
+                { "SLEEPTIMEMS1", "4000" },
+                { "SLEEPTIMEMS2", "600000" },
             },
             cancellationToken: TestContext.CancellationToken);
         testHostResult.AssertExitCodeIs(ExitCode.TestHostProcessExitedNonGracefully);
@@ -104,6 +104,88 @@ public async Task HangDump_PathWithSpaces_CreateDump()
         Assert.IsNotNull(dumpFile, $"Dump file not found '{TargetFrameworks.NetCurrent}'\n{testHostResult}'");
     }
 
+    [DynamicData(nameof(TargetFrameworks.AllForDynamicData), typeof(TargetFrameworks))]
+    [TestMethod]
+    public async Task HangDump_TemplateFileName_CreateDump(string tfm)
+    {
+        string resultDirectory = Path.Combine(AssetFixture.TargetAssetPath, Guid.NewGuid().ToString("N"), tfm);
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, "HangDump", tfm);
+        TestHostResult testHostResult = await testHost.ExecuteAsync(
+            $"--hangdump --hangdump-timeout 8s --hangdump-filename {{pname}}_{{pid}}_{{tfm}}_{{time}}_hang.dmp --results-directory {resultDirectory}",
+            new Dictionary<string, string?>
+            {
+                ["SLEEPTIMEMS1"] = "4000",
+                ["SLEEPTIMEMS2"] = "20000",
+            },
+            cancellationToken: TestContext.CancellationToken);
+        testHostResult.AssertExitCodeIs(ExitCode.TestHostProcessExitedNonGracefully);
+
+        // Verify the dump file uses the template format
+        string[] dumpFiles = Directory.GetFiles(resultDirectory, "*_hang.dmp", SearchOption.AllDirectories);
+        string dumpFile = Assert.ContainsSingle(
+            dumpFiles,
+            $"Expected single dump file in '{resultDirectory}'\n{testHostResult}'");
+        string fileName = Path.GetFileNameWithoutExtension(dumpFile);
+
+        // File should match pattern: {pname}_{pid}_{tfm}_{time}_hang
+        // where {tfm} is e.g. net10.0, net8.0, net462
+        // and {time} is yyyy-MM-dd_HH-mm-ss.fffffff
+        Assert.MatchesRegex(@"^.+_\d+_net[\w.]+_\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\.\d{7}_hang$", fileName,
+            $"File name should match '{{pname}}_{{pid}}_{{tfm}}_{{time}}_hang' pattern. Actual: {fileName}");
+
+        // Verify the TFM segment matches the expected target framework
+        Assert.Contains($"_{tfm}_", fileName, $"File name should contain the TFM '{tfm}'. Actual: {fileName}");
+    }
+
+    [DynamicData(nameof(TargetFrameworks.AllForDynamicData), typeof(TargetFrameworks))]
+    [TestMethod]
+    public async Task HangDump_TemplateFileNameWithSubdirectory_CreateDump(string tfm)
+    {
+        string resultDirectory = Path.Combine(AssetFixture.TargetAssetPath, Guid.NewGuid().ToString("N"), tfm);
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, "HangDump", tfm);
+        TestHostResult testHostResult = await testHost.ExecuteAsync(
+            $"--hangdump --hangdump-timeout 8s --hangdump-filename {{asm}}/{{pname}}_{{pid}}_hang.dmp --results-directory {resultDirectory}",
+            new Dictionary<string, string?>
+            {
+                ["SLEEPTIMEMS1"] = "4000",
+                ["SLEEPTIMEMS2"] = "20000",
+            },
+            cancellationToken: TestContext.CancellationToken);
+        testHostResult.AssertExitCodeIs(ExitCode.TestHostProcessExitedNonGracefully);
+
+        // Verify the dump file was created inside a subdirectory named after the assembly
+        string[] dumpFiles = Directory.GetFiles(resultDirectory, "*_hang.dmp", SearchOption.AllDirectories);
+        string dumpFile = Assert.ContainsSingle(
+            dumpFiles,
+            $"Expected single dump file in '{resultDirectory}'\n{testHostResult}'");
+
+        // The dump file should be in a subdirectory named after the assembly
+        string? parentDir = Path.GetDirectoryName(dumpFile);
+        Assert.IsNotNull(parentDir);
+        Assert.AreNotEqual(resultDirectory, parentDir, "Dump file should be in a subdirectory created from the {asm} placeholder");
+        Assert.AreEqual("HangDump", Path.GetFileName(parentDir),
+            $"Subdirectory should be named after the assembly ('HangDump'). Actual: {Path.GetFileName(parentDir)}");
+    }
+
+    [TestMethod]
+    public async Task HangDump_TemplateWithPathTraversal_RejectsAndFails()
+    {
+        string resultDirectory = Path.Combine(AssetFixture.TargetAssetPath, Guid.NewGuid().ToString("N"), TargetFrameworks.NetCurrent);
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, "HangDump", TargetFrameworks.NetCurrent);
+        TestHostResult testHostResult = await testHost.ExecuteAsync(
+            $"--hangdump --hangdump-timeout 8s --hangdump-filename ../../outside/{{pname}}_hang.dmp --results-directory {resultDirectory}",
+            new Dictionary<string, string?>
+            {
+                ["SLEEPTIMEMS1"] = "4000",
+                ["SLEEPTIMEMS2"] = "20000",
+            },
+            cancellationToken: TestContext.CancellationToken);
+
+        // The path-traversal guard should cause a non-graceful exit and no dump file should be created outside the results directory.
+        testHostResult.AssertExitCodeIs(ExitCode.TestHostProcessExitedNonGracefully);
+        Assert.Contains("outside the results directory", testHostResult.StandardOutput);
+    }
+
     [DataRow("Mini")]
     [DataRow("Heap")]
     [DataRow("Triage")]

test/UnitTests/Microsoft.Testing.Platform.UnitTests/Microsoft.Testing.Platform.UnitTests.csproj

@@ -32,6 +32,7 @@
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Helpers\TimeoutHelper.cs" Link="Helpers\TimeoutHelper.cs" />
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Helpers\TimeSpanParser.cs" Link="Helpers\TimeSpanParser.cs" />
     <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\OutputDevice\TargetFrameworkParser.cs" Link="Helpers\TargetFrameworkParser.cs" />
+    <Compile Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Services\ArtifactNamingHelper.cs" Link="Services\ArtifactNamingHelper.cs" />
   </ItemGroup>
 
   <ItemGroup>