From 6be933f64977fc6e264526f378b48ecac90290cd Mon Sep 17 00:00:00 2001
From: Justin Anderson <jander@microsoft.com>
Date: Tue, 15 Jun 2021 09:27:46 -0700
Subject: [PATCH 1/5] Copy endpoint info, runtime info, commmand parsing, and
 tests from dotnet/diagnostics.

---
 eng/Versions.props                            |   1 +
 .../CommandLineHelper.cs                      |  69 ++++
 .../EndpointInfo/ClientEndpointInfoSource.cs  |  54 ++++
 .../EndpointInfo/EndpointInfo.cs              |  99 ++++++
 .../EndpointInfo/IEndpointInfoSource.cs       |  36 +++
 .../EndpointInfo/ServerEndpointInfoSource.cs  | 272 ++++++++++++++++
 .../SchemaGenerationTests.cs                  |   1 +
 .../OpenApiGeneratorTests.cs                  |   1 +
 .../CommonTestTimeouts.cs                     |  26 ++
 .../DiagnosticPortHelper.cs                   |   2 +-
 ...t.Diagnostics.Monitoring.TestCommon.csproj |  10 +
 .../Runners/AppRunner.cs                      |  24 +-
 .../Runners/AppRunnerExtensions.cs            |  28 +-
 .../Runners/ConsoleLogEvent.cs                |   2 +-
 .../{ => Runners}/DotNetRunner.cs             |   3 +-
 .../{ => Runners}/LoggingRunnerAdapter.cs     |   3 +-
 .../DumpTests.cs                              |   3 +-
 .../ProcessTests.cs                           |   5 +-
 .../Runners/MonitorRunnerExtensions.cs        |   2 +-
 .../Runners/ScenarioRunner.cs                 |   3 +-
 .../TestTimeouts.cs                           |  15 -
 .../CommandLineHelperTests.cs                 |  43 +++
 .../EndpointInfoSourceTests.cs                | 299 ++++++++++++++++++
 ...ft.Diagnostics.Monitoring.UnitTests.csproj |   6 +-
 .../DiagnosticPortConnectionMode.cs           |  19 ++
 .../dotnet-monitor/DiagnosticPortOptions.cs   |   9 -
 .../DiagnosticPortOptionsDefaults.cs          |   4 -
 .../DiagnosticsMonitorCommandHandler.cs       |   5 +-
 .../Egress/AzureBlobEgressFactory.cs          |   1 -
 .../Egress/ConfiguredEgressProvider.cs        |   1 -
 .../dotnet-monitor/Egress/EgressService.cs    |   1 -
 .../Egress/FileSystemEgressFactory.cs         |   1 -
 .../FilteredEndpointInfoSource.cs             |   2 +-
 ...FilteredEndpointInfoSourceHostedService.cs |   2 +-
 src/Tools/dotnet-monitor/Program.cs           |   1 -
 src/Tools/dotnet-monitor/RuntimeInfo.cs       |  46 +++
 36 files changed, 1025 insertions(+), 74 deletions(-)
 create mode 100644 src/Microsoft.Diagnostics.Monitoring.WebApi/CommandLineHelper.cs
 create mode 100644 src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ClientEndpointInfoSource.cs
 create mode 100644 src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/EndpointInfo.cs
 create mode 100644 src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/IEndpointInfoSource.cs
 create mode 100644 src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ServerEndpointInfoSource.cs
 create mode 100644 src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/CommonTestTimeouts.cs
 rename src/Tests/{Microsoft.Diagnostics.Monitoring.Tool.UnitTests => Microsoft.Diagnostics.Monitoring.TestCommon}/DiagnosticPortHelper.cs (96%)
 rename src/Tests/{Microsoft.Diagnostics.Monitoring.Tool.UnitTests => Microsoft.Diagnostics.Monitoring.TestCommon}/Runners/AppRunner.cs (90%)
 rename src/Tests/{Microsoft.Diagnostics.Monitoring.Tool.UnitTests => Microsoft.Diagnostics.Monitoring.TestCommon}/Runners/AppRunnerExtensions.cs (79%)
 rename src/Tests/{Microsoft.Diagnostics.Monitoring.Tool.UnitTests => Microsoft.Diagnostics.Monitoring.TestCommon}/Runners/ConsoleLogEvent.cs (93%)
 rename src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/{ => Runners}/DotNetRunner.cs (98%)
 rename src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/{ => Runners}/LoggingRunnerAdapter.cs (98%)
 create mode 100644 src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/CommandLineHelperTests.cs
 create mode 100644 src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
 create mode 100644 src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
 create mode 100644 src/Tools/dotnet-monitor/RuntimeInfo.cs

diff --git a/eng/Versions.props b/eng/Versions.props
index 297f06ae4b9..5ddd7bc9614 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -64,6 +64,7 @@
     <!-- Third-party references -->
     <NJsonSchemaVersion>10.3.11</NJsonSchemaVersion>
     <SwashbuckleAspNetCoreSwaggerGenVersion>5.6.3</SwashbuckleAspNetCoreSwaggerGenVersion>
