trace2: add sid

A key component of Git's TRACE2 tracing system is the session id (sid).
This identifies the process instance to allow all events emitted by it to
be identified.

We check to see if a parent sid (i.e. from a Git process) exists. If so,
we separate this sid from the GCM sid (a GUID) using a "/". If there is no
parent sid, we simply generate a GUID for the GCM sid and use that.

The above also requires addition of a new SetEnvironmentVariable() method
in EnvironmentBase.cs to set the GCM-specific SID variable.

Author: Lessley Dennington

src/shared/Core.Tests/EnvironmentTests.cs

@@ -150,5 +150,37 @@ public void MacOSEnvironment_TryLocateExecutable_Paths_Are_Ignored()
             Assert.True(actualResult);
             Assert.Equal(expectedPath, actualPath);
         }
+        
+        [PlatformFact(Platforms.Posix)]
+        public void PosixEnvironment_SetEnvironmentVariable_Sets_Expected_Value()
+        {
+            var variable = "FOO_BAR";
+            var value = "baz";
+                
+            var fs = new TestFileSystem();
+            var envars = new Dictionary<string, string>();
+            var env = new PosixEnvironment(fs, envars);
+
+            env.SetEnvironmentVariable(variable, value);
+
+            Assert.Contains(env.Variables, item 
+                => item.Key.Equals(variable) && item.Value.Equals(value));
+        }
+        
+        [PlatformFact(Platforms.Windows)]
+        public void WindowsEnvironment_SetEnvironmentVariable_Sets_Expected_Value()
+        {
+            var variable = "FOO_BAR";
+            var value = "baz";
+                
+            var fs = new TestFileSystem();
+            var envars = new Dictionary<string, string>();
+            var env = new WindowsEnvironment(fs, envars);
+
+            env.SetEnvironmentVariable(variable, value);
+
+            Assert.Contains(env.Variables, item 
+                => item.Key.Equals(variable) && item.Value.Equals(value));
+        }
     }
 }

src/shared/Core.Tests/Trace2Tests.cs

@@ -0,0 +1,24 @@
+using System.Text.RegularExpressions;
+using GitCredentialManager.Tests.Objects;
+using Xunit;
+
+namespace GitCredentialManager.Tests;
+
+public class Trace2Tests
+{
+    [Theory]
+    [InlineData("20190408T191610.507018Z-H9b68c35f-P000059a8")]
+    [InlineData("")]
+    public void SetSid_Envar_Returns_Expected_Value(string parentSid)
+    {
+        Regex rx = new Regex(@$"{parentSid}\/[\d\w-]*");
+
+        var environment = new TestEnvironment();
+        environment.Variables.Add("GIT_TRACE2_PARENT_SID", parentSid);
+
+        var trace2 = new Trace2(environment);
+        var sid = trace2.SetSid();
+
+        Assert.Matches(rx, sid);
+    }
+}

src/shared/Core/EnvironmentBase.cs

@@ -56,6 +56,15 @@ public interface IEnvironment
         /// <param name="workingDirectory">Working directory for the new process.</param>
         /// <returns><see cref="Process"/> object ready to start.</returns>
         Process CreateProcess(string path, string args, bool useShellExecute, string workingDirectory);
+
+        /// <summary>
+        /// Set an environment variable at the specified target level.
+        /// </summary>
+        /// <param name="variable">Name of the environment variable to set.</param>
+        /// <param name="value">Value of the environment variable to set.</param>
+        /// <param name="target">Target level of environment variable to set (Machine, Process, or User).</param>
+        void SetEnvironmentVariable(string variable, string value,
+            EnvironmentVariableTarget target = EnvironmentVariableTarget.Process);
     }
 
     public abstract class EnvironmentBase : IEnvironment
@@ -141,6 +150,16 @@ internal virtual bool TryLocateExecutable(string program, ICollection<string> pa
             path = null;
             return false;
         }
+
+        public void SetEnvironmentVariable(string variable, string value,
+            EnvironmentVariableTarget target = EnvironmentVariableTarget.Process)
+        {
+            if (Variables.Keys.Contains(variable)) return;
+            Environment.SetEnvironmentVariable(variable, value, target);
+            Variables = GetCurrentVariables();
+        }
+
+        protected abstract IReadOnlyDictionary<string, string> GetCurrentVariables();
     }
 
     public static class EnvironmentExtensions

