trace2: update span handling

Previously, we only set up custom performance format span handling for
time-related information (see [1]). However, with the upcoming
introduction of regions, we will need custom spans for the category and
repo strings. This change refactors and adds to the current logic to
correctly handle all 3 span types (i.e. time, repo, and category).

[1] 59a2692

Author: ldennington

src/shared/Core.Tests/Trace2MessageTests.cs

@@ -6,12 +6,33 @@ namespace Core.Tests;
 public class Trace2MessageTests
 {
     [Theory]
-    [InlineData(0.013772,    "  0.013772 ")]
-    [InlineData(26.316083,   " 26.316083 ")]
-    [InlineData(100.316083,  "100.316083 ")]
+    [InlineData(0.013772,     "  0.013772 ")]
+    [InlineData(26.316083,    " 26.316083 ")]
+    [InlineData(100.316083,   "100.316083 ")]
+    [InlineData(1000.316083,  "1000.316083")]
     public void BuildTimeSpan_Match_Returns_Expected_String(double input, string expected)
     {
         var actual = Trace2Message.BuildTimeSpan(input);
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void BuildRepoSpan_Match_Returns_Expected_String()
+    {
+        var input = 1;
+        var expected = " r1  ";
+        var actual = Trace2Message.BuildRepoSpan(input);
+        Assert.Equal(expected, actual);
+    }
+
+    [Theory]
+    [InlineData("foo",               " foo         ")]
+    [InlineData("foobar",            " foobar      ")]
+    [InlineData("foo_bar_baz",       " foo_bar_baz ")]
+    [InlineData("foobarbazfoo",      " foobarbazfo ")]
+    public void BuildCategorySpan_Match_Returns_Expected_String(string input, string expected)
+    {
+        var actual = Trace2Message.BuildCategorySpan(input);
+        Assert.Equal(expected, actual);
+    }
 }

src/shared/Core/Trace2Message.cs

@@ -82,6 +82,18 @@ protected string BuildPerformanceString()
 
     protected abstract string GetEventMessage(Trace2FormatTarget formatTarget);
 
+    private string GetSource()
+    {
+        // Source column format is file:line
+        string source = $"{File}:{Line}";
+        if (source.Length > SourceColumnMaxWidth)
+        {
+            return TraceUtils.FormatSource(source, SourceColumnMaxWidth);
+        }
+
+        return source;
+    }
+
     internal static string BuildTimeSpan(double time)
     {
         var timeString = time.ToString("F6");
@@ -91,46 +103,72 @@ internal static string BuildTimeSpan(double time)
             BeginPadding = 2,
             EndPadding = 1
         };
-        AdjustPadding(component, timeString);
 
-        var beginPadding = new string(' ', component.BeginPadding);
-        var endPadding = new string(' ', component.EndPadding);
+        return BuildSpan(component, timeString);
+    }
 
-        return $"{beginPadding}{timeString}{endPadding}";
+    internal static string BuildCategorySpan(string category)
+    {
+        var component = new PerformanceFormatSpan()
+        {
+            Size = 13,
+            BeginPadding = 1,
+            EndPadding = 1
+        };
+
+        return BuildSpan(component, category);
     }
 
-    private string GetSource()
+    internal static string BuildRepoSpan(int repo)
     {
-        // Source column format is file:line
-        string source = $"{File}:{Line}";
-        if (source.Length > SourceColumnMaxWidth)
+        var component = new PerformanceFormatSpan()
         {
-            return TraceUtils.FormatSource(source, SourceColumnMaxWidth);
-        }
+            Size = 5,
+            BeginPadding = 1,
+            EndPadding = 2
+        };
 
-        return source;
+        return BuildSpan(component, $"r{repo}");
     }
 
-    private static void AdjustPadding(PerformanceFormatSpan span, string data)
+    private static string BuildSpan(PerformanceFormatSpan component, string data)
     {
-        var paddingTotal = span.BeginPadding + span.EndPadding;
-        // Size difference between the expected size and the actual size of the data
-        var sizeDifference = span.Size - paddingTotal - data.Length;
+        var paddingTotal = component.BeginPadding + component.EndPadding;
+        var dataLimit = component.Size - paddingTotal;
+        var sizeDifference = dataLimit - data.Length;
 
-        if (sizeDifference < 0)
+        if (sizeDifference <= 0)
         {
-            // Remove all padding for values that take up the entire span
-            if (Math.Abs(sizeDifference) == paddingTotal)
+            if (double.TryParse(data, out _))
             {
-                span.BeginPadding = 0;
-                span.EndPadding = 0;
+                // Remove all padding for values that take up the entire span
+                if (Math.Abs(sizeDifference) == paddingTotal)
+                {
+                    component.BeginPadding = 0;
+                    component.EndPadding = 0;
+                }
+                else
+                {
+                    // Decrease BeginPadding for large time values that don't occupy entire span
+                    component.BeginPadding += sizeDifference;
+                }
             }
             else
             {
-                // Decrease BeginPadding for large time values that don't occupy entire span
-                span.BeginPadding += sizeDifference;
+                // Truncate value
+                data = data.Substring(0, dataLimit);
             }
         }
+
+        if (data.Length < dataLimit)
+        {
+            component.EndPadding += Math.Abs(sizeDifference);
+        }
+
+        var beginPadding = new string(' ', component.BeginPadding);
+        var endPadding = new string(' ', component.EndPadding);
+
+        return $"{beginPadding}{data}{endPadding}";
     }
 }