+    <XunitAssertVersion>2.4.1</XunitAssertVersion>
   </PropertyGroup>
   <PropertyGroup Label="Dev Workflow">
     <!-- These versions are not used directly. For Dev workflows, nuget requires these to properly follow
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/CommandLineHelper.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/CommandLineHelper.cs
new file mode 100644
index 00000000000..5b71196f390
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/CommandLineHelper.cs
@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Text;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    internal class CommandLineHelper
+    {
+        public static string ExtractExecutablePath(string commandLine, bool isWindows)
+        {
+            if (string.IsNullOrEmpty(commandLine))
+            {
+                return commandLine;
+            }
+
+            int commandLineLength = commandLine.Length;
+            bool isQuoted = false;
+            bool isEscaped = false;
+            int i = 0;
+            char c = commandLine[0];
+
+            // Search for the first whitespace character that is not quoted.
+            // Store character literals as it iterates the command line. Escaped
+            // characters within double quotes are unescaped for non-Windows systems.
+            // Algorithm based on INIT_FormatCommandLine behavior from
+            // https://github.com/dotnet/runtime/blob/main/src/coreclr/pal/src/init/pal.cpp
+            StringBuilder builder = new StringBuilder(commandLineLength);
+            do
+            {
+                if (isEscaped)
+                {
+                    builder.Append(c);
+                    isEscaped = false;
+                }
+                else if (c == '"')
+                {
+                    isQuoted = !isQuoted;
+                }
+                else if (c == '\\' && !isWindows)
+                {
+                    if (isQuoted)
+                    {
+                        isEscaped = true;
+                    }
+                    else
+                    {
+                        builder.Append(c);
+                    }
+                }
+                else
+                {
+                    builder.Append(c);
+                }
+
+                if (commandLineLength == ++i)
+                {
+                    break;
+                }
+
+                c = commandLine[i];
+            }
+            while (isQuoted || !char.IsWhiteSpace(c));
+
+            return builder.ToString();
+        }
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ClientEndpointInfoSource.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ClientEndpointInfoSource.cs
new file mode 100644
index 00000000000..686d6ec61e7
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ClientEndpointInfoSource.cs
@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.NETCore.Client;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    internal sealed class ClientEndpointInfoSource : IEndpointInfoSourceInternal
+    {
+        public async Task<IEnumerable<IEndpointInfo>> GetEndpointInfoAsync(CancellationToken token)
+        {
+            var endpointInfoTasks = new List<Task<EndpointInfo>>();
+            // Run the EndpointInfo creation parallel. The call to FromProcessId sends
+            // a GetProcessInfo command to the runtime instance to get additional information.
+            foreach (int pid in DiagnosticsClient.GetPublishedProcesses())
+            {
+                endpointInfoTasks.Add(Task.Run(() =>
+                {
+                    try
+                    {
+                        return EndpointInfo.FromProcessId(pid);
+                    }
+                    // Catch when runtime instance shuts down while attepting to use the established diagnostic port connection.
+                    catch (EndOfStreamException)
+                    {
+                        return null;
+                    }
+                    //Catch when the application is running a more privilaged socket than dotnet-monitor. For example, running a web app as administrator
+                    //while running dotnet-monitor without elevation.
+                    catch (UnauthorizedAccessException)
+                    {
+                        return null;
+                    }
+                    //Most errors from IpcTransport, such as a stale socket.
+                    catch (ServerNotAvailableException)
+                    {
+                        return null;
+                    }
+                }, token));
+            }
+
+            await Task.WhenAll(endpointInfoTasks);
+
+            return endpointInfoTasks.Where(t => t.Result != null).Select(t => t.Result);
+        }
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/EndpointInfo.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/EndpointInfo.cs
new file mode 100644
index 00000000000..c6a0dac8190
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/EndpointInfo.cs
@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.NETCore.Client;
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    [DebuggerDisplay("{DebuggerDisplay,nq}")]
+    internal class EndpointInfo : IEndpointInfo
+    {
+        public static EndpointInfo FromProcessId(int processId)
+        {
+            var client = new DiagnosticsClient(processId);
+
+            ProcessInfo processInfo = null;
+            try
+            {
+                // Primary motivation is to get the runtime instance cookie in order to
+                // keep parity with the FromIpcEndpointInfo implementation; store the
+                // remainder of the information since it already has access to it.
+                processInfo = client.GetProcessInfo();
+
+                Debug.Assert(processId == unchecked((int)processInfo.ProcessId));
+            }
+            catch (ServerErrorException)
+            {
+                // The runtime likely doesn't understand the GetProcessInfo command.
+            }
+            catch (TimeoutException)
+            {
+                // Runtime didn't respond within client timeout.
+            }
+
+            // CONSIDER: Generate a runtime instance identifier based on the pipe name
+            // for .NET Core 3.1 e.g. pid + disambiguator in GUID form.
+            return new EndpointInfo()
+            {
+                Endpoint = new PidIpcEndpoint(processId),
+                ProcessId = processId,
+                RuntimeInstanceCookie = processInfo?.RuntimeInstanceCookie ?? Guid.Empty,
+                CommandLine = processInfo?.CommandLine,
+                OperatingSystem = processInfo?.OperatingSystem,
+                ProcessArchitecture = processInfo?.ProcessArchitecture
+            };
+        }
+
+        public static EndpointInfo FromIpcEndpointInfo(IpcEndpointInfo info)
+        {
+            var client = new DiagnosticsClient(info.Endpoint);
+
+            ProcessInfo processInfo = null;
+            try
+            {
+                // Primary motivation is to keep parity with the FromProcessId implementation,
+                // which provides the additional process information because it already has
+                // access to it.
+                processInfo = client.GetProcessInfo();
+
+                Debug.Assert(info.ProcessId == unchecked((int)processInfo.ProcessId));
+                Debug.Assert(info.RuntimeInstanceCookie == processInfo.RuntimeInstanceCookie);
+            }
+            catch (ServerErrorException)
+            {
+                // The runtime likely doesn't understand the GetProcessInfo command.
+            }
+            catch (TimeoutException)
+            {
+                // Runtime didn't respond within client timeout.
+            }
+
+            return new EndpointInfo()
+            {
+                Endpoint = info.Endpoint,
+                ProcessId = info.ProcessId,
+                RuntimeInstanceCookie = info.RuntimeInstanceCookie,
+                CommandLine = processInfo?.CommandLine,
+                OperatingSystem = processInfo?.OperatingSystem,
+                ProcessArchitecture = processInfo?.ProcessArchitecture
+            };
+        }
+
+        public IpcEndpoint Endpoint { get; private set; }
+
+        public int ProcessId { get; private set; }
+
+        public Guid RuntimeInstanceCookie { get; private set; }
+
+        public string CommandLine { get; private set; }
+
+        public string OperatingSystem { get; private set; }
+
+        public string ProcessArchitecture { get; private set; }
+
+        internal string DebuggerDisplay => FormattableString.Invariant($"PID={ProcessId}, Cookie={RuntimeInstanceCookie}");
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/IEndpointInfoSource.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/IEndpointInfoSource.cs
new file mode 100644
index 00000000000..7419458808b
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/IEndpointInfoSource.cs
@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.NETCore.Client;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    internal interface IEndpointInfo
+    {
+        IpcEndpoint Endpoint { get; }
+
+        int ProcessId { get; }
+
+        Guid RuntimeInstanceCookie { get; }
+
+        string CommandLine { get; }
+
+        string OperatingSystem { get; }
+
+        string ProcessArchitecture { get; }
+    }
+
+    public interface IEndpointInfoSource
+    {
+    }
+
+    internal interface IEndpointInfoSourceInternal : IEndpointInfoSource
+    {
+        Task<IEnumerable<IEndpointInfo>> GetEndpointInfoAsync(CancellationToken token);
+    }
+}
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ServerEndpointInfoSource.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ServerEndpointInfoSource.cs
new file mode 100644
index 00000000000..67b4b1e65b3
--- /dev/null
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/EndpointInfo/ServerEndpointInfoSource.cs
@@ -0,0 +1,272 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.NETCore.Client;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Diagnostics.Monitoring.WebApi
+{
+    /// <summary>
+    /// Aggregates diagnostic endpoints that are established at a transport path via a reversed server.
+    /// </summary>
+    internal class ServerEndpointInfoSource : IEndpointInfoSourceInternal, IAsyncDisposable
+    {
+        // The amount of time to wait when checking if the a endpoint info should be
+        // pruned from the list of endpoint infos. If the runtime doesn't have a viable connection within
+        // this time, it will be pruned from the list.
+        private static readonly TimeSpan PruneWaitForConnectionTimeout = TimeSpan.FromMilliseconds(250);
+
+        private readonly CancellationTokenSource _cancellation = new CancellationTokenSource();
+        private readonly IList<EndpointInfo> _endpointInfos = new List<EndpointInfo>();
+        private readonly SemaphoreSlim _endpointInfosSemaphore = new SemaphoreSlim(1);
+        private readonly string _transportPath;
+
+        private Task _listenTask;
+        private bool _disposed = false;
+        private ReversedDiagnosticsServer _server;
+
+        /// <summary>
+        /// Constructs a <see cref="ServerEndpointInfoSource"/> that aggreates diagnostic endpoints
+        /// from a reversed diagnostics server at path specified by <paramref name="transportPath"/>.
+        /// </summary>
+        /// <param name="transportPath">
+        /// The path of the server endpoint.
+        /// On Windows, this can be a full pipe path or the name without the "\\.\pipe\" prefix.
+        /// On all other systems, this must be the full file path of the socket.
+        /// </param>
+        public ServerEndpointInfoSource(string transportPath)
+        {
+            _transportPath = transportPath;
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (!_disposed)
+            {
+                _cancellation.Cancel();
+
+                if (null != _listenTask)
+                {
+                    try
+                    {
+                        await _listenTask.ConfigureAwait(false);
+                    }
+                    catch (Exception ex)
+                    {
+                        Debug.Fail(ex.Message);
+                    }
+                }
+
+                if (null != _server)
+                {
+                    await _server.DisposeAsync().ConfigureAwait(false);
+                }
+
+                _endpointInfosSemaphore.Dispose();
+
+                _cancellation.Dispose();
+
+                _disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Starts listening to the reversed diagnostics server for new connections.
+        /// </summary>
+        public void Start()
+        {
+            Start(ReversedDiagnosticsServer.MaxAllowedConnections);
+        }
+
+        /// <summary>
+        /// Starts listening to the reversed diagnostics server for new connections.
+        /// </summary>
+        /// <param name="maxConnections">The maximum number of connections the server will support.</param>
+        public void Start(int maxConnections)
+        {
+            VerifyNotDisposed();
+
+            if (IsListening)
+            {
+                throw new InvalidOperationException(nameof(ServerEndpointInfoSource.Start) + " method can only be called once.");
+            }
+
+            _server = new ReversedDiagnosticsServer(_transportPath);
+
+            _listenTask = ListenAsync(maxConnections, _cancellation.Token);
+        }
+
+        /// <summary>
+        /// Gets the list of <see cref="IpcEndpointInfo"/> served from the reversed diagnostics server.
+        /// </summary>
+        /// <param name="token">The token to monitor for cancellation requests.</param>
+        /// <returns>A list of active <see cref="IEndpointInfo"/> instances.</returns>
+        public async Task<IEnumerable<IEndpointInfo>> GetEndpointInfoAsync(CancellationToken token)
+        {
+            VerifyNotDisposed();
+
+            VerifyIsListening();
+
+            using CancellationTokenSource linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, _cancellation.Token);
+            CancellationToken linkedToken = linkedSource.Token;
+
+            // Prune connections that no longer have an active runtime instance before
+            // returning the list of connections.
+            await _endpointInfosSemaphore.WaitAsync(linkedToken).ConfigureAwait(false);
+
+            try
+            {
+                // Check the transport for each endpoint info and remove it if the check fails.
+                IDictionary<EndpointInfo, Task<bool>> checkMap = new Dictionary<EndpointInfo, Task<bool>>();
+                foreach (EndpointInfo info in _endpointInfos)
+                {
+                    checkMap.Add(info, Task.Run(() => CheckNotViable(info, linkedToken), linkedToken));
+                }
+
+                // Wait for all checks to complete
+                await Task.WhenAll(checkMap.Values).ConfigureAwait(false);
+
+                // Remove connections for failed checks
+                foreach (KeyValuePair<EndpointInfo, Task<bool>> entry in checkMap)
+                {
+                    if (entry.Value.Result)
+                    {
+                        _endpointInfos.Remove(entry.Key);
+                        OnRemovedEndpointInfo(entry.Key);
+                        _server?.RemoveConnection(entry.Key.RuntimeInstanceCookie);
+                    }
+                }
+
+                return _endpointInfos.ToList();
+            }
+            finally
+            {
+                _endpointInfosSemaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the connection is not longer viable.
+        /// </summary>
+        private static async Task<bool> CheckNotViable(EndpointInfo info, CancellationToken token)
+        {
+            using var timeoutSource = new CancellationTokenSource();
+            using var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(token, timeoutSource.Token);
+
+            try
+            {
+                timeoutSource.CancelAfter(PruneWaitForConnectionTimeout);
+
+                await info.Endpoint.WaitForConnectionAsync(linkedSource.Token).ConfigureAwait(false);
+            }
+            catch
+            {
+                // Only report not viable if check was not cancelled.
+                if (!token.IsCancellationRequested)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Accepts endpoint infos from the reversed diagnostics server.
+        /// </summary>
+        /// <param name="maxConnections">The maximum number of connections the server will support.</param>
+        /// <param name="token">The token to monitor for cancellation requests.</param>
+        private async Task ListenAsync(int maxConnections, CancellationToken token)
+        {
+            _server.Start(maxConnections);
+            // Continuously accept endpoint infos from the reversed diagnostics server so
+            // that <see cref="ReversedDiagnosticsServer.AcceptAsync(CancellationToken)"/>
+            // is always awaited in order to to handle new runtime instance connections
+            // as well as existing runtime instance reconnections.
+            while (!token.IsCancellationRequested)
+            {
+                try
+                {
+                    IpcEndpointInfo info = await _server.AcceptAsync(token).ConfigureAwait(false);
+
+                    _ = Task.Run(() => ResumeAndQueueEndpointInfo(info, token), token);
+                }
+                catch (OperationCanceledException)
+                {
+                }
+            }
+        }
+
+        private async Task ResumeAndQueueEndpointInfo(IpcEndpointInfo info, CancellationToken token)
+        {
+            try
+            {
+                // Send ResumeRuntime message for runtime instances that connect to the server. This will allow
+                // those instances that are configured to pause on start to resume after the diagnostics
+                // connection has been made. Instances that are not configured to pause on startup will ignore
+                // the command and return success.
+                var client = new DiagnosticsClient(info.Endpoint);
+                try
+                {
+                    client.ResumeRuntime();
+                }
+                catch (ServerErrorException)
+                {
+                    // The runtime likely doesn't understand the ResumeRuntime command.
+                }
+
+                EndpointInfo endpointInfo = EndpointInfo.FromIpcEndpointInfo(info);
+
+                await _endpointInfosSemaphore.WaitAsync(token).ConfigureAwait(false);
+                try
+                {
+                    _endpointInfos.Add(endpointInfo);
+
+                    OnAddedEndpointInfo(endpointInfo);
+                }
+                finally
+                {
+                    _endpointInfosSemaphore.Release();
+                }
+            }
+            catch (Exception)
+            {
+                _server?.RemoveConnection(info.RuntimeInstanceCookie);
+
+                throw;
+            }
+        }
+
+        internal virtual void OnAddedEndpointInfo(EndpointInfo info)
+        {
+        }
+
+        internal virtual void OnRemovedEndpointInfo(EndpointInfo info)
+        {
+        }
+
+        private void VerifyNotDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(nameof(ServerEndpointInfoSource));
+            }
+        }
+
+        private void VerifyIsListening()
+        {
+            if (!IsListening)
+            {
+                throw new InvalidOperationException(nameof(ServerEndpointInfoSource.Start) + " method must be called before invoking this operation.");
+            }
+        }
+
+        private bool IsListening => null != _server && null != _listenTask;
+    }
+}
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.ConfigurationSchema.UnitTests/SchemaGenerationTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.ConfigurationSchema.UnitTests/SchemaGenerationTests.cs
index 9e4d55051cc..1c030dac511 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.ConfigurationSchema.UnitTests/SchemaGenerationTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.ConfigurationSchema.UnitTests/SchemaGenerationTests.cs
@@ -11,6 +11,7 @@
 using System.Reflection;
 using Microsoft.Diagnostics.Monitoring.TestCommon;
 using System.Threading;
+using Microsoft.Diagnostics.Monitoring.UnitTests.Runners;
 
 namespace Microsoft.Diagnostics.Monitoring.ConfigurationSchema.UnitTests
 {
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.OpenApiGen.UnitTests/OpenApiGeneratorTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.OpenApiGen.UnitTests/OpenApiGeneratorTests.cs
index 3c06695c511..55397ffce73 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.OpenApiGen.UnitTests/OpenApiGeneratorTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.OpenApiGen.UnitTests/OpenApiGeneratorTests.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.Diagnostics.Monitoring.TestCommon;
+using Microsoft.Diagnostics.Monitoring.UnitTests.Runners;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers;
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/CommonTestTimeouts.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/CommonTestTimeouts.cs
new file mode 100644
index 00000000000..4a0bfc30c85
--- /dev/null
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/CommonTestTimeouts.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace Microsoft.Diagnostics.Monitoring.UnitTests
+{
+    public static class CommonTestTimeouts
+    {
+        /// <summary>
+        /// Default timeout for sending commands from the test to a process.
+        /// </summary>
+        public static readonly TimeSpan SendCommand = TimeSpan.FromSeconds(15);
+
+        /// <summary>
+        /// Default timeout for starting an executable.
+        /// </summary>
+        public static readonly TimeSpan StartProcess = TimeSpan.FromMinutes(1);
+
+        /// <summary>
+        /// Default timeout for waiting for an executable to exit.
+        /// </summary>
+        public static readonly TimeSpan WaitForExit = TimeSpan.FromSeconds(15);
+    }
+}
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DiagnosticPortHelper.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DiagnosticPortHelper.cs
similarity index 96%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DiagnosticPortHelper.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DiagnosticPortHelper.cs
index 3946de18d80..9ae7c6bc3d6 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DiagnosticPortHelper.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DiagnosticPortHelper.cs
@@ -9,7 +9,7 @@
 
 namespace Microsoft.Diagnostics.Monitoring.UnitTests
 {
-    internal static class DiagnosticPortHelper
+    public static class DiagnosticPortHelper
     {
         /// <summary>
         /// Calculates the app's diagnostic port mode and generates a port path
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
index 638805a9b95..fb9174adf28 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
@@ -2,11 +2,21 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+    <DefineConstants>$(DefineConstants);UNITTEST</DefineConstants>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\..\Tools\dotnet-monitor\DiagnosticPortConnectionMode.cs" Link="Options\DiagnosticPortConnectionMode.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="System.Security.Principal.Windows" Version="$(SystemSecurityPrincipalWindowsVersion)" />
     <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsVersion)" />
+    <PackageReference Include="xunit.assert" Version="$(XunitAssertVersion)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Options\" />
   </ItemGroup>
 
   <Import Project="GenerateDotNetHost.targets" />
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunner.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
similarity index 90%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunner.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
index 31adf62248d..b152d6841fa 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunner.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
@@ -6,6 +6,7 @@
 using Microsoft.Diagnostics.Monitoring.UnitTests.Options;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Reflection;
 using System.Text.Json;
 using System.Threading;
@@ -18,7 +19,7 @@ namespace Microsoft.Diagnostics.Monitoring.UnitTests.Runners
     /// <summary>
     /// Runner for running the unit test application.
     /// </summary>
-    internal sealed class AppRunner : IAsyncDisposable
+    public sealed class AppRunner : IAsyncDisposable
     {
         private readonly LoggingRunnerAdapter _adapter;
 
@@ -29,22 +30,23 @@ internal sealed class AppRunner : IAsyncDisposable
 
         private readonly DotNetRunner _runner = new();
 
+        private readonly Assembly _testAssembly;
+
         private TaskCompletionSource<object> _currentCommandSource;
 
         private bool _isDiposed;
 
         /// <summary>
-        /// The path of the currently executing assembly.
+        /// The path of the current test assembly.
         /// </summary>
-        private static string CurrentExecutingAssemblyPath =>
-            Assembly.GetExecutingAssembly().Location;
+        private string CurrentTestAssembly => _testAssembly.Location;
 
         /// <summary>
         /// The path to the application.
         /// </summary>
-        private static string AppPath =>
-            CurrentExecutingAssemblyPath
-                .Replace(Assembly.GetExecutingAssembly().GetName().Name, "Microsoft.Diagnostics.Monitoring.UnitTestApp");
+        private string AppPath =>
+            CurrentTestAssembly
+                .Replace(_testAssembly.GetName().Name, "Microsoft.Diagnostics.Monitoring.UnitTestApp");
 
         /// <summary>
         /// The mode of the diagnostic port connection. Default is <see cref="DiagnosticPortConnectionMode.Listen"/>
@@ -71,8 +73,9 @@ internal sealed class AppRunner : IAsyncDisposable
         /// </summary>
         public string ScenarioName { get; set; }
 
-        public AppRunner(ITestOutputHelper outputHelper, int appId = 1)
+        public AppRunner(ITestOutputHelper outputHelper, Assembly testAssembly, int appId = 1)
         {
+            _testAssembly = testAssembly;
             _outputHelper = new PrefixedOutputHelper(outputHelper, FormattableString.Invariant($"[App{appId}] "));
 
             _adapter = new LoggingRunnerAdapter(_outputHelper, _runner);
@@ -106,6 +109,11 @@ public async Task StartAsync(CancellationToken token)
                 throw new ArgumentNullException(nameof(ScenarioName));
             }
 
+            if (!File.Exists(AppPath))
+            {
+                throw new FileNotFoundException($"Application path could not be found.", AppPath);
+            }
+
             _runner.EntrypointAssemblyPath = AppPath;
             _runner.Arguments = ScenarioName;
 
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunnerExtensions.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunnerExtensions.cs
similarity index 79%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunnerExtensions.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunnerExtensions.cs
index 3177dd71af3..41686da386e 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/AppRunnerExtensions.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunnerExtensions.cs
@@ -11,7 +11,7 @@
 
 namespace Microsoft.Diagnostics.Monitoring.UnitTests.Runners
 {
-    internal static class AppRunnerExtensions
+    public static class AppRunnerExtensions
     {
         private static readonly TimeSpan ExceptionTimeout = TimeSpan.FromSeconds(5);
 
@@ -19,17 +19,17 @@ public static async Task ExecuteAsync(this AppRunner runner, Func<Task> func)
         {
             try
             {
-                await runner.StartAsync(TestTimeouts.StartProcess);
+                await runner.StartAsync(CommonTestTimeouts.StartProcess);
 
-                await runner.SendStartScenarioAsync(TestTimeouts.SendCommand);
+                await runner.SendStartScenarioAsync(CommonTestTimeouts.SendCommand);
 
                 await func();
 
-                await runner.SendEndScenarioAsync(TestTimeouts.SendCommand);
+                await runner.SendEndScenarioAsync(CommonTestTimeouts.SendCommand);
 
                 // This gives the app time to send out any remaining stdout/stderr messages,
                 // exit properly, and delete its diagnostic pipe.
-                await runner.WaitForExitAsync(TestTimeouts.WaitForExit);
+                await runner.WaitForExitAsync(CommonTestTimeouts.WaitForExit);
             }
             catch (Exception)
             {
@@ -51,9 +51,9 @@ public static async Task ExecuteAsync(this IEnumerable<AppRunner> runners, Func<
             {
                 foreach (AppRunner runner in runners)
                 {
-                    await runner.StartAsync(TestTimeouts.StartProcess);
+                    await runner.StartAsync(CommonTestTimeouts.StartProcess);
 
-                    await runner.SendStartScenarioAsync(TestTimeouts.SendCommand);
+                    await runner.SendStartScenarioAsync(CommonTestTimeouts.SendCommand);
                 }
 
                 await func();
@@ -62,9 +62,9 @@ public static async Task ExecuteAsync(this IEnumerable<AppRunner> runners, Func<
                 // exit properly, and delete their diagnostic pipes.
                 await Task.WhenAll(runners.Select(async runner =>
                     {
-                        await runner.SendEndScenarioAsync(TestTimeouts.SendCommand);
+                        await runner.SendEndScenarioAsync(CommonTestTimeouts.SendCommand);
 
-                        await runner.WaitForExitAsync(TestTimeouts.WaitForExit);
+                        await runner.WaitForExitAsync(CommonTestTimeouts.WaitForExit);
                     }));
             }
             catch (Exception)
@@ -83,7 +83,7 @@ await Task.WhenAll(runners.Select(async runner =>
 
         public static Task SendEndScenarioAsync(this AppRunner runner)
         {
-            return runner.SendEndScenarioAsync(TestTimeouts.SendCommand);
+            return runner.SendEndScenarioAsync(CommonTestTimeouts.SendCommand);
         }
 
         public static async Task SendEndScenarioAsync(this AppRunner runner, TimeSpan timeout)
@@ -94,7 +94,7 @@ public static async Task SendEndScenarioAsync(this AppRunner runner, TimeSpan ti
 
         public static Task SendCommandAsync(this AppRunner runner, string command)
         {
-            return runner.SendCommandAsync(command, TestTimeouts.SendCommand);
+            return runner.SendCommandAsync(command, CommonTestTimeouts.SendCommand);
         }
 
         public static async Task SendCommandAsync(this AppRunner runner, string command, TimeSpan timeout)
@@ -105,7 +105,7 @@ public static async Task SendCommandAsync(this AppRunner runner, string command,
 
         public static Task SendStartScenarioAsync(this AppRunner runner)
         {
-            return runner.SendStartScenarioAsync(TestTimeouts.SendCommand);
+            return runner.SendStartScenarioAsync(CommonTestTimeouts.SendCommand);
         }
 
         public static async Task SendStartScenarioAsync(this AppRunner runner, TimeSpan timeout)
@@ -116,7 +116,7 @@ public static async Task SendStartScenarioAsync(this AppRunner runner, TimeSpan
 
         public static Task StartAsync(this AppRunner runner)
         {
-            return runner.StartAsync(TestTimeouts.StartProcess);
+            return runner.StartAsync(CommonTestTimeouts.StartProcess);
         }
 
         public static async Task StartAsync(this AppRunner runner, TimeSpan timeout)
@@ -127,7 +127,7 @@ public static async Task StartAsync(this AppRunner runner, TimeSpan timeout)
 
         public static Task<int> WaitForExitAsync(this AppRunner runner)
         {
-            return runner.WaitForExitAsync(TestTimeouts.WaitForExit);
+            return runner.WaitForExitAsync(CommonTestTimeouts.WaitForExit);
         }
 
         public static async Task<int> WaitForExitAsync(this AppRunner runner, TimeSpan timeout)
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ConsoleLogEvent.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/ConsoleLogEvent.cs
similarity index 93%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ConsoleLogEvent.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/ConsoleLogEvent.cs
index 0439fd25f89..fd4ca3200f7 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ConsoleLogEvent.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/ConsoleLogEvent.cs
@@ -9,7 +9,7 @@ namespace Microsoft.Diagnostics.Monitoring.UnitTests.Runners
 {
     // All log events have this structure (plus additional fields
     // not needed by the test runner for identifying events).
-    internal sealed  class ConsoleLogEvent
+    public sealed class ConsoleLogEvent
     {
         public string Category { get; set; }
 
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DotNetRunner.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/DotNetRunner.cs
similarity index 98%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DotNetRunner.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/DotNetRunner.cs
index 0be8d62bf28..f050ebe28ff 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/DotNetRunner.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/DotNetRunner.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information
 
+using Microsoft.Diagnostics.Monitoring.TestCommon;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -10,7 +11,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Microsoft.Diagnostics.Monitoring.TestCommon
+namespace Microsoft.Diagnostics.Monitoring.UnitTests.Runners
 {
     /// <summary>
     /// Runner for running dotnet processes.
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/LoggingRunnerAdapter.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/LoggingRunnerAdapter.cs
similarity index 98%
rename from src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/LoggingRunnerAdapter.cs
rename to src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/LoggingRunnerAdapter.cs
index 3b520bf5fa5..6e72cb6f39c 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/LoggingRunnerAdapter.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/LoggingRunnerAdapter.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.Diagnostics.Monitoring.TestCommon;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -9,7 +10,7 @@
 using System.Threading.Tasks;
 using Xunit.Abstractions;
 
-namespace Microsoft.Diagnostics.Monitoring.TestCommon
+namespace Microsoft.Diagnostics.Monitoring.UnitTests.Runners
 {
     public sealed class LoggingRunnerAdapter : IAsyncDisposable
     {
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DumpTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DumpTests.cs
index a2e4a4a7779..b32bd4ada7b 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DumpTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/DumpTests.cs
@@ -15,6 +15,7 @@
 using System;
 using System.IO;
 using System.Net.Http;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
@@ -64,7 +65,7 @@ public async Task DumpTest(DiagnosticPortConnectionMode mode, DumpType type)
             using HttpClient httpClient = await toolRunner.CreateHttpClientDefaultAddressAsync(_httpClientFactory);
             ApiClient apiClient = new(_outputHelper, httpClient);
             
-            AppRunner appRunner = new(_outputHelper);
+            AppRunner appRunner = new(_outputHelper, Assembly.GetExecutingAssembly());
             appRunner.ConnectionMode = appConnectionMode;
             appRunner.DiagnosticPortPath = diagnosticPortPath;
             appRunner.ScenarioName = TestAppScenarios.AsyncWait.Name;
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs
index d6270bd54ae..ad6031a70bc 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs
@@ -15,6 +15,7 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Reflection;
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
@@ -59,7 +60,7 @@ public async Task SingleProcessIdentificationTest(DiagnosticPortConnectionMode m
             using HttpClient httpClient = await toolRunner.CreateHttpClientDefaultAddressAsync(_httpClientFactory);
             ApiClient apiClient = new(_outputHelper, httpClient);
 
-            AppRunner appRunner = new(_outputHelper);
+            AppRunner appRunner = new(_outputHelper, Assembly.GetExecutingAssembly());
             appRunner.ConnectionMode = appConnectionMode;
             appRunner.DiagnosticPortPath = diagnosticPortPath;
             appRunner.ScenarioName = TestAppScenarios.AsyncWait.Name;
@@ -111,7 +112,7 @@ public async Task MultiProcessIdentificationTest(DiagnosticPortConnectionMode mo
 
             for (int i = 0; i < appCount; i++)
             {
-                AppRunner runner = new(_outputHelper, appId: i + 1);
+                AppRunner runner = new(_outputHelper, Assembly.GetExecutingAssembly(), appId: i + 1);
                 runner.ConnectionMode = appConnectionMode;
                 runner.DiagnosticPortPath = diagnosticPortPath;
                 runner.ScenarioName = TestAppScenarios.AsyncWait.Name;
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/MonitorRunnerExtensions.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/MonitorRunnerExtensions.cs
index 86882794f09..034bf30f33d 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/MonitorRunnerExtensions.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/MonitorRunnerExtensions.cs
@@ -78,7 +78,7 @@ public static async Task<HttpClient> CreateHttpClientMetricsAddressAsync(this Mo
 
         public static Task StartAsync(this MonitorRunner runner)
         {
-            return runner.StartAsync(TestTimeouts.StartProcess);
+            return runner.StartAsync(CommonTestTimeouts.StartProcess);
         }
 
         public static async Task StartAsync(this MonitorRunner runner, TimeSpan timeout)
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs
index 005b823ebb7..612f3fd524a 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs
@@ -2,6 +2,7 @@
 using Microsoft.Diagnostics.Monitoring.UnitTests.Options;
 using System;
 using System.Net.Http;
+using System.Reflection;
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
@@ -31,7 +32,7 @@ public static async Task SingleTarget(
             using HttpClient httpClient = await toolRunner.CreateHttpClientDefaultAddressAsync(httpClientFactory);
             ApiClient apiClient = new(outputHelper, httpClient);
 
-            AppRunner appRunner = new(outputHelper);
+            AppRunner appRunner = new(outputHelper, Assembly.GetExecutingAssembly());
             appRunner.ConnectionMode = appConnectionMode;
             appRunner.DiagnosticPortPath = diagnosticPortPath;
             appRunner.ScenarioName = scenarioName;
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TestTimeouts.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TestTimeouts.cs
index 68cb7fedd93..a1f4d28b1a1 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TestTimeouts.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/TestTimeouts.cs
@@ -13,21 +13,6 @@ internal static class TestTimeouts
         /// </summary>
         public static readonly TimeSpan HttpApi = TimeSpan.FromSeconds(15);
 
-        /// <summary>
-        /// Default timeout for sending commands from the test to a process.
-        /// </summary>
-        public static readonly TimeSpan SendCommand = TimeSpan.FromSeconds(15);
-
-        /// <summary>
-        /// Default timeout for starting an executable.
-        /// </summary>
-        public static readonly TimeSpan StartProcess = TimeSpan.FromMinutes(1);
-
-        /// <summary>
-        /// Default timeout for waiting for an executable to exit.
-        /// </summary>
-        public static readonly TimeSpan WaitForExit = TimeSpan.FromSeconds(15);
-
         /// <summary>
         /// Default logs collection duration.
         /// </summary>
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/CommandLineHelperTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/CommandLineHelperTests.cs
new file mode 100644
index 00000000000..3b81f9a326a
--- /dev/null
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/CommandLineHelperTests.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Diagnostics.Monitoring.UnitTests
+{
+    public class CommandLineHelperTests
+    {
+        private readonly ITestOutputHelper _output;
+
+        public CommandLineHelperTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
+        [Theory]
+        [InlineData(true, null, null)]
+        [InlineData(true, "", "")]
+        [InlineData(true, @"C:\NoArgs\test.exe", @"C:\NoArgs\test.exe")]
+        [InlineData(true, @"C:\WithArgs\test.exe arg1 arg2", @"C:\WithArgs\test.exe")]
+        [InlineData(true, @"""C:\With Space No Args\test.exe""", @"C:\With Space No Args\test.exe")]
+        [InlineData(true, @"""C:\With Space With Args\test.exe"" arg1 arg2", @"C:\With Space With Args\test.exe")]
+        [InlineData(true, @"C:\With'Quotes'No'Args\test.exe", @"C:\With'Quotes'No'Args\test.exe")]
+        [InlineData(true, @"C:\With'Quotes'With'Args\test.exe arg1 arg2", @"C:\With'Quotes'With'Args\test.exe")]
+        [InlineData(false, null, null)]
+        [InlineData(false, "", "")]
+        [InlineData(false, "/home/noargs/test", "/home/noargs/test")]
+        [InlineData(false, "/home/withargs/test arg1 arg2", "/home/withargs/test")]
+        [InlineData(false, @"""/home/with space no args/test""", "/home/with space no args/test")]
+        [InlineData(false, @"""/home/with space with args/test"" arg1 arg2", "/home/with space with args/test")]
+        [InlineData(false, @"""/home/escaped\\backslashes\\no\\args/test""", @"/home/escaped\backslashes\no\args/test")]
+        [InlineData(false, @"""/home/escaped\\backslashes\\with\\args/test"" arg1 arg2", @"/home/escaped\backslashes\with\args/test")]
+        [InlineData(false, @"""/home/escaped\""quotes\""no\""args/test""", @"/home/escaped""quotes""no""args/test")]
+        [InlineData(false, @"""/home/escaped\""quotes\""with\""args/test"" arg1 arg2", @"/home/escaped""quotes""with""args/test")]
+        public void CommandLineValidPathTest(bool isWindows, string commandLine, string expectedProcessPath)
+        {
+            Assert.Equal(expectedProcessPath, WebApi.CommandLineHelper.ExtractExecutablePath(commandLine, isWindows));
+        }
+    }
+}
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
new file mode 100644
index 00000000000..719563ff3f8
--- /dev/null
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
@@ -0,0 +1,299 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Diagnostics.Monitoring.TestCommon;
+using Microsoft.Diagnostics.Monitoring.UnitTests.Runners;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Diagnostics.Monitoring.UnitTests
+{
+#if NET5_0_OR_GREATER
+    public class EndpointInfoSourceTests
+    {
+        private static readonly TimeSpan DefaultNegativeVerificationTimeout = TimeSpan.FromSeconds(2);
+
+        private readonly ITestOutputHelper _outputHelper;
+
+        public EndpointInfoSourceTests(ITestOutputHelper outputHelper)
+        {
+            _outputHelper = outputHelper;
+        }
+
+        /// <summary>
+        /// Tests that other <see cref="ServerEndpointInfoSource"> methods throw if
+        /// <see cref="ServerEndpointInfoSource.Start"/> is not called.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceNoStartTest()
+        {
+            await using var source = CreateServerSource(out string transportName);
+            // Intentionally do not call Start
+
+            using CancellationTokenSource cancellation = new(DefaultNegativeVerificationTimeout);
+
+            await Assert.ThrowsAsync<InvalidOperationException>(
+                () => source.GetEndpointInfoAsync(cancellation.Token));
+        }
+
+        /// <summary>
+        /// Tests that the server endpoint info source has not connections if no processes connect to it.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceNoConnectionsTest()
+        {
+            await using var source = CreateServerSource(out _);
+            source.Start();
+
+            var endpointInfos = await GetEndpointInfoAsync(source);
+            Assert.Empty(endpointInfos);
+        }
+
+        /// <summary>
+        /// Tests that server endpoint info source should throw ObjectDisposedException
+        /// from API surface after being disposed.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceThrowsWhenDisposedTest()
+        {
+            var source = CreateServerSource(out _);
+            source.Start();
+
+            await source.DisposeAsync();
+
+            // Validate source surface throws after disposal
+            Assert.Throws<ObjectDisposedException>(
+                () => source.Start());
+
+            Assert.Throws<ObjectDisposedException>(
+                () => source.Start(1));
+
+            using CancellationTokenSource cancellation = new(DefaultNegativeVerificationTimeout);
+            await Assert.ThrowsAsync<ObjectDisposedException>(
+                () => source.GetEndpointInfoAsync(cancellation.Token));
+        }
+
+        /// <summary>
+        /// Tests that server endpoint info source should throw an exception from
+        /// <see cref="ServerEndpointInfoSource.Start"/> and
+        /// <see cref="ServerEndpointInfoSource.Start(int)"/> after listening was already started.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceThrowsWhenMultipleStartTest()
+        {
+            await using var source = CreateServerSource(out _);
+            source.Start();
+
+            Assert.Throws<InvalidOperationException>(
+                () => source.Start());
+
+            Assert.Throws<InvalidOperationException>(
+                () => source.Start(1));
+        }
+
+        /// <summary>
+        /// Tests that the server endpoint info source can properly enumerate endpoint infos when a single
+        /// target connects to it and "disconnects" from it.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceAddRemoveSingleConnectionTest()
+        {
+            await using var source = CreateServerSource(out string transportName);
+            source.Start();
+
+            var endpointInfos = await GetEndpointInfoAsync(source);
+            Assert.Empty(endpointInfos);
+
+            AppRunner runner = CreateAppRunner(transportName);
+
+            Task newEndpointInfoTask = source.WaitForNewEndpointInfoAsync(runner, CommonTestTimeouts.StartProcess);
+
+            await runner.ExecuteAsync(async () =>
+            {
+                await newEndpointInfoTask;
+
+                endpointInfos = await GetEndpointInfoAsync(source);
+
+                var endpointInfo = Assert.Single(endpointInfos);
+                Assert.NotNull(endpointInfo.CommandLine);
+                Assert.NotNull(endpointInfo.OperatingSystem);
+                Assert.NotNull(endpointInfo.ProcessArchitecture);
+                VerifyConnection(runner, endpointInfo);
+
+                await runner.SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
+            });
+
+            await Task.Delay(TimeSpan.FromSeconds(1));
+
+            endpointInfos = await GetEndpointInfoAsync(source);
+
+            Assert.Empty(endpointInfos);
+        }
+
+        /// <summary>
+        /// Tests that the server endpoint info source can properly enumerate endpoint infos when multiple
+        /// targets connect to it and "disconnect" from it.
+        /// </summary>
+        [Fact]
+        public async Task ServerSourceAddRemoveMultipleConnectionTest()
+        {
+            await using var source = CreateServerSource(out string transportName);
+            source.Start();
+
+            var endpointInfos = await GetEndpointInfoAsync(source);
+            Assert.Empty(endpointInfos);
+
+            const int appCount = 5;
+            AppRunner[] runners = new AppRunner[appCount];
+            Task[] newEndpointInfoTasks = new Task[appCount];
+
+            // Start all app instances
+            for (int i = 0; i < appCount; i++)
+            {
+                runners[i] = CreateAppRunner(transportName, appId: i + 1);
+                newEndpointInfoTasks[i] = source.WaitForNewEndpointInfoAsync(runners[i], CommonTestTimeouts.StartProcess);
+            }
+
+            await runners.ExecuteAsync(async () =>
+            {
+                _outputHelper.WriteLine("Waiting for all new endpoint info notifications.");
+                await Task.WhenAll(newEndpointInfoTasks);
+                _outputHelper.WriteLine("Received all new endpoint info notifications.");
+
+                endpointInfos = await GetEndpointInfoAsync(source);
+
+                Assert.Equal(appCount, endpointInfos.Count());
+
+                for (int i = 0; i < appCount; i++)
+                {
+                    IEndpointInfo endpointInfo = endpointInfos.FirstOrDefault(info => info.ProcessId == runners[i].ProcessId);
+                    Assert.NotNull(endpointInfo);
+                    Assert.NotNull(endpointInfo.CommandLine);
+                    Assert.NotNull(endpointInfo.OperatingSystem);
+                    Assert.NotNull(endpointInfo.ProcessArchitecture);
+
+                    VerifyConnection(runners[i], endpointInfo);
+
+                    await runners[i].SendCommandAsync(TestAppScenarios.AsyncWait.Commands.Continue);
+                }
+            });
+
+            for (int i = 0; i < appCount; i++)
+            {
+                Assert.True(0 == runners[i].ExitCode, $"App {i} exit code is non-zero.");
+            }
+
+            await Task.Delay(TimeSpan.FromSeconds(1));
+
+            endpointInfos = await GetEndpointInfoAsync(source);
+
+            Assert.Empty(endpointInfos);
+        }
+
+        private TestServerEndpointInfoSource CreateServerSource(out string transportName)
+        {
+            DiagnosticPortHelper.Generate(Options.DiagnosticPortConnectionMode.Listen, out _, out transportName);
+            _outputHelper.WriteLine("Starting server endpoint info source at '" + transportName + "'.");
+            return new TestServerEndpointInfoSource(transportName, _outputHelper);
+        }
+
+        private AppRunner CreateAppRunner(string transportName = null, int appId = 1)
+        {
+            AppRunner appRunner = new(_outputHelper, Assembly.GetExecutingAssembly(), appId);
+            appRunner.ConnectionMode = Options.DiagnosticPortConnectionMode.Connect;
+            appRunner.DiagnosticPortPath = transportName;
+            appRunner.ScenarioName = TestAppScenarios.AsyncWait.Name;
+            return appRunner;
+        }
+
+        private async Task<IEnumerable<IEndpointInfo>> GetEndpointInfoAsync(ServerEndpointInfoSource source)
+        {
+            _outputHelper.WriteLine("Getting endpoint infos.");
+            using CancellationTokenSource cancellationSource = new(TimeSpan.FromSeconds(10));
+            return await source.GetEndpointInfoAsync(cancellationSource.Token);
+        }
+
+        /// <summary>
+        /// Verifies basic information on the connection and that it matches the target process from the runner.
+        /// </summary>
+        private static void VerifyConnection(AppRunner runner, IEndpointInfo endpointInfo)
+        {
+            Assert.NotNull(runner);
+            Assert.NotNull(endpointInfo);
+            Assert.Equal(runner.ProcessId, endpointInfo.ProcessId);
+            Assert.NotEqual(Guid.Empty, endpointInfo.RuntimeInstanceCookie);
+            Assert.NotNull(endpointInfo.Endpoint);
+        }
+
+        private sealed class TestServerEndpointInfoSource : ServerEndpointInfoSource
+        {
+            private readonly ITestOutputHelper _outputHelper;
+            private readonly List<Tuple<AppRunner, TaskCompletionSource<EndpointInfo>>> _addedEndpointInfoSources = new();
+
+            public TestServerEndpointInfoSource(string transportPath, ITestOutputHelper outputHelper)
+                : base(transportPath)
+            {
+                _outputHelper = outputHelper;
+            }
+
+            public async Task<EndpointInfo> WaitForNewEndpointInfoAsync(AppRunner runner, TimeSpan timeout)
+            {
+                TaskCompletionSource<EndpointInfo> addedEndpointInfoSource = new(TaskCreationOptions.RunContinuationsAsynchronously);
+                using CancellationTokenSource timeoutCancellation = new();
+                var token = timeoutCancellation.Token;
+                using var _ = token.Register(() => addedEndpointInfoSource.TrySetCanceled(token));
+
+                lock (_addedEndpointInfoSources)
+                {
+                    _addedEndpointInfoSources.Add(Tuple.Create(runner, addedEndpointInfoSource));
+                }
+
+                _outputHelper.WriteLine("Waiting for new endpoint info.");
+                timeoutCancellation.CancelAfter(timeout);
+                EndpointInfo endpointInfo = await addedEndpointInfoSource.Task;
+                _outputHelper.WriteLine("Notified of new endpoint info.");
+
+                return endpointInfo;
+            }
+
+            internal override void OnAddedEndpointInfo(EndpointInfo info)
+            {
+                _outputHelper.WriteLine($"Added endpoint info to collection: {info.DebuggerDisplay}");
+                
+                lock (_addedEndpointInfoSources)
+                {
+                    foreach (var source in _addedEndpointInfoSources)
+                    {
+                        try
+                        {
+                            if (info.ProcessId == source.Item1.ProcessId)
+                            {
+                                _outputHelper.WriteLine($"Notifying endpoint registration for process ID {info.ProcessId}");
+                                source.Item2.TrySetResult(info);
+                                _addedEndpointInfoSources.Remove(source);
+                                break;
+                            }
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            // Thrown in app runner hasn't started process yet.
+                        }
+                    }
+                }
+            }
+
+            internal override void OnRemovedEndpointInfo(EndpointInfo info)
+            {
+                _outputHelper.WriteLine($"Removed endpoint info from collection: {info.DebuggerDisplay}");
+            }
+        }
+    }
+#endif
+}
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/Microsoft.Diagnostics.Monitoring.UnitTests.csproj b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/Microsoft.Diagnostics.Monitoring.UnitTests.csproj
index 4f865643f4b..c41ea9108cf 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/Microsoft.Diagnostics.Monitoring.UnitTests.csproj
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/Microsoft.Diagnostics.Monitoring.UnitTests.csproj
@@ -1,14 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net6.0</TargetFrameworks>
+      <TargetFrameworks>netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
         <DefineConstants>$(DefineConstants);UNITTEST</DefineConstants>
     </PropertyGroup>
     
     <ItemGroup>
-        <ProjectReference Include="..\..\Microsoft.Diagnostics.Monitoring.WebApi\Microsoft.Diagnostics.Monitoring.WebApi.csproj">
-            
-        </ProjectReference>
+        <ProjectReference Include="..\..\Microsoft.Diagnostics.Monitoring.WebApi\Microsoft.Diagnostics.Monitoring.WebApi.csproj" />
         <ProjectReference Include="..\Microsoft.Diagnostics.Monitoring.TestCommon\Microsoft.Diagnostics.Monitoring.TestCommon.csproj" />
     </ItemGroup>
 </Project>
diff --git a/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs b/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
new file mode 100644
index 00000000000..466815c7194
--- /dev/null
+++ b/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Text.Json.Serialization;
+
+#if UNITTEST
+namespace Microsoft.Diagnostics.Monitoring.UnitTests.Options
+#else
+namespace Microsoft.Diagnostics.Tools.Monitor
+#endif
+{
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    public enum DiagnosticPortConnectionMode
+    {
+        Connect,
+        Listen
+    }
+}
diff --git a/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs b/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs
index ebfb545ab8a..33081b58f87 100644
--- a/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs
+++ b/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs
@@ -4,8 +4,6 @@
 
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
-using System.Runtime.Serialization;
-using System.Text.Json.Serialization;
 
 #if UNITTEST
 namespace Microsoft.Diagnostics.Monitoring.UnitTests.Options
@@ -25,11 +23,4 @@ public class DiagnosticPortOptions
         [Display(Description = @"In 'Listen' mode, the maximum amount of connections to accept.")]
         public int? MaxConnections { get; set; }
     }
-
-    [JsonConverter(typeof(JsonStringEnumConverter))]
-    public enum DiagnosticPortConnectionMode
-    {
-        Connect,
-        Listen
-    }
 }
diff --git a/src/Tools/dotnet-monitor/DiagnosticPortOptionsDefaults.cs b/src/Tools/dotnet-monitor/DiagnosticPortOptionsDefaults.cs
index f63ca3f78c9..65b0cb9356c 100644
--- a/src/Tools/dotnet-monitor/DiagnosticPortOptionsDefaults.cs
+++ b/src/Tools/dotnet-monitor/DiagnosticPortOptionsDefaults.cs
@@ -2,10 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
-using System.Text;
-
 #if UNITTEST
 namespace Microsoft.Diagnostics.Monitoring.UnitTests.Options
 #else
diff --git a/src/Tools/dotnet-monitor/DiagnosticsMonitorCommandHandler.cs b/src/Tools/dotnet-monitor/DiagnosticsMonitorCommandHandler.cs
index 24c6713eda1..e48e44af66c 100644
--- a/src/Tools/dotnet-monitor/DiagnosticsMonitorCommandHandler.cs
+++ b/src/Tools/dotnet-monitor/DiagnosticsMonitorCommandHandler.cs
@@ -5,7 +5,6 @@
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Http;
 using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Extensions.Configuration;
@@ -17,12 +16,10 @@
 using System.Collections.Generic;
 using System.CommandLine;
 using System.IO;
-using System.Linq;
 using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using IEndpointInfoSource = Microsoft.Diagnostics.Monitoring.WebApi.IEndpointInfoSource;
 
 namespace Microsoft.Diagnostics.Tools.Monitor
 {
diff --git a/src/Tools/dotnet-monitor/Egress/AzureBlobEgressFactory.cs b/src/Tools/dotnet-monitor/Egress/AzureBlobEgressFactory.cs
index 9aa6de25d75..c5a4d45bece 100644
--- a/src/Tools/dotnet-monitor/Egress/AzureBlobEgressFactory.cs
+++ b/src/Tools/dotnet-monitor/Egress/AzureBlobEgressFactory.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.Tools.Monitor.Egress.AzureStorage;
 using Microsoft.Extensions.Configuration;
diff --git a/src/Tools/dotnet-monitor/Egress/ConfiguredEgressProvider.cs b/src/Tools/dotnet-monitor/Egress/ConfiguredEgressProvider.cs
index dc4c363918f..bbdd5ba466e 100644
--- a/src/Tools/dotnet-monitor/Egress/ConfiguredEgressProvider.cs
+++ b/src/Tools/dotnet-monitor/Egress/ConfiguredEgressProvider.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using System;
 using System.IO;
diff --git a/src/Tools/dotnet-monitor/Egress/EgressService.cs b/src/Tools/dotnet-monitor/Egress/EgressService.cs
index 62180075bc0..b0a9179cbba 100644
--- a/src/Tools/dotnet-monitor/Egress/EgressService.cs
+++ b/src/Tools/dotnet-monitor/Egress/EgressService.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.Tools.Monitor.Egress.Configuration;
 using Microsoft.Extensions.Options;
diff --git a/src/Tools/dotnet-monitor/Egress/FileSystemEgressFactory.cs b/src/Tools/dotnet-monitor/Egress/FileSystemEgressFactory.cs
index 08742f08d50..0137f5a7d96 100644
--- a/src/Tools/dotnet-monitor/Egress/FileSystemEgressFactory.cs
+++ b/src/Tools/dotnet-monitor/Egress/FileSystemEgressFactory.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.Tools.Monitor.Egress.FileSystem;
 using Microsoft.Extensions.Configuration;
diff --git a/src/Tools/dotnet-monitor/FilteredEndpointInfoSource.cs b/src/Tools/dotnet-monitor/FilteredEndpointInfoSource.cs
index 557e1b8abee..d1e1eaf6466 100644
--- a/src/Tools/dotnet-monitor/FilteredEndpointInfoSource.cs
+++ b/src/Tools/dotnet-monitor/FilteredEndpointInfoSource.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
+using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Diagnostics.NETCore.Client;
 using Microsoft.Extensions.Options;
 using System;
diff --git a/src/Tools/dotnet-monitor/FilteredEndpointInfoSourceHostedService.cs b/src/Tools/dotnet-monitor/FilteredEndpointInfoSourceHostedService.cs
index d72de2b6fa4..b580cdb9748 100644
--- a/src/Tools/dotnet-monitor/FilteredEndpointInfoSourceHostedService.cs
+++ b/src/Tools/dotnet-monitor/FilteredEndpointInfoSourceHostedService.cs
@@ -4,7 +4,7 @@
 
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Diagnostics.Monitoring;
+using Microsoft.Diagnostics.Monitoring.WebApi;
 using Microsoft.Extensions.Hosting;
 
 namespace Microsoft.Diagnostics.Tools.Monitor
diff --git a/src/Tools/dotnet-monitor/Program.cs b/src/Tools/dotnet-monitor/Program.cs
index e7330af312c..613d92fdf02 100644
--- a/src/Tools/dotnet-monitor/Program.cs
+++ b/src/Tools/dotnet-monitor/Program.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Tools.Common;
 using System;
diff --git a/src/Tools/dotnet-monitor/RuntimeInfo.cs b/src/Tools/dotnet-monitor/RuntimeInfo.cs
new file mode 100644
index 00000000000..62738030483
--- /dev/null
+++ b/src/Tools/dotnet-monitor/RuntimeInfo.cs
@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Diagnostics.Tools.Monitor
+{
+    public static class RuntimeInfo
+    {
+        public static bool IsDiagnosticsEnabled
+        {
+            get
+            {
+                string enableDiagnostics = Environment.GetEnvironmentVariable("COMPlus_EnableDiagnostics");
+                return string.IsNullOrEmpty(enableDiagnostics) || !"0".Equals(enableDiagnostics, StringComparison.Ordinal);
+            }
+        }
+
+        public static bool IsInDockerContainer
+        {
+            get
+            {
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                {
+                    // Check if one of the control groups of this process is owned by docker
+                    if (File.ReadAllText("/proc/self/cgroup").Contains("/docker/"))
+                    {
+                        return true;
+                    }
+
+                    // Most of the control groups are owned by "kubepods" when running in kubernetes;
+                    // Check for docker environment file
+                    return File.Exists("/.dockerenv");
+                }
+
+                // TODO: Add detection for other platforms
+                return false;
+            }
+        }
+
+        public static bool IsInKubernetes => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("KUBERNETES_SERVICE_HOST"));
+    }
+}
\ No newline at end of file

From a199fe906010dcca1a7887b2b563cf7d8866ae4e Mon Sep 17 00:00:00 2001
From: Justin Anderson <jander@microsoft.com>
Date: Fri, 18 Jun 2021 09:31:45 -0700
Subject: [PATCH 2/5] Remove Display attributes on DiagnosticPortConnectionMode
 enum.

---
 .../OptionsDisplayStrings.Designer.cs          | 18 ------------------
 .../OptionsDisplayStrings.resx                 |  8 --------
 ...ft.Diagnostics.Monitoring.TestCommon.csproj |  4 ----
 .../DiagnosticPortConnectionMode.cs            |  9 ---------
 4 files changed, 39 deletions(-)

diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.Designer.cs b/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.Designer.cs
index eac7b198187..e6ed34c77b4 100644
--- a/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.Designer.cs
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.Designer.cs
@@ -87,24 +87,6 @@ public static string DisplayAttributeDescription_CorsConfiguration_AllowedOrigin
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to Launches in mode where dotnet-monitor will connect to a separate running dotnet process..
-        /// </summary>
-        public static string DisplayAttributeDescription_DiagnosticPortConnectionMode_Connect {
-            get {
-                return ResourceManager.GetString("DisplayAttributeDescription_DiagnosticPortConnectionMode_Connect", resourceCulture);
-            }
-        }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Launches in mode where dotnet-monitor will listen for connections from a separate running dotnet process. This configuration options requires environment variables be set on the target process..
-        /// </summary>
-        public static string DisplayAttributeDescription_DiagnosticPortConnectionMode_Listen {
-            get {
-                return ResourceManager.GetString("DisplayAttributeDescription_DiagnosticPortConnectionMode_Listen", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to In &apos;Connect&apos; mode, dotnet-monitor connects to the application for diagnostics. In &apos;Listen&apos; mode, the application connects to dotnet-monitor via EndpointName..
         /// </summary>
diff --git a/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.resx b/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.resx
index 5fe0b2fac17..7d8fbd34c8a 100644
--- a/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.resx
+++ b/src/Microsoft.Diagnostics.Monitoring.WebApi/OptionsDisplayStrings.resx
@@ -129,14 +129,6 @@
     <value>List of allowed CORS origins, separated by semicolons.</value>
     <comment>The description provided for the AllowedOrigins parameter on CorsConfiguration.</comment>
   </data>
-  <data name="DisplayAttributeDescription_DiagnosticPortConnectionMode_Connect" xml:space="preserve">
-    <value>Launches in mode where dotnet-monitor will connect to a separate running dotnet process.</value>
-    <comment>The description provided for enum DiagnosticPortConnectionMode's Connect value.</comment>
-  </data>
-  <data name="DisplayAttributeDescription_DiagnosticPortConnectionMode_Listen" xml:space="preserve">
-    <value>Launches in mode where dotnet-monitor will listen for connections from a separate running dotnet process. This configuration options requires environment variables be set on the target process.</value>
-    <comment>The description provided for enum DiagnosticPortConnectionMode's Listen value.</comment>
-  </data>
   <data name="DisplayAttributeDescription_DiagnosticPortOptions_ConnectionMode" xml:space="preserve">
     <value>In 'Connect' mode, dotnet-monitor connects to the application for diagnostics. In 'Listen' mode, the application connects to dotnet-monitor via EndpointName.</value>
     <comment>The description provided for the ConnectionMode parameter on DiagnosticPortOptions.</comment>
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
index 8206b86053f..43b4ec2cd46 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Microsoft.Diagnostics.Monitoring.TestCommon.csproj
@@ -15,10 +15,6 @@
     <PackageReference Include="xunit.assert" Version="$(XunitAssertVersion)" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\..\Microsoft.Diagnostics.Monitoring.WebApi\Microsoft.Diagnostics.Monitoring.WebApi.csproj" />
-  </ItemGroup>
-
   <Import Project="GenerateDotNetHost.targets" />
 
 </Project>
diff --git a/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs b/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
index 9bd906b50f9..466815c7194 100644
--- a/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
+++ b/src/Tools/dotnet-monitor/DiagnosticPortConnectionMode.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.Diagnostics.Monitoring.WebApi;
-using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Serialization;
 
 #if UNITTEST
@@ -15,14 +13,7 @@ namespace Microsoft.Diagnostics.Tools.Monitor
     [JsonConverter(typeof(JsonStringEnumConverter))]
     public enum DiagnosticPortConnectionMode
     {
-        [Display(
-            ResourceType = typeof(OptionsDisplayStrings),
-            Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_DiagnosticPortConnectionMode_Connect))]
         Connect,
-
-        [Display(
-            ResourceType = typeof(OptionsDisplayStrings),
-            Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_DiagnosticPortConnectionMode_Listen))]
         Listen
     }
 }

From 189f1d8277b7fc4b859d1ed702429ddc91b8432d Mon Sep 17 00:00:00 2001
From: Justin Anderson <jander@microsoft.com>
Date: Fri, 18 Jun 2021 10:04:45 -0700
Subject: [PATCH 3/5] Add more logging.

---
 .../Runners/AppRunner.cs                                 | 4 ++++
 .../EndpointInfoSourceTests.cs                           | 9 ++++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
index b152d6841fa..299db51e4f6 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.TestCommon/Runners/AppRunner.cs
@@ -73,8 +73,12 @@ public sealed class AppRunner : IAsyncDisposable
         /// </summary>
         public string ScenarioName { get; set; }
 
+        public int AppId { get; }
+
         public AppRunner(ITestOutputHelper outputHelper, Assembly testAssembly, int appId = 1)
         {
+            AppId = appId;
+
             _testAssembly = testAssembly;
             _outputHelper = new PrefixedOutputHelper(outputHelper, FormattableString.Invariant($"[App{appId}] "));
 
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
index 719563ff3f8..456103bb52b 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
@@ -253,12 +253,13 @@ public async Task<EndpointInfo> WaitForNewEndpointInfoAsync(AppRunner runner, Ti
                 lock (_addedEndpointInfoSources)
                 {
                     _addedEndpointInfoSources.Add(Tuple.Create(runner, addedEndpointInfoSource));
+                    _outputHelper.WriteLine($"Added endpoint registration for App{runner.AppId}");
                 }
 
-                _outputHelper.WriteLine("Waiting for new endpoint info.");
+                _outputHelper.WriteLine($"Waiting for new endpoint info for App{runner.AppId}");
                 timeoutCancellation.CancelAfter(timeout);
                 EndpointInfo endpointInfo = await addedEndpointInfoSource.Task;
-                _outputHelper.WriteLine("Notified of new endpoint info.");
+                _outputHelper.WriteLine($"Notified of new endpoint info for App{runner.AppId}");
 
                 return endpointInfo;
             }
@@ -275,7 +276,7 @@ internal override void OnAddedEndpointInfo(EndpointInfo info)
                         {
                             if (info.ProcessId == source.Item1.ProcessId)
                             {
-                                _outputHelper.WriteLine($"Notifying endpoint registration for process ID {info.ProcessId}");
+                                _outputHelper.WriteLine($"Notifying endpoint registration for App{source.Item1.AppId}");
                                 source.Item2.TrySetResult(info);
                                 _addedEndpointInfoSources.Remove(source);
                                 break;
@@ -286,6 +287,8 @@ internal override void OnAddedEndpointInfo(EndpointInfo info)
                             // Thrown in app runner hasn't started process yet.
                         }
                     }
+
+                    _outputHelper.WriteLine($"Finished searching for endpoint registrations for process {info.ProcessId}");
                 }
             }
 

From 93a31f0014fab199015875b06e19fa30917c99bc Mon Sep 17 00:00:00 2001
From: Justin Anderson <jander@microsoft.com>
Date: Fri, 18 Jun 2021 12:08:29 -0700
Subject: [PATCH 4/5] Move timeout to constant.

---
 .../EndpointInfoSourceTests.cs                                | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
index 456103bb52b..155a7fe7c83 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
@@ -20,6 +20,8 @@ public class EndpointInfoSourceTests
     {
         private static readonly TimeSpan DefaultNegativeVerificationTimeout = TimeSpan.FromSeconds(2);
 
+        private static readonly TimeSpan GetEndpointInfoTimeout = TimeSpan.FromSeconds(10);
+
         private readonly ITestOutputHelper _outputHelper;
 
         public EndpointInfoSourceTests(ITestOutputHelper outputHelper)
@@ -216,7 +218,7 @@ private AppRunner CreateAppRunner(string transportName = null, int appId = 1)
         private async Task<IEnumerable<IEndpointInfo>> GetEndpointInfoAsync(ServerEndpointInfoSource source)
         {
             _outputHelper.WriteLine("Getting endpoint infos.");
-            using CancellationTokenSource cancellationSource = new(TimeSpan.FromSeconds(10));
+            using CancellationTokenSource cancellationSource = new(GetEndpointInfoTimeout);
             return await source.GetEndpointInfoAsync(cancellationSource.Token);
         }
 

From a4f4b91e025b23ecf330806e441dc606f94e1a89 Mon Sep 17 00:00:00 2001
From: Justin Anderson <jander@microsoft.com>
Date: Fri, 18 Jun 2021 12:56:01 -0700
Subject: [PATCH 5/5] More test logging.

---
 .../EndpointInfoSourceTests.cs                | 29 +++++++++++--------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
index 155a7fe7c83..3545abb1404 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
@@ -255,48 +255,53 @@ public async Task<EndpointInfo> WaitForNewEndpointInfoAsync(AppRunner runner, Ti
                 lock (_addedEndpointInfoSources)
                 {
                     _addedEndpointInfoSources.Add(Tuple.Create(runner, addedEndpointInfoSource));
-                    _outputHelper.WriteLine($"Added endpoint registration for App{runner.AppId}");
+                    _outputHelper.WriteLine($"[Wait] Register App{runner.AppId}");
                 }
 
-                _outputHelper.WriteLine($"Waiting for new endpoint info for App{runner.AppId}");
+                _outputHelper.WriteLine($"[Wait] Wait for App{runner.AppId} notification");
                 timeoutCancellation.CancelAfter(timeout);
                 EndpointInfo endpointInfo = await addedEndpointInfoSource.Task;
-                _outputHelper.WriteLine($"Notified of new endpoint info for App{runner.AppId}");
+                _outputHelper.WriteLine($"[Wait] Received App{runner.AppId} notification");
 
                 return endpointInfo;
             }
 
             internal override void OnAddedEndpointInfo(EndpointInfo info)
             {
-                _outputHelper.WriteLine($"Added endpoint info to collection: {info.DebuggerDisplay}");
+                _outputHelper.WriteLine($"[Source] Added: {info.DebuggerDisplay}");
                 
                 lock (_addedEndpointInfoSources)
                 {
-                    foreach (var source in _addedEndpointInfoSources)
+                    _outputHelper.WriteLine($"[Source] Start notifications for process {info.ProcessId}");
+
+                    foreach (var sourceTuple in _addedEndpointInfoSources)
                     {
+                        AppRunner runner = sourceTuple.Item1;
+                        _outputHelper.WriteLine($"[Source] Checking App{runner.AppId}");
                         try
                         {
-                            if (info.ProcessId == source.Item1.ProcessId)
+                            if (info.ProcessId == sourceTuple.Item1.ProcessId)
                             {
-                                _outputHelper.WriteLine($"Notifying endpoint registration for App{source.Item1.AppId}");
-                                source.Item2.TrySetResult(info);
-                                _addedEndpointInfoSources.Remove(source);
+                                _outputHelper.WriteLine($"[Source] Notifying App{runner.AppId}");
+                                sourceTuple.Item2.TrySetResult(info);
+                                _addedEndpointInfoSources.Remove(sourceTuple);
                                 break;
                             }
                         }
                         catch (InvalidOperationException)
                         {
-                            // Thrown in app runner hasn't started process yet.
+                            // Thrown if app runner hasn't started process yet.
+                            _outputHelper.WriteLine($"[Source] App{runner.AppId} has not start yet.");
                         }
                     }
 
-                    _outputHelper.WriteLine($"Finished searching for endpoint registrations for process {info.ProcessId}");
+                    _outputHelper.WriteLine($"[Source] Finished notifications for process {info.ProcessId}");
                 }
             }
 
             internal override void OnRemovedEndpointInfo(EndpointInfo info)
             {
-                _outputHelper.WriteLine($"Removed endpoint info from collection: {info.DebuggerDisplay}");
+                _outputHelper.WriteLine($"[Source] Removed: {info.DebuggerDisplay}");
             }
         }
     }