src/shared/Core/Interop/Posix/PosixEnvironment.cs

@@ -1,18 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace GitCredentialManager.Interop.Posix
 {
     public class PosixEnvironment : EnvironmentBase
     {
         public PosixEnvironment(IFileSystem fileSystem)
-            : this(fileSystem, GetCurrentVariables()) { }
+            : this(fileSystem, null) { }
 
         internal PosixEnvironment(IFileSystem fileSystem, IReadOnlyDictionary<string, string> variables)
             : base(fileSystem)
         {
-            EnsureArgument.NotNull(variables, nameof(variables));
-            Variables = variables;
+            Variables = variables ?? GetCurrentVariables();
         }
 
         #region EnvironmentBase
@@ -34,7 +34,7 @@ protected override string[] SplitPathVariable(string value)
 
         #endregion
 
-        private static IReadOnlyDictionary<string, string> GetCurrentVariables()
+        protected override IReadOnlyDictionary<string, string> GetCurrentVariables()
         {
             var dict = new Dictionary<string, string>();
             var variables = Environment.GetEnvironmentVariables();

src/shared/Core/Interop/Windows/WindowsEnvironment.cs

@@ -2,20 +2,20 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Text;
 
 namespace GitCredentialManager.Interop.Windows
 {
     public class WindowsEnvironment : EnvironmentBase
     {
         public WindowsEnvironment(IFileSystem fileSystem)
-            : this(fileSystem, GetCurrentVariables()) { }
+            : this(fileSystem, null) { }
 
         internal WindowsEnvironment(IFileSystem fileSystem, IReadOnlyDictionary<string, string> variables)
             : base(fileSystem)
         {
-            EnsureArgument.NotNull(variables, nameof(variables));
-            Variables = variables;
+            Variables = variables ?? GetCurrentVariables();
         }
 
         #region EnvironmentBase
@@ -84,7 +84,7 @@ public override Process CreateProcess(string path, string args, bool useShellExe
 
         #endregion
 
-        private static IReadOnlyDictionary<string, string> GetCurrentVariables()
+        protected override IReadOnlyDictionary<string, string> GetCurrentVariables()
         {
             // On Windows it is technically possible to get env vars which differ only by case
             // even though the general assumption is that they are case insensitive on Windows.

src/shared/Core/Trace2.cs

@@ -25,6 +25,17 @@ public class Trace2 : DisposableObject, ITrace2
     private readonly object _writersLock = new object();
     private List<ITrace2Writer> _writers = new List<ITrace2Writer>();
 
+    private const string GitSidVariable = "GIT_TRACE2_PARENT_SID";
+
+    private IEnvironment _environment;
+    private string _sid;
+
+    public Trace2(IEnvironment environment)
+    {
+        _environment = environment;
+        _sid = SetSid();
+    }
+
     protected override void ReleaseManagedResources()
     {
         lock (_writersLock)
@@ -62,6 +73,22 @@ private void AddWriter(ITrace2Writer writer)
         }
     }
 
+    internal string SetSid()
+    {
+        var sids = new List<string>();
+        if (_environment.Variables.TryGetValue(GitSidVariable, out string parentSid))
+        {
+            sids.Add(parentSid);
+        }
+
+        // Add GCM "child" sid
+        sids.Add(Guid.NewGuid().ToString("D"));
+        var combinedSid = string.Join("/", sids);
+
+        _environment.SetEnvironmentVariable(GitSidVariable, combinedSid);
+        return combinedSid;
+    }
+
     private void WriteMessage(Trace2Message message)
     {
         ThrowIfDisposed();

src/shared/TestInfrastructure/Objects/TestEnvironment.cs

@@ -116,6 +116,14 @@ public Process CreateProcess(string path, string args, bool useShellExecute, str
 
             return new Process { StartInfo = psi };
         }
+        
+        public void SetEnvironmentVariable(string variable, string value,
+            EnvironmentVariableTarget target = EnvironmentVariableTarget.Process)
+        {
+            if (Variables.Keys.Contains(variable)) return;
+            Environment.SetEnvironmentVariable(variable, value, target);
+            Variables.Add(variable, value);
+        }
 
         #endregion
     }