diff --git a/eng/Versions.props b/eng/Versions.props
index 63180c4eb9e..ce8d838db70 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/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.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..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
@@ -2,11 +2,17 @@
 
   <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>
 
   <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..299db51e4f6 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,13 @@ internal sealed class AppRunner : IAsyncDisposable
         /// </summary>
         public string ScenarioName { get; set; }
 
-        public AppRunner(ITestOutputHelper outputHelper, int appId = 1)
+        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}] "));
 
             _adapter = new LoggingRunnerAdapter(_outputHelper, _runner);
@@ -106,6 +113,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 02cfede528d..4b746296179 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;
diff --git a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/ProcessTests.cs
index 2312a6ac9a3..bce2f8ac2c9 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;
@@ -101,7 +102,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 fc5fd235817..2d187827629 100644
--- a/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.Tool.UnitTests/Runners/ScenarioRunner.cs
@@ -6,6 +6,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;
@@ -37,7 +38,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 0eea5c20b38..d303e543e34 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..3545abb1404
--- /dev/null
+++ b/src/Tests/Microsoft.Diagnostics.Monitoring.UnitTests/EndpointInfoSourceTests.cs
@@ -0,0 +1,309 @@
+// 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 static readonly TimeSpan GetEndpointInfoTimeout = TimeSpan.FromSeconds(10);
+
+        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(GetEndpointInfoTimeout);
+            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($"[Wait] Register App{runner.AppId}");
+                }
+
+                _outputHelper.WriteLine($"[Wait] Wait for App{runner.AppId} notification");
+                timeoutCancellation.CancelAfter(timeout);
+                EndpointInfo endpointInfo = await addedEndpointInfoSource.Task;
+                _outputHelper.WriteLine($"[Wait] Received App{runner.AppId} notification");
+
+                return endpointInfo;
+            }
+
+            internal override void OnAddedEndpointInfo(EndpointInfo info)
+            {
+                _outputHelper.WriteLine($"[Source] Added: {info.DebuggerDisplay}");
+                
+                lock (_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 == sourceTuple.Item1.ProcessId)
+                            {
+                                _outputHelper.WriteLine($"[Source] Notifying App{runner.AppId}");
+                                sourceTuple.Item2.TrySetResult(info);
+                                _addedEndpointInfoSources.Remove(sourceTuple);
+                                break;
+                            }
+                        }
+                        catch (InvalidOperationException)
+                        {
+                            // Thrown if app runner hasn't started process yet.
+                            _outputHelper.WriteLine($"[Source] App{runner.AppId} has not start yet.");
+                        }
+                    }
+
+                    _outputHelper.WriteLine($"[Source] Finished notifications for process {info.ProcessId}");
+                }
+            }
+
+            internal override void OnRemovedEndpointInfo(EndpointInfo info)
+            {
+                _outputHelper.WriteLine($"[Source] Removed: {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 211687c010c..1ac41803b64 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>netcoreapp3.1;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>
 
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 0ed00b14987..34e3a9cd831 100644
--- a/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs
+++ b/src/Tools/dotnet-monitor/DiagnosticPortOptions.cs
@@ -5,7 +5,6 @@
 using Microsoft.Diagnostics.Monitoring.WebApi;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
-using System.Text.Json.Serialization;
 
 #if UNITTEST
 namespace Microsoft.Diagnostics.Monitoring.UnitTests.Options
@@ -31,18 +30,4 @@ public class DiagnosticPortOptions
             Description = nameof(OptionsDisplayStrings.DisplayAttributeDescription_DiagnosticPortOptions_MaxConnections))]
         public int? MaxConnections { get; set; }
     }
-
-    [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
-    }
 }
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 f0ed4ccda0a..782b6ebb5d0 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 9cd2596e5b4..b3a77f86454 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 baac8cb4858..3f2d74161e3 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 3e35f0f043a..a947a99734b 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